线性表——顺序表
2.1 线性表的基本概念
2.1.1 线性表的基本定义
线性表是一个由N个相同元素组成的有序序列。
一般来说,线性表主要分为顺序表、单链表、循环单链表、双链表和循环双链表。
线性表主要可以解决一系列数据的线性存储,而它的存储方式又分为顺序储存和链式储存,以此可以实现数据的输入输出、插入、查找等操作。
2.1.2 线性表的基础操作
- 初始化
~~
InitList()
- 销毁单链表
~~
DestoryList()
- 求线性表的长度
~~
GetLength()
- 求线性表中的第i个元素
~~
GetElem()
- 按值查找
~~
Locate()
- 插入元素
~~
InsElem()
- 删除元素
~~
DelElem()
- 输出元素
~~
DisList()
现在,我们把这八种基本操作细分到不同的结构中进行讨论
2.2 顺序表
2.2.1 顺序表的定义
顺序表是线性表采用顺序储存结构在计算机内存中的储存方式,它由多个储存单元组成,每个储存单元存放一个元素,逻辑上相邻的元素在线性表中表示也是相邻的。所以顺序表又称为线性表的直接映射
我们假定线性表的数据元素的类型为ElemType
(这样写主要是为了方便我们之后定义变量)
顺序表的存储是通过结构体来实现的:
#define MaxSize 100000
typedef int ElemType;
typedef struct {
ElemType data[MaxSize]; //存放顺序表的元素
int length //顺序表的实际长度
}SqList;
我们在顺序表结构体中用一个数组data
来存放顺序表的数据,存储方式和一般数组存储方式无异。MaxSize
表示这个顺序表可以存放的最大数据量(注意:一般做题的时候MaxSize
的值最好开大一点)length
表示这个顺序表的实际长度(一般不等于MaxSize
)。
2.2.2 利用顺序表实现线性表的基本运算
在之前的内容中已经指出,线性表的基本运算大概有8类,下面给出基于顺序表实现的线性表功能算法
1. 顺序表的基本算法
初始化顺序表的length
为0,并且data
数据清空
void InitList(SqList & L)
{
L.length = 0;
memset(data,0,sizeof(data));
}
本算法的时间复杂度为 O ( 1 ) O(1) O(1)
2. 销毁顺序表算法
可以发现,顺序表变量L是一个自动变量,其内存空间是系统自己分配的,程序结束后系统会自动释放空间,所以销毁函数不含任何语句
void DesList(SqList L)
{
}
补充问题:复习一下内存空间的问题
给变量分配内存空间分为静态内存分配和动态内存分配。静态内存分配属于编译时给变量分配的空间,动态内存分配属于在程序运行时给变量分配的空间。静态分配属于栈分配(stack),动态分配属于堆分配(heap)。
静态内存分配是在程序编译或者运行过程中,按事先规定的大小分配内存空间的分配方式,他的前提的必须事先知道所需内存空间的大小,它的内存分配在栈区和全局变量区。
动态内存分配是按输入信息的大小分配所需要的内存单元,他的特点是按需分配,内存分配在堆区。
int a[10]
属于静态分配
int a[n]; int *a; a = (int *)malloc(sizeof(a))
属于动态分配
一般情况下我们使用malloc
和free
组合进行动态分配和释放空间。
栈存储:
堆存储
3. 求线性表的长度算法
其实就是返回顺序表的length
int GetLength(SqList L)
{
return L.length;
}
本算法的时间复杂度为
O
(
1
)
O(1)
O(1)
4. 求线性表中的第i个元素算法
为了避免我们的逻辑序号i
是一个无效值,我们在函数开头加一个判断语句(注意:很重要!不能忽略)
int GetElem(SqList L,int i,ElemType &e)
{
if(i < 1 || i > L.length) return 0; //不能丢掉!
else{
e = L.data[i - 1];
return 1;
}
}
本算法的时间复杂度为
O
(
1
)
O(1)
O(1)
5. 按值查找算法
我们要求在顺序表中查找第一个值为x
的函数,找到后返回其序号,否则返回0。
int Locate(SqList L,ElemType x)
{
int i = 0;
while(i < L.length && L.data[i] != x) i++;
if(i >= L.length) return 0;
else return (i + 1); //这里注意我们的下标是0~n-1
}
本算法的时间复杂度
O
(
n
)
O(n)
O(n)
6. 插入元素算法
要求实现将新元素x
插入到顺序表中编号为i
的位置,如果i
无效则返回0。
这个算法的操作分两种情况:
- 如果
i
有效:原数据中i - 1
~n - 1
的数据元素后移一位,length++
- 如果
i
无效:返回0。
int InsElem(SqList & L,ElemType x,int i)
{
int j;
if(i < 1 || i > L.length + 1) return 0;
for(j = L.length;j < i;j--) //从length位置开始后移
L.data[j] = L.data[j - 1];
L.data[i - 1] = x;
L.length++;
return 1;
}
本算法的时间复杂度分析,我们考虑最坏的情况,当i = 0
时,移动次数为n
次,所以算法时间复杂度为
O
(
n
)
O(n)
O(n)
7. 删除元素算法
要求实现将序号为i
的元素从顺序表中删除,从如果i
无效则返回0。
这个算法的操作分两种情况:
- 如果
i
有效:原数据中i
~n - 1
的数据元素前移一位,length--
- 如果
i
无效:返回0。
int DelElem(SqList & L,int i)
{
int j;
if(i < 1 || i > L.length) return 0;
for(j = i;j < L.length;j++) L.data[j - 1] = data[j];
L.length--;
return 1;
}
算法复杂度分析:
对于一般情况,删除位置为i
的元素
a
i
a_i
ai,需要将
a
i
+
1
a_{i + 1}
ai+1 ~
a
i
a_i
ai的元素均向前移动一次,移动次数为
n
−
(
i
+
1
)
+
1
=
n
−
i
n - (i + 1) + 1 = n - i
n−(i+1)+1=n−i。假设
p
i
p_i
pi在是删除在第i个位置上的元素的概率(等概率下
p
i
=
1
n
p_i = {1 \over n}
pi=n1)则在长度为n的线性表中删除元素的平均时间复杂度为:
∑ 1 n p i ( n − 1 ) = ∑ 1 n 1 n ( n − i ) = 1 n ∗ n ( n − 1 ) 2 = ( n − 1 ) 2 \sum_1^np_i(n - 1) = \sum_1^n{1 \over n}(n - i) = {1 \over n}*{n(n - 1) \over 2} = {(n - 1) \over 2} ∑1npi(n−1)=∑1nn1(n−i)=n1∗2n(n−1)=2(n−1)
这里用到了一点期望的算法,得出算法时间复杂度为
O
(
n
)
O(n)
O(n)
8. 输出元素值算法
从头到尾扫描(或称遍历)顺序表L,输出各个元素值。
void DisList(SqList L)
{
int i;
for(i = 0;i < L.length;i++) printf("%d",L.data[i]);
printf("\n");
}
算法时间复杂度 O ( n ) O(n) O(n)
2.2.3 算法实现顺序表的整体创建
我们的基本思路是:用一个数组存储顺序表中的基本元素,然后调用函数将数据存入data
中
void CreatList(SqList & L,ElemType a[],int n)
{
int i,k = 0;
for(i = 0;i < n;i++) {
L.data[k] = a[i];
k ++;
}
L.length = k;
}
算法的时间复杂度为 O ( n ) O(n) O(n)
现在,我们已经完成了对顺序表的一些基本操作,现在给出一些实例:
2.2.4 基于顺序表的基本操作的算法设计
这一类的算法设计中包括顺序表元素的查找、插入、删除等操作。
例题1:
设计一个顺序表L,删除从第i个元素开始的连续的k个元素。
题解:
我们可以这样想,删除k个元素相当于第i + k ~ length
个元素向前移动k个位置,那也就是说我们只需要做一次移动操作即可,而不需要进行k次删除。
代码
int Deletk(SqList & L,int i,int k)
{
int j;
if(i < 1 || k < 1 || i + k - 1 > L.length) return 0;
for(j = i + k - 1;j < L.length;j++) L.data[j - k] = L.data[j];
L.length -= k;
return 1;
}
例题2:
假设有一个顺序表L,其中元素为整数且所有元素值均不相同。设计一个尽可能高效的算法将所有奇数移到所有偶数的前面。
题解:
我们按照前后元素交换的思路,在顺序表的头和尾设置两个哨兵。在顺序表中从后往前找奇数,从前往后找偶数,找到后进行交换,如果两个哨兵相遇则停止查找,这样就可以实现L的前面都是奇数,而后面全是偶数。(注意:这一思想在后面的快速排序中也会有所应用)
代码:
void swap(ElemType & x,ElemType & y)
{
ElemType temp = x;
x = y;
y = temp;
}
void Move(SqList &L)
{
int i = 0,j = L.length; //哨兵
while(i < j){
while(L.data[i] % 2 == 1) i ++;
while(L.data[j] % 2 == 0) j --;
if(i < j) swap(L.data[i],L.data[j]);
}
}
2.2.5 基于整体建表的算法设计
这一类算法中需要根据条件产生新的结果顺序表。
例题3:
已知一个顺序表L,现在要求设计一个算法删除其中所有值为x的元素(假设L中的值为x的元素有多个)。
题解:
不断删除更新L显然是很不方便的,如果我们对这个顺序表每删除一个元素我们都采用移动的方式更新L,那么这个算法的时间复杂度会达到
O
(
n
2
)
O(n^2)
O(n2),这个显然不是一个最优化的解法。我们也可以这样操作:遍历L,对于每一个不为x的元素我们都把他放进另一个新的顺序表L中,这样可以实现
O
(
n
)
O(n)
O(n)的时间复杂度,但是空间复杂度却提升到了
O
(
n
)
O(n)
O(n)。显然这并不是一种最理想的方案。
基于前面的思考,我们考虑这样一种情况:对于这个顺序表中的元素,不为x的元素个数一定小于等于L中总元素的个数,所以我们只需要在这个L中操作就可以,而不需要在新建一个L。
代码:
void Deletex(SqList & L,ElemType x)
{
int i,k = 0;
for(i = 0;i < L.length;i++){
if(L.data[i] != x){
L.data[k] = L.data[i];
k ++;
}
}
L.length = k;
}
2.2.6 有序顺序表的二路归并算法
这里我们针对有序顺序表来讨论。
例题4:
有两个元素递增有序的顺序表A和B,设计一个算法将顺序表A和B的全部元素归并到一个按元素值递增有序的顺序表C中。
题解:
我们分别扫描A和B的元素,每一次都比较当前两个元素的大小,我们总是将比较小的哪一个放入C中,最后我们把未扫描完的元素再放入C中,最后得到的就是一个元素值递增有序的顺序表。这一思路就是我们归并排序实现的基础。
上图:
代码:
void Merge(SqList A,SqList B,SqList & C)
{
int i = 0,j = 0,k = 0;
while(i < A.length && j < B.length){
if(A.data[i] < B.data[j]){
C.data[k] = A.data[i];
i ++;
k ++;
}
else{
C.data[k] = B.data[j];
k ++;
j ++;
}
}
while(i < A.length){
C.data[k] = A.data[i];
i ++;
k ++;
}
while(j < B.length){
C.data[k] = B.data[j];
j ++;
k ++;
}
}
本算法的时间复杂度为
O
(
n
+
m
)
O(n + m)
O(n+m)
下面给出这个问题的一个变型问题:
例题5:
给出两个有序表A和B,分别含有n个m个元素(我们规定最大的元素不超过32767),假设这n + m
个元素互不相同。设计一个算法找出这m + n
个数中第k小的元素。
题解:
我们还是采取二路归并的思路,我们先扫描A和B,如果两个顺序表都没有扫完,那就不断去比较A的元素和B的元素的值,每比较依次k--
,如果k = 0
则证明找到了这个第k小的值,否则我们知道,一定有一个顺序表没有扫描完,那么我们就去找A.data[i + k - 1]
和B.data[j + k - 1]
。
代码:
void Merge(SqList A,SqList B,ElemType & e)
{
int i = 0,j = 0;
if(k < 1 || k > A.length + B.length) return 0; //k的值非法
while(i < A.length && j < B.length) {
k --; //每次比较减一
if(A.data[i] < B.data[j]){
if(k == 0){
e = A.data[i];
return 1;
}
i ++;
}
else{
if(k == 0){
e = B.data[j];
return 1;
}
j ++;
}
}
if(i < A.length) e = A.data[i + k - 1]; //二路归并之后A非空
else if(j < B.length) e = B.data[j + k - 1]; //B非空
return 1;
}