C语言指针五——指针应用：链表

ゞ浴缸里的玫瑰 2022-08-07 01:53 197阅读 0赞

**C语言指针五——指针应用：链表**

——从代码猜测作者的意图毕竟是一件痛苦的事，这也是为什么许多人接手别人的项目宁愿从头做起也不愿意使用现有代码的原因。

链表是一种重要的数据结构，它是许多其他数组结构的和算法的基础，其重要性不言而喻。对于新手来说，它的确是学习C语言的一道关卡——希望你不要被它所吓倒，从而失去对编程的兴趣。

要先学习链表，必先要学习C语言的结构，有了它，我们可以将学生也定义也一个C语言的数据类型。看如下的代码：

#include<stdio.h>
    struct student
    {
        char *name;//学生的姓名
        int age;//学生的年龄
        char *id;//学生的学号
    };
    void PrintStudent(studentstu)
    {
        printf_s("学生的姓名为：%s,学生的年龄为：%d,学生的学号为：%s\n", stu.name, stu.age,stu.id);
    }
    int main()
    {
        student stu;
        stu.name = "汪星人";
        stu.age = 18;
        stu.id = "12110031";
        PrintStudent(stu);
        return 0;
    }

上面的代码定义了一个结构student，并且定义了一个函数打印student变量。可以看到student结构中包含了学生的姓名-年龄-学号数组，此后，结构student就可以当作一个C语言的数组类型来使用了。在main函数里，声明了一个student类型的变量stu，并且对stu里面的成员进行了赋值，最后打印了stu变量里的内容。

链表是如下所示的数组结构:

![Center][]

这里每一个大长方形代表一个结构，箭头表示指针，那么上面表达的意思就是在结构的数据成员里，有一个指针项，这个指针会指向一个结构，如此，多个结构就构成了一个链表。

定义一个拥有指针的数据结构，只需要稍微修改一下上面的结构：

struct student
    {
        char *name;//学生的姓名
        int age;//学生的年龄
        char *id;//学生的学号
        struct student *next;//指向结构student类型的指针
    };

上面的声明中，next是一个指向结构student的指针，它不能指向其他的结构或者其他的数据类型。

链表的每一个项称作结点，构造一个具有3个结点的链表：

![Center 1][]

每一结点的next项指向下一个链表的结点，第一个结点称作表头(head)，这样我们就可以通过表头来遍历整个链表了，最后的结点的next项指向NULL表示那个是这个链表的尾(最后一项)。

手工创建上图的链表，代码如下：

#include<stdio.h>
    struct student
    {
        char *name;//学生的姓名
        int age;//学生的年龄
        char *id;//学生的学号
        struct student* next; //指向结构student类型的指针
    };
    void PrintStudent(studentstu)
    {
        printf_s("学生的姓名为：%s,学生的年龄为：%d,学生的学号为：%s\n", stu.name, stu.age,stu.id);
    }
    void PrintLink(struct student*head)
    {
        while (head!=NULL)
        {
           PrintStudent(*head);
           head = head->next;
        }
    }
    int main()
    {
        student stu,stu2,stu3;
        stu.name = "汪星人";
        stu.age = 18;
        stu.id = "12110031";
        //
        stu2.name = "喵星人";
        stu2.age = 19;
        stu2.id = "12110032";
        //
        stu3.name = "哈星人";
        stu3.age = 20;
        stu3.id = "12110033";
        student *head=&stu;
        stu.next = &stu2;
        stu2.next = &stu3;
        stu3.next = NULL;//将链表末尾的结点的指针成员指向NULL是非常的必要的，不然在使用链表时会发生错误。
        PrintLink(head);
        //PrintStudent(stu);
        return 0;
    }

上面的代码声明了3个student结构类型的变量，并且都已经赋值，然后利用&取地址运算符取得stu的作为链表的表头。表头的下一个结点是stu2，stu2的下一个结点是stu3，最后将stu3的成员next赋值为NULL,标识整个链表的结束。然后利用上面的PrintLink函数输出了整个链表的内容。注意到PrintLink函数利用head!=NULL来判断链表的结束与否，所以，表尾的NULL是非常有必要的，否则将不知道链表何时结束。

程序输出如下：

![Center 2][]

利用VS工具，在return 0;处设置断点，得到如下的关系图：

![Center 3][]

可以看到，链表这个名字对于这种数据结构来说是非常形象的，它一环扣一环，有开始有终点。

上面的代码是通过声明普通变量，然后再通过使用取地址运算符&来构建一个链表的，但大多数情况下，C程序更喜欢通过动态分配内存的方式来构建链表。有些时候，第一种构建链表的方式是行不通的，这时就不行不使用动态分配内存的方式来构建链表了。

为了通过动态内存的方式来构建链表，就必须要认识如下几个函数：

void* malloc(size_t Size);
    void* calloc(size_t nmemb,size_t Size);

这两个函数都是C语言的动态内存分配函数，其中malloc的形式参数Size是要分配的字节数，calloc形式的参数的意思是分配nmemb个Size大小的内存空间，这两个函数返回的都是所分配空间的首地址。所不同的是，calloc会对所全本的内存进行初始化，这样就确保了使用的安全。(在C++中，使用new关键字会更加方便，new 是C++动态内存分配的关键字)，下面使用malloc函数来构建链表，修改的main函数如下：

int main()
    {
        student *stu,*stu2,*stu3;
        stu = (student *)malloc(sizeof(struct student));//malloc函数返回void*，必须显式转换为student*;
        stu2 = (student *)malloc(sizeof(struct student));
        stu3 = (student *)malloc(sizeof(struct student));
        stu->name = "汪星人";
        stu->age = 18;
        stu->id = "12110031";
        //
        stu2->name = "喵星人";
        stu2->age = 19;
        stu2->id = "12110032";
        //
        stu3->name = "哈星人";
        stu3->age = 20;
        stu3->id = "12110033";
        student *head=stu;
        head->next = stu2;
        stu2->next = stu3;
        stu3->next = NULL;//将链表末尾的结点的指针成员指向NULL是非常的必要的，不然在使用链表时会发生错误。
        PrintLink(head);
        return 0;
    }

下面以stu变量为例，解释程序的行为：

首先是将stu声明为一个指向student的指针变量，它还没有初始化，还不能使用。然后使用malloc函数向操作系统申请了sizeof(struct student)大小的空间——它刚好是student变量所占的内存大小。然后将这个地址返回。因为它的返回值是void\*，所以必须将其转换为student\*才能赋值给stu。因为stu是一个存储了实际数据的地址，所以不能再用成员访问符“.”来访问name，age等student的成员了，毕竟stu没有成员。为了访问stu指向的student变量，可以将其转换成student后再使用，如(\*stu).name,或者使用->符号，通过指针->成员的形式来访问指向变量的数据成员。图解如下：

![Center 4][]

因为name和id是指针型变量，所以当它们被赋值后，更详细的内存快照如下：

![Center 5][]

Also see:

![Center 6][]

上面的修改后的程序的输出的原始程序的输出是一样的。

上面创建链表的方式很容易理解，他相当直观。但这种创建链表的方式有很多多的局限性。首先，你可能不知道你要创建的链表有多少个结点；其次，如果要使用这种方式来创建一个具有100个结点的链表，代码太过于繁琐。因此我们需要有一种方式，它可以动态(根据需要)地创建链表。下面编写一个学生资料录入程序，是一个动态创建链表的示例。

程序要求：

1.根据需求动态地创建链表的每一个结点

2.它基于命令行输入学生的信息（为了简单起见，结构只有一个成员：学号）

3.输入0代表数据输入完成；

程序代码如下;

#include<stdio.h>
    #include<stdlib.h>
    struct student
    {
        int id;//学生的学号
        struct student* next; //指向结构student类型的指针
    };
    void PrintStudent(studentstu)
    {
        printf_s("学生的学号为：%d\n",stu.id);
    }
    void PrintLink(struct student*head)
    {
        while (head!=NULL&&head->id!=0)
        {
           PrintStudent(*head);
           head = head->next;
        }
    }
    student* DataEntry()
    {//这个函数用于录入数据
        student *head, *curr, *next;
        head =curr= (student*)malloc(sizeof(struct student));//第一次分配的空间地址作为表头
        while (scanf_s("%d",&curr->id))//如果数据读入成功
        {
           if (curr->id==0)//如果是结束输入的标志
           {
               curr->next = NULL;//将当前结点curr设置为表尾
               break;
           }
           else
           {
               next = (student*)malloc(sizeof(struct student));//为下一个结点申请空间，并且返回内存空间的地址
               curr->next = next;//链接下一个结点
               curr = next;//为下一个结点赋值做准备
     
           }
        }
        return head;
    }
    int main()
    {
        student *head;
        head=DataEntry();
        PrintLink(head);
        return 0;
    }

调试程序，在命令行输入如下：

DataEntry函数的运行过程如下图：

![Center 7][]

图有点乱，我也凌乱了。

运行结果输出如下：

![Center 8][]

下面再次详细说明运行过程：

首先是第一次申请结点的空间，这个结点的空间地址将作为表头。申请空间后，现在有了空间存放数据了，在屏幕输入id数，此时的内存快照如下：

![Center 9][]

然后新申请一个内存空间(结点)，内存空间的首地址存入next中，并且将表头的next指向新申请的结点，此时内存快照如下：

![Center 10][]

然后curr指向新申请的结点，并且对新申请的结点的id项赋值，此时的内存快照如下：

![Center 11][]

再次新申请一个结点空间，返回空间的首地址给next，然后将curr结点的next项指向新申请的结点，此时内存快照如下：

![Center 12][]

然后curr指向新申请的结点，并且对新申请的结点的id项赋值，此时的内存快照如下：

![Center 13][]

再次申请一个结点空间，并且使next指向它，然后将curr结点的next项指向新申请的结点，新申请结点的id录入为0.于是新申请结点的next项值为NULL，构建链表结束，此时内存快照如下：

![Center 14][]

链表构建完成，本章到此结束！

[Center]: /images/20220805/d8ec5060ace44d4f81e93d7934542110.png
[Center 1]: /images/20220805/9d7492fd4f144e3593c7838921f28aa1.png
[Center 2]: /images/20220805/6cad336ac44243f28ac7f40e0e47b9eb.png
[Center 3]: /images/20220805/78375135b98747909fe73d0b08947afa.png
[Center 4]: /images/20220805/c79fdc7fd8b64b6898e8bee33d242328.png
[Center 5]: /images/20220805/6a907bc417944feab0f727cb7347c787.png
[Center 6]: /images/20220805/79ab90ed9ef6450d9f0527a658b3ea80.png
[Center 7]: /images/20220805/da782302415b448298d1d7ef7fd5395a.png
[Center 8]: /images/20220805/d467f3fab5b94eb08ade03ffc1a4ba69.png
[Center 9]: /images/20220805/5e5d3dc87c094073b2aff4c7dce457c3.png
[Center 10]: /images/20220805/44c68d1756854a2c8a5e60844d13b731.png
[Center 11]: /images/20220805/009378ad1f474f56a25f4dc72096bb9c.png
[Center 12]: /images/20220805/e72ad5dc69274dadb57818517eb91ead.png
[Center 13]: /images/20220805/400ccc87ff124623a17ef620bc802ebe.png
[Center 14]: /images/20220805/41f96379e885441bad48743421496af6.png