数据结构与算法 第四天 线性表——链表结构（二）

声明：所有理论笔记来源于《大话数据结构》

线性表的链式存储结构

1 线性表的顺序存储结构
    定义：用一组任意的存储单元存储线性表的数据元素，这组存储单元可以时连续的，也可以是不连续的。
    为了表示每个数据元素ai与其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称作指针域或链。这两部分信息组成数据元素ai的存储映像，称为节点（Node）。
    我们把连表中第一个结点的存储位置叫做头指针。线性表最后一个结点指针为“空”。
    有时候为了方便地对链表进行操作，会在单链表的第一个结点前附设一个结点，称为头结点。头结点数据域可以不存储任何信息

    线性表的顺序存储的结构代码。

    typedef int ElemType;   //ElemType类型根据实际情况而定，这里假设为int
    typedef struct Node{
        ElemType data;
        struct Node *next;
    } Node;
    typedef struct Node *LinkList;  //定义LinkList

    结点由存放数据元素的数据域和存放后继结点地址的指针域组成。

2 顺序存储结构的插入与删除
    2.1 获取链表第i个数据的算法思路：
        1.声明一个指针p指向链表第一个结点，初始化j从1开始；
        2.当j<i时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1；
        3.若到链表末尾p为空，则说明第i个结点不存在；
        4.否则查找成功，返回结点p的数据。

    代码：
    #define Ok 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    typedef int Status;
    /*
     * 初始条件：顺序线性表L已存在，1<= i <= ListLength(L)
     * 操作结果：用e返回L中第i个数据元素的值
     */
    Status GetElem(SqList L, int i, ElemType *e){
        int j;
        LinkList p; //声明一个指针p
        p = L->next;    //让p指向链表L的第一个结点
        j = 1;  //j为计数器
        while(p && j < i){  //p不为空且计数器j还没有等于i，循环继续
            p = p->next;    //让p指向下一个结点
            ++j;
        }

        if(!p || j > i){
            return ERROR;   //第i个结点不存在
        }

        *e = p->data;   //取第i个结点的数据

        return OK;
    }

    由于这个算法的时间复杂度取决于i的位置，当i=1时，则不需要遍历，第一个就取出来了，而当i=n时则遍历n-1次才可以。因此最坏情况的时间复杂度时O(n)。
    由于单链表的结构中没有定义表长，所以不能事先知道要循环多少次，因此也就不方便使用for循环。器主要核心思想就是“工作指针后移”，这其实也是很多算法的常用技术。

    2.2 单链表的插入
        单链表第i个数据插入结点的算法思路：
            1. 声明一指针p指向链表头结点，初始化j从1开始；
            2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；
            3. 若到链表末尾p为空，则说明第i个结点不存在；
            4. 否则查找成功，在系统中生成一个空结点s；
            5. 将数据元素e赋值给s->data;
            6. 单链表的插入标准语句s->next = p->next; p->next = s;
            7. 返回成功

        实现代码如下
        /* 初始条件： 顺序线性表L已存在， 1<=i<=ListLength(L),
         * 操作结果： 在L中第i个位置之前插入新的数据元素e，L的长度加1
         */
        Status ListInsert(SqList *L, int i, ElemType e){
            int j;
            LinkList p, s;
            p = *L;
            j = 1;

            //寻找第i-1个结点,因为是插入第一个位置可以没有元素，所以判断p是否为空
            while(p && j < i){
                p = p->next;
                ++j;
            }

            if(!p || j > i){
                return ERROR;   //第i个结点不存在
            }
            s = (LinkList)malloc(sizeof(Node)); //生成新结点（C标准函数）
            s->data = e;
            s->next = p-next;   //将p的后继结点赋值给s的后继
            p->next = s;    //将s赋值给p的后继
            return OK;
        }

    2.3 删除操作
        单链表第i个数据删除结点的算法思路：
            1. 声明一指针p指向链表头结点，初始化j从1开始；
            2. 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；
            3. 若到链表末尾p为空，则说明第i个结点不存在；
            4. 否则查找成功，将欲删除的结点p->next赋值给q；
            5. 单链表的删除标准语句p->next = q->next;
            6. 将q结点中的数据赋值给e，作为返回；
            7. 释放q结点；
            8. 返回成功。
        实现代码如下：
        /**
          * 初始条件：顺序线性表L已存在， 1 <= i <= ListLength(L)
          * 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
          */
        Status ListDelete(SqList *L, int i, ElemType *e){
            int j;
            LinkList p, q;
            p = *L;
            j = 1;
            //遍历寻找第i-1个结点，因为是删除，至少需要有一个元素，所以判断p->next是否存在
            //p->next是头指针，也就是第一个实际结点的位置
            while(p->next && j < i){
                p = p->next;
                ++j;
            }
            if(!(p->next) || j > i){
                return ERROR;   //第i个结点不存在
            }
            q = p->next;
            p->next = q->next;  //将q的后继赋值给p的后继
            *e = q->data;   //将q结点中的数据给e
            free(q);        //让系统回收此结点，释放内存
            return OK;
        }

        插入和删除的时间复杂度都是O(n)。如果在我们不知道第i个结点的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序结构是没有太大优势的。但如果，我们希望从第i个位置，插入10个结点，对与顺序存储结构意味着，每一次插入都需要移动n-i个结点，每次都是O(n)。而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。

    2.4 单链表的整表创建
        单链表整表创建的算法思路：
        1. 声明一指针p和计数器变量i；
        2. 初始化一空链表L；
        3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表；
        4. 循环：
            a 生成一新结点赋值给p；
            b 随机生成一数字赋值给p的数据域p->data;
            c 将p插入到头结点与前一新结点之间。
        实现代码如下：
        //随机产生n个元素的值，建立带表头结点的单链线性表L（头插法）
        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; //插入到表头
            }
        }

        尾插法实现如下
        //随机产生n个元素的值，建立带表头结点的单链表L(尾插法)
        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 = (Node *)malloc(sizeof(Node));   //生成新结点
                p->data = rand() % 100 + 1; //随机生成100以内的数字
                r = p;  //将当前的新结点定义为表尾终端的结点
                r->next = p;    //将表尾终端结点的指针指向新结点
            }
            r->next = NULL;
        }

    2.5 单链表的整表删除
        单链表整表删除的算法思路如下：
        1. 声明一结点p和q；
        2. 将第一个结点赋值给p；
        3. 循环：
            a 将下一个结点赋值给q；
            b 释放p；
            c 将q赋值给p。

        算法实现如下：
        //初始条件：顺序线性表L已存在，操作结果：将L重置为空表
        Status ClearList(LinkList *L){
            LinkList p, q;
            p = (*L)->next; p指向第一个结点
            while(p){   //没到表尾
                q = p->next;
                free(p);
                p = q;
            }
            (*L)->next = NULL;  //头结点指针域为空
            return OK;
        }
3. 实现中遇到的问题
    3.1 插入元素后打印，无限打印0？
        q = (LinkList)malloc(sizeof(Node)); //生成新结点
        q->data = e;
        q->next = p->next;  //把p的后继给新生成元素的后继
        p->next = p;    //把新生成元素作为p的后继

        在实现插入的时候最后把p赋给了p->next，正确的应该把q赋给->next.
        难道这就是书中用s不用q的原因？