数据结构学习笔记（二） | 1 线性表 之 顺序表

线性表的定义和基本操作

定义

线性表的定义：具有相同数据类型的$n$($n>=0$)个数据元素的有限序列，其中$n$为表长，当$n=0$时线性表是一个空表。若用L命名线性表，则其一般表示为
$$L=(a_1,a_2,...,a_i,a_{i+1},...,a_n)$$
其中：
$a_i$——线性表中的“第$i$个”元素在线性表中的位序；
$a_1$——表头元素；
$a_n$——表尾元素；
除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且只有一个后继。

基本操作

• InitList(&L): 初始化表。构造一个空的线性表L，分配内存空间。
• DestroyList(&L): 销毁操作。销毁线性表，并释放线性表L所占用的内存空间。
• ListInsert(&L,i,e): 插入操作。在表L的第i个位置上插入指定元素e。
• ListDelete(&L,i,e): 删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
• LocateElem(L,e): 按值查找操作。在表L中查找具有给定关键字值的元素。
• GetElem(L,i): 按位查找操作。获取表L中第i个位置的元素的值。
• Length(L): 求表长。返回线性表L的长度，即L中数据元素的个数。
• PrintList(L): 输出操作。按前后顺序输出线性表L的所有元素值。
• Empty(L): 判空操作。若L为空表，则返回true；否则返回false。

Tips

1. 对数据的操作——创销增删改查
2. C语言函数的定义——<返回值类型> 函数名 (<参数1类型>参数1,<参数2类型>参数2,…)
3. 实际开发中，可根据实际需求定义其他的基本操作
4. 函数名和参数的形式、命名都可改变，命名要有可读性。
5. 什么时候要传入引用“&”——对参数的修改结果需要“带回来”

顺序表(顺序存储)

定义

用顺序存储的方式实现线性表。
顺序存储：把逻辑相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

实现

#include <stdio.h>
#define MaxSize 10				//定义最大长度
typedef struct{					
	ElemType data[MaxSize];		//用静态的数组存放数据元素
	int length;					//顺序表的当前长度
}SqList;						//顺序表的类型定义(静态分配方式)

void InitList(SqList &L){
	for(int i = 0;i < MaxSize;i++)
			L.data[i]=0;			//将所有数据元素设置为默认初始值
	L.length = 0;					//顺序表初始长度为0
}		

int main(void){
	SqList L;						//声明一个顺序表
	InitList(L);					//初始化顺序表
	//后续操作
	return 0;
}

顺序表的实现——动态分配

动态申请和释放内存空间
C——malloc、free函数
L.data = (ElemType *) malloc(sizeof(ElemType) *InitSize)
C++——new、delete 关键字

#define InitSize 10				//顺序表的初始长度
typedef struct{
	ElemType *data;				//指示动态分配数组的指针
	int MaxSize;				//顺序表的最大容量
	int length;					//顺序表的当前长度
}SeqList;						//顺序表的类型定义(动态分配方式)

void InitList(SeqList &L){
//用malloc函数申请一片连续的存储空间
L.data = (int *)malloc(InitSize*sizeof(int));
L.length = 0;
L.MaxSize = InitSize;

int main(void){
	SqeList L;
	InitList(L);
	IncreaseSize(L,5);
	return 0;
}

特点

• 随机访问，即可以在$O(1)$时间内找到第$i$个元素
• 存储密度高，每个节点只存储数据元素
• 拓展容量不方便(即便采用动态分配的方式来实现，拓展长度的时间复杂度也较高)
• 插入、删除操作不方便，需要移动大量元素

插入和删除操作

ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。

#define MaxSize 10
typedef struct{
	int data[MaxSize];
	int length;
}sqLsit;

bool ListInsert(SqList &L,int i,int e){
	if (i<1 || i>L.length+1)
	reutrn false;
	for(int j=L.length;j>=i;j--)
		L.data[j]=L.data[j-1];
	L.data[i-1]=e;
	L.length++;
	return true;
}

int main(void){
	SqList L;
	InitList(L);
	ListInsert(L,3,3);
	return 0;
}

时间复杂度计算：
最好情况：新元素插入到表尾，不需移动元素
最坏情况：新元素插入到表头，需要将原有的n个元素全都向后移动
平均情况：假设新元素插入到任何一个位置的概率相同，即$i=1,2,3,length+1$的概率是$p=\frac{1}{n+1}$
$i=1$，循环$n$次；$i=2$,循环$n-1$次；i=3,循环$n-2$次 $...$ $i=n+1$时，循环0次。

平均循环次数 =
$$np+(n-1)p+\cdots +1p=\frac{n(n+1)}{2}\frac{1}{n+1}=\frac{n}{2}$$

ListDelete(&L,i&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

bool ListDelete(SqList &L,int i,int &e){
	if (i<1 || i>L.length)
		return false;
	e = L.data[i-1];
	for(int j=i;j<L.length;j++)
		L.data[j-1]=L.data[j];
	L.length--;
	return true;
}

int main(void){
	SqList L;
	InitList(L);
	int e = -1;
	if (ListDelete(L,3,e))
		printf("已删除第3个元素，删除元素值为=%d",e);
	else 
		printf("位序i不合法，删除失败\n");
	return 0;
}

最好情况:删除表尾元素，不需移动其他元素。
最坏情况：删除表头元素，需将后续的n-1个元素全都向前移动
平均情况：假设删除任何一个元素的概率相同，即$i=1,2,3,\dots ,length$的概率都是$p=\frac{1}{n}$
$i=1$,循环$n-1$次；$i=2$时，循环$n-2$次；$i=3$,循环$n-3$次 $\dots$ $i=n$时，循环0次
平均循环次数=
$$(n-1)p+(n-2)p+\cdots +1p=\frac{n(n-1)}{2}\frac{1}{n}=\frac{n-1}{2}$$

查找操作

GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。

#define InitSize 10
typedef struct{
	ElemType *data;
	int MaxSize;
	int length;
}SeqList;

ElemType GetElem(SeqList L,int i){
	if(i>=0 && i<MaxSize)
		return L.data[i-1];
	else
		return 0;
}

时间复杂度$O(1)$

LocalElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素。

#define InitSize 10
typedef struct{
	ElemType *data;
	int MaxSize;
	int length;
}SeqList;

int LocateElem(SeqList L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)
			return i+1;
		return 0;
}

最好情况：目标元素在表头。最好时间复杂度O(1)
最坏情况：目标元素在表尾。最坏时间复杂度O(n)
平均情况：假设目标元素出现在任何一个位置的概率相同，都是$\frac{1}{n}$
平均循环次数=
$$1\times \frac{1}{n}+2\times \frac{1}{n}+\cdots +n\times \frac{1}{n}=\frac{n(n+1)}{2}\times \frac{1}{n}=\frac{n+1}{2}$$