目录
注:
本笔记参考:《数据结构(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) |