线性表--链式存储结构--单链表

线性表--链式存储结构--单链表

一、定义

1.特点：

• 用一组任意的存储单元存储线性表的数据元素，这组存储单元可以存在内存中未被占用的任意位置。
• 比起顺序存储结构每个数据元素只需要存储一个位置就可以了。现在链式存储结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址（指针）。
• 也就是说除了存储其本身的信息外，还需存储一个指示其直接后继的存储位置的信息。

2.定义：

• 我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称为指针或链。这两部分信息组成数据元素称为存储映像，称为结点(Node)。
• n个结点链接成一个链表，即为线性表(a1, a2, a3, …, an)的链式存储结构。
• 因为此链表的每个结点中只包含一个指针域，所以叫做单链表。

单链表.png

我们把链表中的第一个结点的存储位置叫做头指针，最后一个结点指针为空(NULL)。

单链表结构.png

头结点的数据域一般不存储任何信息

3.头指针与头结点的异同

头指针

• 头指针是指链表指向第一个结点的指针，若链表有头结点，则是指向头结点的指针。
• 头指针具有标识作用，所以常用头指针冠以链表的名字（指针变量的名字）。
• 无论链表是否为空，头指针均不为空。
• 头指针是链表的必要元素。

头结点

• 头结点是为了操作的统一和方便而设立的，放在第一个元素的结点之前，其数据域一般无意义（但也可以用来存放链表的长度）。
• 有了头结点，对在第一元素结点前插入结点和删除第一结点起操作与其它结点的操作就统一了。
• 头结点不一定是链表的必须要素。

二、单链表存储结构

单链表图例.jpg

空链表图例.jpg

C语言中可以用结构指针来描述单链表：

typedef struct Node
{
    ElemType data;      // 数据域
    struct Node* Next;  // 指针域
} Node;
    typedef struct Node* LinkList;

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

例1：假设p是指向线性表第i个元素的指针，则该结点ai的数据域我们可以用p->data的值是一个数据元素，结点ai的指针域可以用p->next来表示，p->next的值是一个指针。

那么p->next指向第i+1个元素。也就是指向ai+1的指针。

例2：如果p->data = ai，那么p->next->data = ?
p->next->data = ai+1。

三、单链表的操作--读取、插入和删除

1.读取

对于单链表实现获取第i个元素的数据的操作GetElem，在算法上相对要麻烦一些：

获得链表第i个数据的算法思路：

1. 声明一个结点p指向链表第一个结点，初始化j从1开始；
2. 当j
3. 若到链表末尾p为空，则说明第i个元素不存在；
4. 否则查找成功，返回结点p的数据。

使用代码实现GetElem.c：

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值 */

Status GetElem( LinkList L, int i, ElemType *e )
{
    int j;
    LinkList p;

    p = L->next;
    j = 1;

    while( p && jnext;
        ++j;
    }

    if( !p || j>i )
    {
        return ERROR;
    }

    *e = p->data;

    return OK;
}

就是从头开始找，直到第i个元素为止：

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

2.插入

单链表的插入：假设存储元素e的结点为s，要实现结点p、p->next和s之间逻辑关系的变化，如图：

结点之间的逻辑关系.jpg

要将结点s插入到ai和ai+1之间，只需要让s->next和p->next的指针做一点改变。
s->next = p->next;
p->next = s;
如图：

插入操作.jpg

这两句代码的顺序可不可以交换过来？
先p->next = s;
再s->next = p->next;

如果先执行p->next的话会先被覆盖为s的地址，那么s->next = p->next其实就等于s->next = s了。

所以这两句是无论如何不能弄反的。

单链表第i个数据插入结点的算法思路：

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

代码实现：

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */

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

    p = *L;
    j = 1;

    while( p && jnext;
        j++;
    }

    if( !p || j>i )
    {
        return ERROR;
    }

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

    s->next = p->next;
    p->next = s;

    return OK;
}

3.删除

单链表的删除.png

假设元素a2的结点为q，要实现结点q删除单链表的操作，其实就是将它的前继结点的指针绕过指向后继结点即可。

那我们所要做的，实际上就是一步：

可以这样：p->next = p->next->next;
也可以是：q=p->next; p->next=q->next;

单链表第i个数据删除结点的算法思路：

1. 声明结点p指向链表第一个结点，初始化j=1；
2. 当j<1时，就遍历链表，让P的指针向后移动，不断指向下一个结点，j累加1；
3. 若到链表末尾p为空，则说明第i个元素不存在；
4. 否则查找成功，将欲删除结点p->next赋值给q；
5. 单链表的删除标准语句p->next = q->next；
6. 将q结点中的数据赋值给e，作为返回；
7. 释放q结点。

代码实现：

/* 初始条件：顺序线性表L已存在，1<=i<=ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度-1 */

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

    p = *L;
    j = 1;

    while( p->next && jnext;
        ++j;
    }

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

    q = p->next;
    p->next = q->next;

    *e = q->data;
    free(q);

    return OK;
}

效率问题：

无论是单链表插入还是删除算法，它们其实都是由两个部分组成：

第一部分就是遍历查找第i个元素，
第二部分就是实现插入和删除元素。

它们的时间复杂度都是O(n)。

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

四、单链表的整表创建

单链表的存储结构，它的数据可以是分散在内存各个角落的，他的增长也是动态的。对于每个链表来说，它所占用空间的大小和位置是不需要预先分配划定的，可以根据系统的情况和实际的需求即时生成。

单链表的整表创建：
创建单链表的过程是一个动态生成链表的过程，从“空表”的初始状态起，依次建立各元素结点并逐个插入链表。

单链表整表创建的算法思路如下：

1. 声明一结点p和计数器变量i；
2. 初始化一空链表L；
3. 让L的头结点的指针指向NULL，即建立一个带头结点的单链表；
4. 循环实现后继结点的赋值和插入。

①头插法建立单链表
头插法从一个空表开始，生成新结点，读取数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头上，直到结束为止。
就是把新加进的元素放在表头后的第一个位置：

1. 先让新节点的next指向头节点之后
2. 然后让表头的next指向新节点

代码实现：

/* 头插法建立单链表示例 */

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;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

头插法演示.png

②尾插法建立单链表
头插法建立链表虽然算法简单，但生成的链表中结点的次序和输入的顺序相反。
我们可以把思维逆过来：把新结点都插入到最后，这种算法称之为尾插法。

尾插法演示.png

代码实现：

/* 尾插法建立单链表演示 */

void CreateListTail(LinkList *L, int n)
{
    LinkList p, r;
    int i;

    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    r = *L;

    for( i=0; i < n; i++ )
    {
        p = (Node *)malloc(sizeof(Node));
        p->data = rand()%100+1;
        r->next = p;
        r = p;                 // 
    }

    r->next = NULL;
}

五、单链表的整表删除

当我们不打算使用这个单链表时，我们需要把它销毁；其实也就是在内存中将它释放掉，以便于留出空间给其他程序或软件使用。

单链表整表删除的算法思路如下：

1. 声明结点p和q；
2. 将第一个结点赋值给p，下一结点赋值给q；
3. 循环执行释放p和将q赋值给p的操作；

代码实现：

Status ClearList(LinkList *L)
{
    LinkList p, q;

    p = (*L)->next;

    while(p)
    {
        q = p->next;
        free(p);
        p = q;
    }

    (*L)->next = NULL;

    return OK;
}

这段算法代码里，常见的错误就是有同学会觉得q变量没有存在的必要，只需要在循环体内直接写free(p); p = p->next; 即可？
p是一个结点，它除了有数据域，还有指针域。当我们做free(p);时，其实是对它整个结点进行删除和内存释放的工作。而我们整表删除是需要一个个结点删除的，所以我们就需要q来记载p的下一个结点。

六、单链表结构与顺序存储结构优缺点

分别从存储分配方式、时间性能、空间性能三方面来做对比：

1.存储分配方式：

• 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素。
• 单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

2.时间性能：

查找：

• 顺序存储结构O(1)
• 单链表O(n)

插入和删除：

• 顺序存储结构需要平均移动表长一半的元素，时间为O(n)
• 单链表在计算出某位置的指针后，插入和删除时间仅为O(1)

3.空间性能：

• 顺序存储结构需要预分配存储空间，分大了，容易造成空间浪费，分小了，容易发生溢出。
• 单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。

结论：

• 若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构。
• 若需要频繁插入和删除时，宜采用单链表结构。
• 比如说游戏开发中，对于用户注册的个人信息，除了注册时插入数据外，绝大多数情况都是读取，所以应该考虑用顺序存储结构。
• 而游戏中的玩家的武器或者装备列表，随着玩家的游戏过程中，可能会随时增加或删除，此时再用顺序存储就不太合适了，单链表结构就可以大展拳脚了。
• 当线性表中的元素个数变化较大或者根本不知道有多大时，最好用单链表结构，这样可以不需要考虑存储空间的大小问题。
• 而如果事先知道线性表的大致长度，比如一年12个月，一周就是星期一至星期日共七天，这种用顺序存储结构效率会高很多。

总之，线性表的顺序存储结构和单链表结构各有其优缺点，不能简单的说哪个好，哪个不好，需要根据实际情况，来综合平衡采用哪种数据结构更能满足和达到需求和性能。