目录
注：
本笔记参考：《数据结构（C语言版）（第2版）》
线性表的应用
线性表的合并
例子：求一般集合的并集问题
已知有两个集合A和B，现要求一个新的集合 A = AUB。例如：
【通过代码进行描述】
对于其中用到的函数，可以参考笔记2-1。
void MergeList (List &LA, List LB)
{//将所有在线性表LB中但不在LA中的数据元素插入到LA中
m = ListLength(LA);
n = ListLength(LB); //求线性表的长度
for (i = 1; i <=n; i++)
{
GetElem(LB, i, e); //取LB中第i个元素，并将其赋给e
if (!LocateElem(LA, e)) //判断LA中是否存在元素，其的值等于e
ListInsert(LA, ++m, e); //将e插在LA的最后
}
}线性表LA和LB分别代表集合A和B。
现在我们通过扩大表LA，以此接收来自LB的在LA中不存在的数据元素。方法就是提取LB中的每个数据元素，依值在LA中进行查访，若在LA中不存在该数据元素，就进行插入操作。
【算法分析】
上述算法的时间复杂度取决于抽象数据类型List定义中基本操作的执行时间，假设LA和LB的表长分别为m和n，循环执行n次，则：
当采用顺序存储结构时
在循环的过程中，GetElem函数和ListInsert函数的执行时间与表长无关，LocateElem函数的执行时间和LA的表长有关（和m成正比），因此，该算法的时间复杂度为 O(m*n) 。
当采用链式存储结构时
GetElem函数的执行时间与LB的表长有关（和n成正比），LocateElem函数和ListInsert函数的执行时间与LA的表长有关（和m成正比）。因此，当 m > n 时，该算法的时间复杂度也是 O(m*n) 。
有序表的合并
有序表的定义：若线性表中的数据元素相互之间可以比较，并且数据元素在线性表中依值非递减或非递增有序排列，则称该线性表为有序表（Ordered List）。
如果我们设有序表的长度是 n ，数组存在元素 nums[i] 则：
- 非递减排列的定义：对于数组中所有的 i（0 <= i <= n-2），总满足 nums[i] <= nums[i+1]；
- 非递增排列的定义：对于数组中所有的 i（0 <= i <= n-2），总满足 nums[i] >= nums[i+1]。
例子：求解有序集合的并集问题
1. 顺序有序表的合并
有序集合是指集合中的元素有序排列。
现有有序非递减集合A和B，要求一个新的集合 C = AUB ，使集合C中的数据元素依旧非递减有序排列。例如：
【问题分析】
因为此时LA和LB有序，所以可以不用从LB中依次取数据元素，到LA中进行查访。
设指针pa和pb分别指向LA和LB中的某个元素，设pa当前所指的元素为a，pb当前所指的元素为b，则当前插入LC中的元素c为：
void MergeList_Sq(SqList LA, SqList LB, SqList &LC)
{//已知顺序有序表LA和LB的元素按值非递减排列
//归并LA和LB得到新的顺序有序表LC，LC的元素也按值非递减数列
LC.length = LA.length + LB.length; //设置LC长度
LC.elem = new ElemType[LC.length]; //为LC存储分配空间
pc = LC.elem; //指针pc指向新表的第一个元素
pa = LA.elem;
pb = LB.elem; //指针pa和pb的初值分别指向两个表的第一个元素
pa_last = LA.elem + LA.length - 1;
pb_last = LB.elem + LB.length - 1; //指针pa_last和pb_last分别指向两个表的最后一个元素
while((pa <= pa_last) && (pb <= pb_last)) //LA和LB均为到达表尾
{
if(*pa <= *pb)
*pc++ = *pa++;
else
*pc++ = *pb++; //取较小值填入LC的最后
}
while(pa <= pa_last) //LB已到达表尾，依次将LA的剩余元素插入LC的最后
*pc++ = *pa++;
while(pb <= pb_last) //类似于上一步
*pc++ = *pb++;
}【算法分析】
由于LA和LB中的元素依值非递减，所以不需要再在LA中对LB中的元素进行全程搜索。如果LA和LB两个表长分别记为m和n，则算法最多执行的总次数为m+n，所以算法的时间复杂度为 O(m+n) 。
此算法在归并时，需要开辟新的辅助空间，空间复杂度是 O(m+n) 。如果使用链表，就可以使空间复杂度达到最低。
2. 链式有序表的合并
此时假设头指针为LA和LB的单链表分别为线性表LA和LB的存储结构，现在要归并LA和LB得到单链表LC。
void MergeList_L(LinkList &LA, LinkList &LB, LinkList &LC)
{//已知单链表LA和LB的元素按值非递减排列
//归并所得单链表LC也按值非递减排列
pc = LA->next;
pb = LB->next; //pa和pb的初值分别指向两个表的第一个结点
LC = LA; //用LA的头结点作为LC的头结点
pc = LC;
while(pa && pb) //LA和LB均为到达表尾
{
if(pa->data <= pb->data) //取pa所指结点
pc->ext = pa;
pc = pa;
pa = pa->next;
else //取pb所指结点
{
pc->next = pb;
pc = pb;
pb = pb->next;
}
}
pc->next = pa?pa:pb; //将非空表的剩余段插入到pc所指结点之后
delete LB; //释放LB的头结点
}【算法分析】
可以看出，该算法的时间复杂度和上一个算法相同，但是空间复杂度不同。由于在建立新表时，不需要新建结点空间，而只需要接触原本两个链表之间的关系，重新组合即可，所以空间复杂度是 O(1) 。
案例分析和实现
例1：一元多项式的计算
一元多项式可以抽象成一个线性表。在计算机中，我们可以使用数组来表示一元多项式的线性表。
例如：
将上述多项式P(x)通过数组表示：
| 指数（下标i） | 0 | 1 | 2 | 3 | 4 |
| 系数p[i] | 10 | 5 | -4 | 3 | 2 |
例2：稀疏多项式的运算
和一元多项式类似地，稀疏多项式也可以抽象成一个线性表。但和归并两个有序表不同的是，有序表在比较数据元素时只会出现两种情况（≤，＞），而稀疏多项式在比较多项式指数时却需要考虑三种情况（＝、＜、＞）。
一般而言，链式存储结构的灵活性使它更适合表示一般的多项式，且合并过程的空间复杂度也只有O(1)。
例如：存在两个链表分别表示多项式A(x)和B(x)：
在上图中，每个结点表示多项式中的一项。
多项式相加的运算规则：
对于两个多项式中：
- 所有指数相同的项：对应系数相加，若其和不为0，则插入到“和多项式”列表中；
- 两个指数不同的项：将指数值较小的项插入到“和多项式”链表中。
通过上述规则形成的链表无需生成结点，而是从两个多项式的链表中“摘取”结点。
【接下来对例子进行实现】
用链表实现多项式，对应的数据结构定义为：
typedef struct PNode
{
float coef; //系数
int expn; //指数
struct PNode* next; //指针域
}PNode,*Polynomial;1. 多项式的创建
注：区别于一般链表的创建方式，多项式链表是一个有序表，每项的位置需要经过比较才能确认。
void GreatePolyn(Polynomial& P, int n)
{//输入n项的系数和指数，建立表示多项式的有序链表P
P = new PNode;
P->next = NULL; //先建立一个只有头结点的空链表
int i = 0;
for (i = 1; i <= n; i++) //依次输入n个非零项
{
Polynomial s = new PNode; //生成新节点
cin >> s->coef >> s->expn;
Polynomial pre = P;
Polynomial q = P->next;
while (q && q->expn < s->expn) //通过比较指数找到一个大于输入项指数的项*q
{
pre = q;
q->next;
}
s->next = q;
pre->next = s; //将输入项s插入到q和其前驱结点pre之间
}
}【算法分析】
创建一个项数为n的有序多项式链表，需要执行n次循环输入各项，而每次循环还需要比较前后输入项与各项的系数。最坏的情况下，第n次循环需要比较n次，此时时间复杂度就是 O(n²) 。
2. 多项式的相加
通过上述算法创建两个多项式链表。假设头指针为Pa和Pb的单链表分别为 多项式A和B的存储结构 ，指针p1和p2分别指向 A和B中当前进行比较的某个节点 。
void AddPolyn(Polynomial& Pa, Polynomial& Pb)
{//多项式加法：Pa = Pa + Pb，利用两个多项式的结点构成“和多项式”
Polynomial p1 = Pa->next;
Polynomial p2 = Pb->next; //p1和p2分别指向Pa和Pb的首元结点
Polynomial p3 = Pa; //p3指向“和多项式”的当前结点，初值为Pa
while (p1 && p2) //p1和p2均不为空
{
if (p1->expn = p2->expn) //指数相等
{
float sum = p1->coef + p2->coef;
if (sum) //系数和不为0
{
p1->coef = sum;
p3->next = p1; //将修改后的Pa当前结点链在p3之后
p3 = p1; //p3指向p1
p1 = p1->next; //p1指向后一项
Polynomial r = p2;
p2 = p2->next;
delete r; //删除Pb当前结点，p2指向后一项
}
else //系数和为0
{
Polynomial r = p1;
p1 = p1->next;
delete r; //删除Pa当前结点，p1指向后一项
Polynomial r = p2;
p2 = p2->next;
delete r; //删除Pb当前结点，p2指向后一项
}
}
else if (p1->expn < p2->expn) //Pa当前结点的指数值较小
{
p3->next = p1;
p3 = p1;
p1 = p1->next;
}
else //Pb当前结点的指数值较小
{
p3->next = p2;
p3 = p2;
p2 = p2->next;
}
p3->next = p1 ? p1 : p2; //插入非空多项式的剩余段
delete Pb; //释放Pb的头结点
}
}
【算法分析】
假设两个多项式的项数分别为m和n，则该算法的时间复杂度为 O(m+n) ，空间复杂度为 O(1) 。
两个多项式的减法和乘法运算，都可以利用多项式加法的算法来实现。
- 多项式的减法运算只需要对多项式的每项系数取反，然后调用加法函数进行计算即可；
- 多项式的乘法运算可以分为一系列的加法运算，例如：
其中，每一项都是一个一元多项式。
总结
| 顺序表 | 链表 | ||
| 空间 | 存储空间 | 预先分配、会导致空间闲置或溢出现象。 | 动态分配、不会出现存储空间闲置或溢出现象。 |
| 存储密度 | 不用为表示结点间的逻辑关系而增加额外的存储开销，存储密度等于 1 。 | 需要借助指针来体现元素间的逻辑关系，存储密度小于 1 。 | |
| 时间 | 存取元素 | 随机存取、按位置访问元素的时间复杂度为 O(1) 。 | 顺序存取、按位置访问元素时间复杂度为 O(n) 。 |
| 插入、删除 | 平均移动约表中一般的元素，时间复杂度为 O(n) 。 | 不需要移动元素，确定插入、删除位置后，时间复杂度为 O(1) 。 | |
| 适应情况 | ① 表长度变化不大，且能事先确定变化的范围； ②很少进行插入或删除操作，经常按元素位置序号访问数据元素。 | ① 长度变化较大； ② 频繁进行插入或删除操作。 | |
| 查找表头结点 | 查找表尾结点 | 查找结点*p的前驱结点 | |
| 带头结点的单链表L | L->next 时间复杂度 O(1) | 从 L->next 依次向后遍历 时间复杂度 O(n) | 通过 p->next 无法找到其前驱 |
| 带头结点仅设头指针L的循环单链表 | L->next 时间复杂度 O(1) | 从 L->next 依次向后遍历 时间复杂度 O(n) | 通过 p->next 可以找到其前驱 时间复杂度 O(n) |
| 带头结点仅设尾指针R的循环单链表 | R->next 时间复杂度 O(1) | R 时间复杂度 O(1) | 通过 p->next 可以找到其前驱 时间复杂度 O(n) |
| 带头结点的双向循环链表L | L->next 时间复杂度 O(1) | L->prior 时间复杂度O(1) | p->prior 时间复杂度O(1) |
1122
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
