数据结构总结——单链表/循环链表/双向链表

总体构成：

1. 头节点：不作数据的存储，存储链表的公共数据信息，如：长度；另外还有，还包括头指针，指向第一个数据节点；
2. 数据节点：顾名思义是存数据的，链表最后的节点的指针域为NULL；

节点的构成：

1. 数据域：存储数据元素信息
2. 指针域：存储下一节点的地址

操作流程：

遍历的流程
1. 通过头节点的指针域得到第一个元素
2. 在通过第一个元素的数据域得到第一个元素的数据，通过第一个元素的指针域得到第二个元素；
3. 以此类推，
4. 直到得到目标元素或最后最后一个节点为止；

添加流程
1. 根据遍历的流程，查找到要添加的节点的位置；
2. 声明一个新节点，新元素添加到该新节点中；
3. 将此位置后面元素的指针，添加到新节点后面（即：新节点的指针域中）；
4. 将新节点的指针，添加到此位置前面元素的指针域；

删除流程
1. 根据遍历的流程，查找到要删除的节点的位置；
2. 取出删除的节点后面所有元素（下面称为：AfterNodes）；
3. 将AfterNodes的指针赋值给删除节点前一元素节点的指针域；
4. 释放删除元素的内存；

优势与缺点：
对于所谓的优势与劣势，都是对比出来的，在此我们拿顺序存储结构来比较：
读取时：
并没有优势，因为首先需要遍历链表，找到需要读取的节点的位置；时间复杂度为O(n)，
而顺序存储结构，可直接使用下标，其时间复杂度为O(1)；

添加和删除：
单链表：也是要遍历后才得到添加或者删除的位置后（时间复杂度为O(n)，才进行添加删除操作（时间复杂度为O(1)）；
顺序存储结构：移动元素，时间复杂度为O(n)；
个人见解：综合起来两者性能没有太大区别，

如果添加删除操作频繁时，单链表性能就体现出来了，
如果无法预知长度，单链表也是也是比较好的选择！

#include <stdlib.h>
#include <time.h>

#define MAXSIZE 20
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node *next;
} Node;
typedef Node *LinkList;

// 
Status GetElem(LinkList L, int i, ElemType *e)
{
    LinkList p;         // 声明一个指针p
    p = L->next;        // 让p指向链表L中的第一个节点
    int j = 1;          // 计数器

    while( p && j < i)  // p不为NULL（最后的节点），且还没有等于i时，循环继续
    {
        p = p->next;
        ++j;
    }
    if (!p || j > i)
    {
        return ERROR;   // 第i个节点不存在
    }
    *e = p->data;       // 取出第i个节点的数据
    return OK;
}

// 头插法
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    int i;
    srand(time(0));                 // 初始化随机数种子
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;              // 建立一个带表头节点的单链表
    for(i = 0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(Node)); // 生成新节点
        p->data = rand() % 100 + 1; // 随机生成100以内的数字
        p->next = (*L)->next;
        (*L)->next = p;             // 插入到表头
    }
}
// 尾插法
void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;                                 // r指向尾部节点
    for(i = 0; i < n; i++)
    {
        p = (LinkList)malloc(sizeof(Node)); // 生成新节点
        p->data = rand() % 100 + 1;         // 随机生成100以内的数字
        r->next = p;                        // 将表尾端节点的指针指向新节点
        r = p;                              // 将当前的新节点定义为尾表终端节点（r指向尾部节点）
    }
    r->next = NULL;
}
// 清除链表
Status ClearList(LinkList *L)
{
    LinkList p, q;
    p = (*L)->next;
    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }
    (*L)->next = NULL;
    return OK;
}

// 在我们不知道第i个节点的指针位置时，
// 单链表数据结构在插入和删除操作上，
// 与线性表的顺序结构是没有太大的优势的；

// 但是，在第i个位置插入10个节点时，
// 线性表的顺序结构在每次插入时都需要移动n-i个节点，时间复杂度为O(n)
// 单链表，在找到i的位置后，只要简单的通过赋值移动指针而已，时间复杂度为O(1)
// 在这里，单链表的优势才体现出来。
Status ListInsert(LinkList *L, int i, ElemType e)
{
    int j;
    LinkList p, s;
    p = *L;
    j = 1;

    while(p && j < i)
    {
        p = p->next;
        ++j;
    }

    if (!p || j > i)
        return ERROR; // i节点不存在

    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;

    return OK;
} 

Status ListDelete(LinkList *L, int i, ElemType *e)
{
    int j;
    LinkList p, q;
    p = *L;
    j = 1;

    while(p->next && j < i)
    {
        p = p->next;
        ++j;
    }

    if (!p->next || j > i)
        return ERROR;

    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}

循环链表
与单链表不同的就是尾节点的区别而已，尾节点指向头节点，其他均相同；

void CreateList(DuLinkList *L, int n)
{
    DuLinkList p, r;
    int i;
    srand(time(0));
    *L = (DuLinkList)malloc(sizeof(DulNode));
    r = *L;                                 // r指向尾部节点
    for(i = 0; i < n; i++)
    {
        p = (DuLinkList)malloc(sizeof(DulNode));    // 生成新节点
        p->data = rand() % 100 + 1;         // 随机生成100以内的数字
        p->prev = r;                        // （双向链表新增加）前驱
        r->next = p;                        // 将表尾端节点的指针指向新节点
        r = p;                              // 将当前的新节点定义为尾表终端节点（r指向尾部节点）
    }
    r->next = *L; // （循环链表新增加）尾节点指向头节点
}

双向链表
与单链表的不同也不大，结构如下：

typedef struct DulNode
{
    ElemType data;
    struct DulNode *prev;
    struct DulNode *next;
} DulNode, *DuLinkList;

相比单链表的后继，多了前驱的操作（prev），代码如下：

Status ListInsert(DuLinkList *L, int i, ElemType e)
{
    int j;
    DuLinkList p, s;
    p = *L;
    j = 1;

    while(p && j < i)
    {
        p = p->next;
        ++j;
    }

    if (!p || j > i)
        return ERROR; // i节点不存在

    s = (DuLinkList)malloc(sizeof(DulNode));
    s->data = e;
    s->prev = p;            // 把p赋值给s的前驱
    s->next = p->next;      // 把p->next赋值给s的后继
    p->next->prev = s;      // 把s赋值给p->next的前驱
    p->next = s;            // 把s赋值给p的后继

    return OK;
} 

Status ListDelete(DuLinkList *L, int i, ElemType *e)
{
    int j;
    DuLinkList p, q;
    p = *L;
    j = 1;

    while(p->next && j < i)
    {
        p = p->next;
        ++j;
    }

    if (!p->next || j > i)
        return ERROR;

    q = p->next;
    *e = q->data;
    //p->next = q->next;            // 单链表
    p->prev->next = p->next;        // 把p->next赋值给p->prev的后继
    p->next->prev = p->prev;        // 把p->prev赋值给p->next的前驱
    free(q);
    return OK;
}