二、数据结构基础之单链表C语言实现

/*
 * 二、数据结构基础之单链表        
 * 单链表数据结构（结构的定义+在此结构上的操作）
 * --- 2012年4月22日 ---by lee
 */

#ifndef _LINKED_LIST_H
#define _LINKED_LIST_H

#include "Utility.h"

typedef int DataType;

//声明链表结点结构
typedef struct _ListNode
{
    DataType data;//数据域
    struct _ListNode *next;//指针域
} ListNode;

//声明链表结构，单链表由头指针唯一确定
//头结点不需要改变，改变的只是头指针的指向
typedef ListNode *LinkedList;


//单链表的数据操作

LinkedList InitLinkedList(void);//初始化一个带头结点的空链表，返回头指针
void SwapListNode(ListNode* lnode, ListNode* rnode);//交换链表结点中的元素
LinkedList CreateLinkedList(DataType* array, int arrayLength);//创建一个带头结点的单链表，并用数组中的数据来填充
LinkedList CreateLinkedListFromHead(void);//采用头插入法创建一个带头结点的单链表，返回头指针
LinkedList CreateLinkedListFromTail(void);//采用尾插入法创建一个带头结点的单链表，返回头指针
int GetLinkedListLength(LinkedList list);//返回单链表的长度（不包括头结点）
ListNode* GetListNode(LinkedList list, int index);//返回指向index位置结点的指针
ListNode* LocateListNode(LinkedList list, DataType x);//返回指向第一个值为x的结点的指针
void InsertListNode(LinkedList list, int index, DataType x);//在链表中位置index处插入值为x的结点
void DeleteListNode(LinkedList list, int index);//删除链表中位于index处的结点
void PrintLinkedList(LinkedList list);//打印输出链表
void ReverseLinkedList(LinkedList list);//实现单链表的逆置
void SortLinkedList(LinkedList list);//对单链表中的元素进行升序排序



//初始化一个带头结点的空链表，返回头指针
//无论链表是否为空，头指针都是指向头结点的非空指针，统一了对空表和非空表的处理
LinkedList InitLinkedList(void)
{
    //生成头结点，head指向头结点
    LinkedList head=(ListNode*)malloc(sizeof(ListNode));
    if(head == NULL)
        Error("Apply HeadNode Failed");
    head->next=NULL;
    return head;
}

//交换链表结点中的元素
void SwapListNode(ListNode* lnode, ListNode* rnode)
{
    if(lnode==NULL && rnode==NULL)
        Error("Node is null");
    
    DataType temp=lnode->data;
    lnode->data=rnode->data;
    rnode->data=temp;
}

//采用尾插入法创建一个带头结点的单链表，并用数组中的数据来填充
LinkedList CreateLinkedList(DataType* array, int arrayLength)
{
    LinkedList head=InitLinkedList();
    ListNode *p=NULL;
    ListNode *rear=head; //rear始终指向尾结点
    for(int i=0; i<arrayLength; i++)
    {
        p=(ListNode*)malloc(sizeof(ListNode));
        if(p == NULL)
            Error("Apply Node Failed");
        p->data=array[i];
        rear->next=p;
        rear=p;
    }
    rear->next=NULL;
    return head;
}

//采用头插入法创建一个带头结点的单链表，返回头指针
LinkedList CreateLinkedListFromHead(void)
{
    LinkedList head=InitLinkedList();
    DataType x;
    ListNode *p=NULL;
    int flag=1;
    while(flag)
    {
        printf("Input the value of node: ");
        scanf("%d",&x);
        p=(ListNode*)malloc(sizeof(ListNode));
        if(p == NULL)
            Error("Apply Node Failed");
        p->data=x;

        //在头结点后插入
        p->next=head->next;
        head->next=p;

        printf("\nIs continue? Yes:1; No:0\t Answer: ");
        scanf("%d",&flag);
    }
    return head;
}


//采用尾插入法创建一个带头结点的单链表，返回头指针
LinkedList CreateLinkedListFromTail(void)
{
    //生成头结点，head指向头结点
    LinkedList head=InitLinkedList();

    DataType x; //x为结点数据域的值
    ListNode *p=NULL; //p用来指向新建立的结点
    ListNode *rear=head; //rear始终指向尾结点
    int flag=1;
    while(flag)
    {
        printf("Input the value of node: ");
        scanf("%d",&x);
        p=(ListNode*)malloc(sizeof(ListNode));
        if(p == NULL)
            Error("Apply Node Failed");
        p->data=x;
        //在尾结点后插入
        rear->next=p;
        //rear始终指向尾结点
        rear=p;
        printf("\nIs continue? Yes:1; No:0\t Answer: ");
        scanf("%d",&flag);
    }
    //尾结点的指针域指向空
    rear->next=NULL;
    return head;
}

//返回单链表的长度（不包括头结点）
int GetLinkedListLength(LinkedList list)
{
    int length=0;
    ListNode *p=list->next;
    while(p != NULL)
    {
        p=p->next;
        length++;
    }
    return length;
}

//返回指向index位置结点的指针（index从0到length）
//index为0时，返回头结点的指针
ListNode* GetListNode(LinkedList list, int index)
{
    ListNode *p=list;

    int i=0;
    while((i<index) && (p->next!=NULL))
    {    
        p=p->next;
        i++;
    }
    if(i!=index)//i<0或者i>length-1时
        Error("Index Out of Bounds");
        
    return p;
}

//返回指向第一个值为x的结点的指针
ListNode* LocateListNode(LinkedList list, DataType x)
{
    ListNode *p=list->next;
    while((p!=NULL) && (p->data!=x))
    {
        p=p->next;
    }
    return p;//若p为NULL，则查找失败
}


//在链表中位置index处插入值为x的结点，index从1到length+1
void InsertListNode(LinkedList list, int index, DataType x)
{
    ListNode *node=(ListNode*)malloc(sizeof(ListNode));
    if(node==NULL)
        Error("Apply Node Failed");
    node->data=x;

    //获取指向插入位置前一个位置的结点指针
    ListNode *p=GetListNode(list,index-1);
    //插入结点
    node->next=p->next;
    p->next=node;

}


//删除链表中位于index处的结点，index从1到length
void DeleteListNode(LinkedList list, int index)
{
    //获取指向删除位置前一个位置的结点指针
    ListNode *p=GetListNode(list,index-1);
    //p指向最后一个结点，则出错
    if(p->next==NULL)
        Error("Illegal Deleted Position");
    
    ListNode *delNode=p->next;
    p->next=delNode->next;
    free(delNode);
}

//打印输出链表
void PrintLinkedList(LinkedList list)
{
    ListNode *p=list->next;
    while(p != NULL)
    {
        printf("%d\t",p->data);
        p=p->next;
    }
    printf("\n");
}

//实现单链表的逆置，改变了原链表的结构
//遍历一遍链表，改变指针的指向
void ReverseLinkedList(LinkedList list)
{
    //如果链表为空，则返回
    if(list->next==NULL)
        return;
    ListNode *p1=list->next;
    ListNode *p2=p1->next;//p2指向p1的下一个结点
    ListNode *r=NULL;//作为临时指针，保存p2的下一个结点
    p1->next=NULL;//头结点的下一个结点作为逆置后的尾结点置为NULL
    while(p2!=NULL)
    {
        r=p2->next;
        p2->next=p1;//指针反转
        //p1和p2后移一位
        p1=p2;
        p2=r;
    }
    //p1最后指向原链表的尾结点，将head指向p1
    list->next=p1;
}

//对单链表中的元素进行升序排序（冒泡排序），改变了链表的结构
void SortLinkedList(LinkedList list)
{
    //如果链表为空，则返回
    if(list->next==NULL)
        return;
    ListNode *p=NULL;
    int length=GetLinkedListLength(list);
    for(int i=1; i<length; i++)
    {
        p=list->next;
        for(int j=0; j<length-i; j++)
        {
            if(p->data > p->next->data)
            {
                //只是简单地交换两个结点的数据域
                SwapListNode(p,p->next);
            }
            p=p->next;
        }
    }
}

#endif

//测试代码
/*
    LinkedList head=CreateLinkedListFromTail();
    PrintLinkedList(head);
    printf("list length: %d\n",GetLinkedListLength(head));
    InsertListNode(head,1,9);
    InsertListNode(head,1,8);
    PrintLinkedList(head);
    DeleteListNode(head,1);
    PrintLinkedList(head);
    DeleteListNode(head,GetLinkedListLength(head)+2);
*/