线性表基础

线性表（linear list）是一种数据结构，是由 n 个具有相同特性的数据元素构成的序列。

线性表中元素的个数 n 即为线性表的长度，当 n = 0 时称为空表。线性表的相邻元素之间存在着序偶关系。

如用（ a[0] ，…… ，a[i-1] ，a[i] ，a[i+1] ，…… ，a[n-1] ）表示一个线性表，则称 a[i-1] 是 a[i] 的前驱，a[i+1] 是 a[i] 的后继。

线性表的特性

• 线性表中必存在唯一的一个“第一元素”；

• 线性表中必存在唯一的一个“最后元素” ；

• 除最后一个元素之外，均有唯一的后继；

• 除第一个元素之外，均有唯一的前驱。

线性表的一般操作

• 将线性表变为空表；

• 返回线性表的长度，即表中元素个数；

• 获取线性表某位置的元素；

• 定位某个元素在线性表中的位置；

• 在线性表中插入一个元素；

• 删除某个元素；

• 判断线性表是否为空；

• 遍历输出线性表的所有元素；

• 线性表排序。

线性表的表示方法

线性表可以用链表来实现。链表是通过指针链接在一起的一组数据项（结点）。

链表的每个结点都是同类型的结构，该结构中一般包含两类信息：

• 数据域，存储业务相关的数据（如财务系统的数据域为财务信息，车辆管理系统的业务信息为车辆信息）；

• 指针域，用于构建结点的链接关系。单链表的实现只需要一个指针。

由于数据域跟线性表的构建无关（靠指针域就够了），所以本关所有程序的实现中线性表的数据域都只有一个整数。

单链表的形式如下：

如上图所示，该单链表共包含了4个结点，4个结点的数据域分别是28、52、2、96。每个结点还包含一个指针，指向下一个结点。最后一个结点的指针域置为“NULL”，表示后面没有结点了。

第一个结点的地址存放在一个指针变量 head 中（ head 指向链表第一个结点， head 本身不是一个结点）。访问该单链表只需要知道 head 的值就可以了，因为通过 head 可以访问到第一个结点，通过第一个结点的指针域可以访问第二个结点 …… 直到访问链表中所有的结点。

要实现上述链表，只需要定义如下结构：

1. // 定义结点结构
2. struct node
3. {
4. int data; // 数据域
5. node * next; // 指针域，指向下一个结点
6. };

如下程序可以构建上述图中链表（其中：每个结点都是 node 类型的一个结构变量，head 则是node*类型的指针）：

1. node a, b, c, d, *head;
2. head = &a; // 让 head 指针指向结点 a
3. a.data = 28; // 给 a 的数据域赋值
4. a.next = &b; // 让 a 的指针域指向结点 b
5. b.data = 52; b.next = &c; // 给 b 的数据域赋值，并让 b 的指针域指向结点 c
6. c.data = 2; c.next = &d; // 给 c 的数据域赋值，并让 c 的指针域指向结点 d
7. d.data = 96; d.next = NULL; // 给 d 的数据域赋值，并将 d 的指针域置为 NULL，表示后面没有结点了

很显然，这样写程序比较麻烦，而且在不知道有多少结点的情况下也根本无法处理。怎么可以解决这个问题呢？

C 和 C++ 的内存动态分配方法可以很好的解决这个问题。C++ 提供了两种动态分配内存的方法：

1. C 语言提供的 malloc 和 free 函数，代码如下：

1. node *t = (node *)malloc(sizeof(node));
2. t->data = 2;
3. free(t);

• sizeof 是一个运算符，sizeof(node)用于计算并返回一个 node 类型变量所占内存空间的大小（字节数）；

• malloc(int n)用于申请动态分配 n 个字节大小的数据空间，并返回该空间的首地址；

• (node *)是类型转换运算符，malloc 函数返回的地址是void*类型，转换成node*类型后赋值给指针变量 t（ t 的类型是node*）。

所以上面第一条语句执行后，指针 t 指向一块动态分配的内存空间，该空间大小为一个 node 类型变量的大小。

第二条语句通过指针 t 访问该空间（当作 node 变量）的数据域 data，给它赋值为2。free 函数用于释放 t 指向的动态分配空间（不需要该空间后再释放）。

1. C++ 扩展的 new 和 delete 运算符，代码如下：

1. node *t = new node;
2. t->data = 2;
3. delete t;

那么使用动态内存分配的方法实现上述的单链表的代码如下：

1. node *head, *t, *p;
2. t = new node; // 动态分配一个 node 结点的空间，并让 t 指向它
3. head = t; // 该结点是第一个结点，让 head 指向它
4. t->data = 28; // 给第一个结点的数据域赋值
5. p = new node; // 动态分配第二个 node 结点的空间，并让 p 指向它
6. t->next = p; // 修改第一个结点的指针域为第二个结点的地址（第一个结点的指针域指向第二个结点）
7. p->data = 52; // 给第二个结点的数据域赋值
8. t=p; // 让 t 指向最后一个结点
9. p = new node; // 动态分配第三个 node 结点的空间，并让 p 指向它（ p 不再指向第二个结点了）
10. t->next = p; // 修改第二个结点的指针域为第三个结点的地址（第二个结点的指针域指向第三个结点）
11. p->data = 2; // 给第三个结点的数据域赋值
12. t = p; // 让 t 指向最后一个结点
13. p = new node; // 动态分配第四个 node 结点的空间，并让 p 指向它（ p 不再指向第三个结点了）
14. t->next = p; // 修改第三个结点的指针域为第四个结点的地址（第三个结点的指针域指向第四个结点）
15. p->data = 96; // 给第四个结点的数据域赋值
16. p->next = NULL; // 给第四个结点的指针域置为 NULL，表示后面没有结点了

上述程序语句虽然好像变多了，程序也好像变复杂了，但细读会发现这段程序可以很方便地改成循环，这样处理后其实是使得程序更简单了，并且适用于任意多个结点的情况。

改成循环后，单链表里面可能包含0个或多个结点，如果包含多个结点，则下面程序中的语句可以让指针 t 指向链表的最后一个结点，具体代码如下：

1. node *t = head; // t 指向第一个结点
3. // 如果 t->next 不为 NULL，即后面还有结点
4. while(t->next != NULL)
5. {
6. t = t->next; // 把 t 指向结点的指针域（下一个结点地址）赋值给 t，t 指向下一个结点
7. }
8. // 循环结束时，t->next 为 NULL，即 t 指向的结点后面没有结点了。