【算法和数据结构】_5_线性结构_单链表

/*
本程序用来测试线性存储结构：链表
*/

#include <stdio.h>
#include <stdlib.h>

//*************************************************
//       定义处理字符的链表数据类型

struct singlelink
{
short int data;
struct singlelink* next;
};//单链表

struct doublelink
{
int data;
struct doublelink* prenode;
struct doublelink* postnode;
};//双链表

typedef struct singlelink  SIGLINK;
typedef SIGLINK* PSIGLINK;
typedef struct doublelink  DBLLINK;
//**************************************************

//**************************************************
//        定义申请地址空间宏

#define  MALLOC(pNode,Type,size)\
if(NULL==\
(pNode=(Type *)malloc(sizeof(Type)*size))\
)\
{\
return FALSE;\
}
//**************************************************

//**************************************************
//        定义BOOL数据类型

typedef enum {FALSE,TRUE} BOOL;
//**************************************************

SIGLINK* CreateSingleLink(void);
BOOL InitSigLink(SIGLINK* head,char element[]);
void EchoSigLink(PSIGLINK head);
BOOL AppendToEnd(PSIGLINK head,char element);
PSIGLINK SearchNodeSig(PSIGLINK head,char element);
BOOL DelNodeSig(PSIGLINK head,char element);
BOOL DestroySigLink(PSIGLINK head);
BOOL  IsSigLinkEmpty(PSIGLINK head);

int main(int argc,char* argv[])
{
PSIGLINK head;

if(NULL==(head=CreateSingleLink()))
{
puts("Error.\n");
}

if(IsSigLinkEmpty(head))
puts("Yes.\n");

if(!InitSigLink(head,"Hello wold"))
{
puts("Error.\n");
}

EchoSigLink(head);

AppendToEnd(head,'A');
EchoSigLink(head);

if(SearchNodeSig(head,'e'))
puts("Exist element");

DelNodeSig(head,'A');
EchoSigLink(head);

if(DestroySigLink(head))
if(IsSigLinkEmpty(head))
puts("Yes.\n");
EchoSigLink(head);

getchar();
getchar();
return 0;
}

//**************************************************
/*
函数功能：
创建链表的表头，
并将表头的数字域设置为 '\0' 、表头下一个指向域为空
函数原型：
SIGLINK* CreateSingleLink(void)
函数参数：
无参数
返回值：
如果创建表头成功，则返回表头指针;否则返回空指针
异常：
无
*/
SIGLINK* CreateSingleLink(void)
{
SIGLINK* head;

head=(SIGLINK*)malloc(sizeof(SIGLINK));

if(NULL==head)
{
return NULL;
}

head->next=NULL;
head->data ='\0';

return head;
}
//**************************************************

//**************************************************
/*
函数功能：
初始化链表：申请节点空间和设置值域
函数原型：
BOOL InitSigLink(SIGLINK* head,char element[])
函数参数：
SIGLINK* head:要初始化的链表头指针
char element[]:用来初始化链表以'\0'结尾的字符串
返回值：
如果初始化成功，则返回TRUE；否则返回FALSE
异常：
传递空指针
*/
BOOL InitSigLink(SIGLINK* head,char element[])
{
PSIGLINK temp,
end;

int i;

if(NULL==head || element==NULL )
{
return FALSE;
}

end=head;

for(i=0; element[i] != '\0';i++)
{
MALLOC(temp,SIGLINK,1);

temp->data='\0';
temp->next =NULL;

end->data=element[i];
end->next=temp;

end=temp;
}

return TRUE;
}
//**************************************************

//**************************************************
/*
函数功能：
显示链表
函数原型：
void EchoSigLink(PSIGLINK head)
函数参数：
PSIGLINK head: 要显示的链表的头指针
返回值：
无
异常：
传递空指针
*/
void EchoSigLink(PSIGLINK head)
{
PSIGLINK temp;

if(NULL==head)
{
puts("Error.\n");
return ;
}
else
{
temp=head;
while(NULL != temp->next )
{
printf("%c",temp->data );
temp=temp->next ;
}
putchar('\n');
return ;
}
}
//**************************************************

//**************************************************
/*
函数功能：
获取最后一个节点的指针
函数原型：
PSIGLINK  GetEndNode(PSIGLINK head)
函数参数：
PSIGLINK head:链表头指针
返回值：
如果执行成功，则返回尾指针；否则返回NULL
异常：
无
*/
PSIGLINK  GetEndNode(PSIGLINK head)
{
PSIGLINK temp;

if(!(temp=head))
{
return NULL;
}
else
{
while(temp->next)
{
temp=temp->next ;
}
return temp;
}
}
//**************************************************

//**************************************************
/*
函数功能：
在链表的尾端增加节点
函数原型：
BOOL AppendToEnd(PSIGLINK head,char element)
函数参数：
PSIGLINK head:要增加元素的链表的头节点
char element:要增加的元素
返回值：
成功增加返回TRUE，否则返回FALSE
异常：
无
*/
BOOL AppendToEnd(PSIGLINK head,char element)
{
PSIGLINK end,
temp;

end=GetEndNode(head);
if(!end)
{
return FALSE;
}
else
{
//分配空间，并设置最后一个节点
MALLOC(temp,SIGLINK,1)
temp->data='\0';
temp->next =NULL;

//将最后一个节点设置为新增的节点
end->data =element;
end->next=temp;
return TRUE;
}
}
//**************************************************

//**************************************************
/*
函数功能：
查找元素，
函数原型
PSIGLINK SearchNodeSig(PSIGLINK head,char element)
函数参数：
PSIGLINK head：待查找头指针
char element：要查找的元素
返回值：
如果存在就返回节点指针，否则返回NULL
异常：
传递空指针
*/
PSIGLINK SearchNodeSig(PSIGLINK head,char element)
{
PSIGLINK temp;

temp=head;

//设计仅有表头节点的时候，不存储元素
//所以可以这样判断
if(!temp || !temp->next )
return NULL;

while(temp->next)
{
if(element == temp->data )
{
return temp;
}
temp=temp->next ;
}
return NULL;
}
//**************************************************

//**************************************************
/*
函数功能：
在指定的元素后面插入节点，
1、如果指定元素存在就将节点插入到指定元素之后
2、如果指定元素不存在就插入到链表最后
函数原型：
BOOL InsertNodeSig(PSIGLINK head,char element)
函数参数
PSIGLINK head：表头指针
char element：指定元素
返回值：
插入成功，则返回TRUE，否则返回FALSE
异常：
无
*/
BOOL InsertNodeSig(PSIGLINK head,char elementPos,char element)
{
PSIGLINK temp,
NewNode;

if(!head)
{
return FALSE;
}

//处理仅有头节点的情况
if(!head->next)
{
if(AppendToEnd(head,element))
return TRUE;
else
return FALSE;
}
/*
//处理仅有一个节点的情况
//无论是否存在指定元素，都将插入一个节点
if(head->next->next ==NULL)
{
MALLOC(NewNode,SIGLINK,1);
NewNode->data =element;
NewNode->next=head->next ;

head->next =NewNode;
free(NewNode);
return TRUE;
}

*/
temp=SearchNodeSig(head,elementPos);
if(temp)
{
//存在指定元素
MALLOC(NewNode,SIGLINK,1);
NewNode->data =element;
NewNode->next =temp->next;

temp->next =NewNode;

free(NewNode);
return TRUE;
}
else
{
//如果不存在指定元素，将元素插入到最后
if(AppendToEnd(head,element))
return TRUE;
else
return FALSE;
}
}
//**************************************************

//**************************************************
/*
函数功能：
删除指定元素
函数原型：
BOOL DelNodeSig(PSIGLINK *head,char element)
函数参数:
PSIGLINK *head: 链表头指针
char element：要删除的元素
返回值：
如果删除成功，则返回TRUE；否则返回FALSE
异常：
无
*/
BOOL DelNodeSig(PSIGLINK head,char element)
{
PSIGLINK temp,
DeNode;

//仅有头节点
if(!head->next)
{
return  FALSE;
}

//仅有一个节点
if(!head->next->next)
{
if(head->data == element)
{
DeNode=head;
head=head->next;

free(DeNode);
return TRUE;
}
else
{
return FALSE;
}
}

temp=head;
while(temp->next)
{
if(temp->next->data ==element)
{
DeNode=temp->next ;
temp->next =temp->next ->next ;

free(DeNode);
return TRUE;
}
temp=temp->next ;
}
return FALSE;
}
//**************************************************

//**************************************************
/*
函数功能：
销毁链表
函数原型：
BOOL DestroySigLink(PSIGLINK head)
函数参数：
PSIGLINK head: 待销毁链表头指针
返回值：
成功销毁，返回TRUE，否则返回FALSE
异常：
无
*/
BOOL DestroySigLink(PSIGLINK head)
{
PSIGLINK temp;
if(NULL== head)
{
return FALSE;
}
else
{
if(head->next ==NULL)
return TRUE;
else
{
while(NULL != head->next->next )
{
temp=head->next ;
head->next=head->next->next;
free(temp);
}
temp=head->next ;
head->next =NULL;
head->data ='\0';

free(temp);
return TRUE;
}
}
}
//**************************************************

//**************************************************
/*
函数功能：
判断是否为空表
1、仅有头节点时表为空
函数原型
BOOL  IsSigLinkEmpty(PSIGLINK head)
函数参数：
PSIGLINK head：链表头指针
返回值：
如果为空，返回TRUE，否则返回FALSE
异常：
无
*/
BOOL  IsSigLinkEmpty(PSIGLINK head)
{
if(head && NULL==head->next )
return TRUE;
else
return FALSE;
}
//**************************************************