【算法和数据结构】_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;
}
//**************************************************

运行结果如下所示：