《数据结构》第二章：线性表

第2章：线性表

2.1 线性表的定义和基本操作

线性表是具有相同数据类型的n个数据元素的有限序列。n为表长，当n=0时该线性表是一个空表。a1是唯一的『第一个』数据元素，又称表头元素。An是唯一的『最后一个』数据元素，又称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后驱。
线性表的特点：
1) 表中元素个数有限。
2) 表中元素具有逻辑上的顺序性，在序列中个元素排序有其先后次序。
3) 表中元素都是数据元素，每个元素都是单个元素。
4) 表中的数据类型都相同。每一个元素占有相同大小的存储空间。
5) 表中元素具有抽象性。即讨论元素间的逻辑关系，不考虑元素究竟表示什么内容。
线性表是一种逻辑结构，表示元素间一对一的相邻关系。顺序表和链表是指存储结构，两者属于不同层面的概念。
线性表的基本操作：
InitList(&L)：初始化表。构造一个空的线性表。
Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数。
LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素。
GetElem(L,i)：按位查找操作。获取表L中的第i个位置的元素的值。
ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。
ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
PrintList(L)：输入操作。按前后顺序输出线性表L的所有元素值。
Empty(L)：判空操作。若L为空表，则返回true，否则返回false。
Destroy(&L)：销毁操作。销毁线性表，并释放线性表L所占用的内存空间。
基本操作的实现取决于采用哪一种存储结构，存储结构不同，算法的实现也不同。『&』表示C++中的引用。如果传入的变量是指针类型的变量，且在函数体内要对传入的指针进行改变，则将用到指针变量的引用。

2.2 线性表的顺序表示

线性表的顺序存储又称顺序表，是用一组地址连续的存储单元，依次存储线性表中的数据元素。顺序表的表中元素的逻辑顺序与物理顺序相同。
假定线性表的元素类型为ElemType，

线性表的顺序存储类型描述为

1 #define MaxSize 50          //定义线性表的最大长度
2 typedef struct {
3   ElemType data[MaxSize];   //顺序表的元素
4   int length;               //顺序表的当前长度
5 }SqList;                    //顺序表的类型定义

动态分配线性表

1 #define InitSize 100        //表长度的初始定义
2 typedef struct {
3   ElemType *data;           //指示动态分配数组的指针
4   int MaxSize, length;      //数组的最大容量和当前个数
5 } SqList;  

C的初始动态分配语句为

1 L.data = (ElemType*)malloc(sizeof(ElemType)*InitSize);

C++的初始动态分配语句为

1 L.data = new ElemType[InitSize];

『1』插入操作
在顺序表L的第i(1<=i<=L.length+1)个位置插入新元素e。如果i的输入不合法，则返回false，表示插入失败。
否则将顺序表的第i个元素以及气候的所有元素右移一个位置，腾出一个空位置插入新元素e，顺序表的长度增加1，插入成功，返回true

 1 bool ListInsert(SqList &L, int i, ElemType e) {
 2   //本算法实现将元素e插入到顺序表L中的第i个位置
 3   if(i<1||i>L.length+1)   //判断i的范围是否有效
 4     return false;
 5   if(L.length >= MaxSize) //当前存储空间已满，不能插入
 6     return false;
 7   for(int j = L.length; j >= i; j++) {
 8     L.data[j] = L.data[j-1];
 9   }
10   L.data[i-1] = e;
11   L.length++;
12   return true;
13 }

线性表插入算法的平均时间复杂度为O(n)。

『2』删除操作
删除顺序表L中的第i(1<=i<=L.length)个位置的元素，成功则返回true，并将被删除的元素用引用变量e返回，否则返回false

 1 bool ListDelete(SqList &L, int i; ElemType &e) {
 2   //本算法实现删除顺序表L中的第i个位置的元素
 3   if(i<1||i>L.length)                 //判断i的范围是否有效
 4     return false;
 5   e = L.data[i-1];                    //将被删除的元素赋值给e
 6   for(int j = i; j < L.length; j++) { //将第i个位置之后的元素前移
 7     L.data[j-1] = L.data[j];
 8   }
 9   L.length--;                         //线性表长度减一
10   return true;
11 }

线性表删除操作的平均时间复杂度为O(n)

『3』按值查找（顺序查找）
在顺序表L中查找第一个元素值等于e的元素，并返回其位序

 1 int LocateElem(SqList L, ElemType e) {
 2   //本算法实现查找顺序表中值为e的元素，如果查找成功，返回元素位序，否则返回0
 3   int i;
 4   for(int i = 0; i < L.length; i++) {
 5     if(L.data[i] == e) {
 6       return i+1;
 7     }
 8   }
 9   return 0;
10 }

线性表按值查找算法的平均时间复杂度为O(n)

单链表中结点类型的描述如下：

1 typedef struct LNode {    //定义单链表结点类型
2   ElemType data;          //数据域
3   struct LNode *next;     //指针域
4 }LNode, *LinkList;

动态分配并不是链式存储，仍属于顺序存储结构，其物理结构没有变化，依然是随机存取，只是在分配的空间大小可以在运行时决定。
顺序表的最主要特点是酥记访问，即通过首地址和元素序号可以在O(1)的时间内找到指定的元素。
顺序表的存储密度高，每隔结点只存储数据元素。
顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除操作需要移动大量元素。

2.3 线性表的链式表示

线性表的链式存储又称单链表，是通过一组任意的存储单元来存储线性表中的数据元素。
单链表中借点类型的描述如下：

1 typedef struct LNode {    //定义单链表结点类型
2   ElemType data;          //数据域
3   struct LNode *next;     //指针域
4 }LNode, *LinkList;

由于单链表的元素是离散地分布在存储空间中的，所以单链表是非随机存取的存储结构，即不能直接找到表中某个特定的结点。查找某个特定的结点时，需要从表头开始遍历，依次查找。
『1』采用用头插法建立单链表

 1 LinkList CreatList1(LinkList &L) {
 2   //从表尾到表头逆向建立单链表L，每次均在头结点之后插入元素
 3   LNode *s;
 4   int x;
 5   L = (LinkList)malloc(sizeof(LNode));  //创建头结点
 6   L->next = NULL;                       //初始为空链表
 7   scanf("d", &x);                       //输入结点的值
 8   while (x != 9999) {                   //输入9999表示结束
 9     s = (LNode)malloc(sizeof(LNode));   //创建新结点
10     s->data = x;
11     s->next = L->next;
12     L-next = s;                         //将新结点插入表中，L为头指针
13     scanf("d", &x);
14   }                                     //while结束
15   return L;
16 }

采用头插法建立单链表，读入数据的顺序与生成链表中元素的顺序是相反的。每个结点插入的时间为O(1)，设单链表长为n，则总的时间复杂度为O(n)

『2』采用尾插法建立单链表

 1 LinkList CreatList2(LinkList &L) {
 2   //从表头到表尾正向建立单链表L，每次均在表尾插入元素
 3   int x;                              //设元素类型为整形
 4   L = (LinkList)malloc(sizeof(LNode));
 5   LNode *s, *r = L;                   //r为表尾指针
 6   scanf("%d", &x);                    //输入结点的值
 7   while (x != 9999) {                 //输入9999表示结束
 8     s = (LNode*)malloc(sizeof(LNode));
 9     s->data = x;
10     r->next = s;
11     r = s;
12     scanf("%d", &x);
13   }
14   r->next = NULL;                     //尾结点指针置空
15   return L;
16 }

与头插法时间复杂度相同，为O(n)

『3』按序号查找结点值
在单链表中从第一个结点出发，顺指针next域诸葛往下搜索，直到找到第i个结点为止，否则返回最后一个结点指针域NULL

 1 LNode *GetElem(LinkList L, int i) {
 2   //本算法取出单链表L（带头结点）中第i个位置的结点指针
 3   int j = 1;              //计数，初始为1
 4   LNode *p = L->next      //头结点指针赋给p
 5   if (i == 0)
 6     return L;             //若i等于0，则返回头结点
 7   if (i < 1)
 8     return NULL;          //若i无效，则返回NULL
 9   while (p&&j<i) {        //从第1个结点开始找，查找第i个结点
10     p = p->next;
11     j++;
12   }
13   return p;               //返回第i个结点的指针，如果i大宇表长，p=NULL，直接返回p即可
14 }

『4』按值查找表结点
从单链表的第一个结点开始，由前往后依次比较表中各结点数据域的值，若某结点数据域的值等于给定值e，
则返回该借点的指针；若整个单链表中没有这样的结点，则返回NULL。

1 LNode *LocateElem(LinkList L, ElemType e) {
2   //本算法查找单链表（带头结点）中数据域值等于e的结点操作指针，否则返回NULL
3   LNode *p = L->next;
4   while (p != NULL && p->data != e) //从第1个结点开始查找data域为e的结点
5     p = p->next;
6   return p;                         //找到返回该结点指针，否则返回NULl
7 }

『5』插入结点操作

插入操作是将值为x的新结点插入到单链表的第i个位置上。先检查插入位置的合法性，然后找到待插入位置的前驱结点，
即第i-1个结点，再在气候插入新结点。
前插操作

1 p = GetElem（L,i-1;    //查找插入位置的前驱结点
2 s->next = p->next;
3 p->next = s;

后插操作

1 s->next = p->next;    //修改指针域，不能颠倒
2 p->next = s;
3 temp = p->data;       //交换数据域部分
4 p->data = s->data;
5 s->data = temp;

『6』删除结点操作

1 p = GetElem(L,i-1);   //查找删除位置的前驱结点
2 q = p->next;          //令q指向被删除结点
3 p->next = q->next;    //将*q结点从链中『断开』
4 free(q);              //释放结点的存储空间

删除结点*p
删除结点*p的操作可以用删除结点*p的后继结点操作来实现，实质是将其后继结点的值赋予其自身，
然后删除后继结点，也能使得时间复杂度为O(1)

1 q=p->next;
2 p->data=p->next->data;
3 p->next=q->next;
4 free(q);

双链表：为克服单链表的访问某结点的前驱结点的时间复杂度为O(n)的缺点引入双链表，双链表结点中有两个指针prior和next，分别指向某前驱结点和后继结点。
双链表中结点类型的描述如下：

1 typedef struct DNode {            //定义双链表结点类型
2   ElemType data;                  //数据域
3   struct DNode *prior, *next;     //前驱和后继指针
4 }DNode, *DLinklist;

『1』双链表的插入操作

在双链表中p所指的结点之后插入结点*s

1 s->next=p->next;        //将结点*s插入到结点*p之后
2 p->next->prior=s;
3 s->prior=p;
4 p->next=s;

『2』双链表的删除操作

1 p->next=q->next;
2 q->next->prior=p;
3 free(q);

循环链表：循环链表和单链表的区别在于表中最后一个结点的指针不是NULL，而改为指向头结点从而整个链表形成一个环。循环单链表的判断条件不是头结点的指针是否为空，而是它是否等于头指针。
循环双链表：在循环双链表中，头结点的prior指针指向表尾结点。
静态链表：静态链表接住数组来描述线性表的链式存储结构。指针域next是结点的相对地址（数组下标），又称游标。
静态链表结构类型的描述如下：

1 #define MaxSize 50          //静态链表的最大长度
2 typedef struct {            //静态链表结构类型的定义
3   ElemType data;            //存储数据元素
4   int next;                 //下一个元素的数组下标
5 } SLinkList[MaxSize];

顺序表和链表的比较：
1) 存取方式不同。顺序表可以顺序存取，也可以随机存取，链表只能从表头顺序存取元素。
2) 逻辑结构与物理结构：采用顺序存储时，逻辑上相邻的元素，其对应的物理存储位置也相邻。而采用链式存储时，逻辑上相邻的元素其物理存储位置不一定相邻，对应的逻辑关系是通过指针链接来表示的。
3) 查找、插入和删除操作：对于按值查找，当顺序表在无序的情况下，两者的时间复杂度均为O(n)；当顺序表有序时采用折半查找，时间复杂度为O(logN)。
对于按序号查找，顺序表只吃随机访问，时间复杂度仅为O(1)，而链表的平均时间复杂度为O（n）。顺序表的插入、删除操作，平均需要移动半个表厂的元素。链表的插入、删除操作，只需要修改相关结点的指针域即可。由于链表每个节点带有指针域，因而在存储空间上比顺序存储要付出较大的代价，存储密度不够大。
4) 空间分配：顺序存储在静态存储器分配情形下，一旦存储空间装满就不能扩充。动态存储分配虽然可以扩充，但需要移动大量元素，导致操作效率降低。链式存储的借点空间只在需要时申请分配，只要内存有空间就可以分配，操作灵活、高效。
在实际中应怎样选取存储结构？
1) 基于存储的考虑：对线性表的长度或存储规模难以估计时，不宜采用顺序表。链表不用实现估计存储规模，但链表的存储密度较低。
2) 基于运算的考虑：若经常按序号访问数据元素，则顺序表优于链表。插入、删除操作时链表优于顺序表。（基于时间复杂度）
3) 基于环境的考虑：顺序表容易实现，链表的操作基于指针。顺序表实现较为简单。