顺序构建线性表（线性表实训）

按照数据输入的顺序构建一个线性表。即如果输入的333个结点数据分别为1、2、3，则构建的线性表包含333个结点，且从前往后的结点数据分别为1、2、3。

相关知识

线性表（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]的后继。

线性表的特性

1. 线性表中必存在唯一的一个“第一元素”；
2. 线性表中必存在唯一的一个 “最后元素” ；
3. 除最后一个元素之外，均有唯一的后继；
4. 除第一个元素之外，均有唯一的前驱。

线性表的一般操作

6. 将线性表变为空表；
7. 返回线性表的长度，即表中元素个数；
8. 获取线性表某位置的元素；
9. 定位某个元素在线性表中的位置；
10. 在线性表中插入一个元素；
11. 删除某个元素；
12. 判断线性表是否为空；
13. 遍历输出线性表的所有元素；
14. 线性表排序。

线性表的链表表示

线性表可以用链表来实现。链表是通过指针链接在一起的一组数据项（结点）。链表的每个结点都是同类型的结构，该结构中一般包含两类信息:
一类称为数据域，存储业务相关的数据（如财务系统的数据域为财务信息，车辆管理系统的业务信息为车辆信息）;另一类称为指针域，用于构建结点的链接关系。单链表的实现只需要一个指针。
由于数据域跟线性表的构建无关（靠指针域就够了），所以程序的实现中线性表的数据域都只有一个整数。
单链表的形式如下：

如上图所示，该单链表共包含了4个结点，4个结点的数据域分别是28、52、2、96。每个结点还包含一个指针，指向下一个结点。最后一个结点的指针域置为NULL，表示后面没有结点了，第一个结点的地址存放在一个指针变量head中（head指向链表第一个结点，head本身不是一个结点）。访问该单链表只需要知道head的值就可以了，因为通过head可以访问到第一个结点，通过第一个结点的指针域可以访问第二个结点……直到访问链表中所有的结点。
要实现上述链表，只需要定义如下结构：

// 定义结点结构
    struct node
    {
        int data;  // 数据域
        node * next;  // 指针域,指向下一个结点
    };

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

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

很显然，这样写程序比较麻烦，而且在不知道有多少结点的情况下也根本无法处理。怎么可以解决这个问题呢？C语言或者C++内存的动态分配方法可以很好的解决这个问题。

C++提供了两种动态内存的方法：

1. 一种是C语言提供的malloc和free函数；
2. 一种是C++扩展的new和delete运算符。

C语言提供的动态内存方法（malloc和free函数）

代码如下：

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

其中：

1. sizeof是一个运算符；
2. sizeof(node)用于计算并返回一个node类型变量所占内存空间的大小（字节数）；
3. malloc(int n)用于申请动态分配n个字节大小的数据空间，并返回该空间的首地址；
4. (node )是类型转换运算符，malloc函数返回的地址是void类型，转换成node类型后赋值给指针变量t（t的类型是node）。

所以上面第一条语句执行后，指针t指向一块动态分配的内存空间，该空间大小为一个node类型变量的大小。第二条语句通过指针t访问该空间（当作node变量）的数据域data，给它赋值为2。free函数用于释放t指向的动态分配空间（不需要该空间后再释放）。
除了malloc和free函数，C++中的new和delete可以实现同样功能，代码如下：

node *t = new node;
t->data = 2;
delete t;

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

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

上述程序语句虽然好像变多了，程序也好像变复杂了，但细读会发现这段程序可以很方便地改成循环，这样处理后其实是使得程序更简单了，并且适用于任意多个结点的情况。
改成循环后，单链表里面可能包含0个或多个结点，如果包含多个结点，则下面程序中的语句可以让指针t指向链表的最后一个结点，具体代码如下：

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

测试输入：
5
1 2 3 4 5
预期输出：
List: 1 2 3 4 5
测试输入：
3
8 7 6
预期输出：
List: 8 7 6

#include <iostream>
//#include "linearList.h"
using namespace std;
// 定义结点结构
struct node
{
    int data;  // 数据域
    node * next;  //指针域,指向下一个结点
};
// 函数insertTail：链表尾部插入
// 参数：h-链表头指针，t-指向要插入的结点
// 返回值：插入结点后链表的首结点地址
node *insertTail(node *h, node *t);
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h);
// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h);
int main()
{
    int n,i;
    node *t;
    node *head=NULL; // 头指针为NULL，表示线性表为空，结点数为0
    // 输入结点数
    cin>>n;
    for(i=0;i<n;i++)
    {
     // 为新节点动态分配空间
        t = new node;
  	cin>>t->data;  // 输入结点数据
  	t->next=NULL;  // 结点指针域值为空
  	// 调用函数插入结点
  	head = insertTail(head, t);
    }
    // 输出链表
    printList(head);
    // 删除结点，释放空间
    delList(head);
    return 0;
}
// 函数delList：删除链表，释放空间
// 参数：h-链表头指针
void delList(node *h)
{
    node *p=h;  // 指针p指向头结点，第一个要删除的结点
    while(p)  // 这个结点是存在的
    {
  	h = h->next;  // 头指针h指向下一个结点（下一个结点的地址存在当前结点的指针域中，即h->next中
        delete p;  // 删除p指向的结点
        p = h;  // p指向当前的头结点，即下一个要删除的结点
    }
}
// 函数printList：输出链表，每个数据之间用一个空格隔开
// 参数：h-链表头指针
void printList(node *h)
{
    cout<<"List:"; 
    while(h)
    {// h为真，即h指向的结点存在，则输出该结点的数据
        cout<<" "<<h->data;  // 输出结点数据
        h=h->next;  // 将该结点的指针域赋值给h，h就指向了下一个结点
    }
    cout<<endl; // 输出换行符
}
node *insertTail(node *h, node *t)
{
    if(h == NULL) // 空链表单独处理
    {
        t->next = NULL; // 链表尾指针置为NULL
        return t; // 返回第一个结点的地址（即链表头指针）
    }
    // 非空链表的情况
    node *p = h;
    // 让p指向最后一个结点
    while(p->next)
    {
        p = p->next;
    }
    p->next = t; // 让最后一个结点的指针域指向结点t
    t->next = NULL; // 链表尾指针置为NULL
    return h;  // 返回第一个结点的地址（即链表头指针）
}