数据结构笔记NO.1（绪论、线性表、栈队列和矩阵的压缩存储）

第一章、绪论

1、数据结构三要素：逻辑结构、存储结构（物理结构）、数据的运算。

(1)逻辑结构：是指数据元素之间的逻辑关系，即从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。

(2)存储结构（物理结构）：是指数据在计算机中的表示（又称映像），是用计算机语言实现的逻辑结构，它依赖于计算机语言。

• 顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现（e.g.数组）。
  • 优点：①可以实现随机存取；② 每个元素占用最少的存储空间；
  • 缺点：只能使用相邻的一整块存储单元，因此可能产生较多的外部碎片；
• 链式存储：不要求逻辑上相邻的元素在物理位置上也相邻，借助指示元素存储地址的指针来表示元素之间的逻辑关系（e.g.链表）。
  • 优点：不会出现碎片现象，能充分利用所有存储单元；
  • 缺点：①每个元素因存储指针而占用额外的存储空间；②只能实现顺序存取；
• 索引存储：在存储元素信息的同时，还建立附加的索引表。索引表中的每项称为索引项，索引项的一般形式是（关键字，地址）。
  • 优点：检索速度快；
  • 缺点：①附加的索引表额外占用存储空间；②增加和删除数据时也要修改索引表，因而会花费较多的时间（对索引表进行维护的时间开销）；
• 散列存储：又称哈希（Hash）存储，根据元素的关键字直接计算出该元素的存储地址。
  • 优点：检索、增加和删除结点的操作都很快；
  • 缺点：若散列函数（也称哈希（Hash）函数）不好，则可能出现元素存储单元的冲突，而解决冲突会增加时间和空间的开销；

(3)数据的运算：包括运算的定义和实现。

• 运算的定义：是针对逻辑结构的，指出运算的功能；
• 运算的实现：是针对存储结构的，指出运算的具体操作步骤。

2、数据元素：是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如：学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。

3、数据对象：是具有相同性质的数据元素的集合，是数据的一个子集。

4、数据类型：是一个值的集合和定义在此集合上的一组操作的总称。

• （1）原子类型：其值不可再分的数据类型；
• （2）结构类型：其值可再分解为若干成分（分量）的数据类型；
• （3）抽象数据类型（ADT（Abstract Data Type））：抽象数据组织及与之相关的操作。描述了数据的逻辑结构和抽象运算，通常用（数据对象，数据关系，基本操作集）这样的三元组来表示，从而构成一个完整的数据结构定义。

5、数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。

6、算法（Algorithm）：是对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作。一个算法应具有5个特性：

• （1）有穷性：一个算法必须总在执行有穷步之后结束，且每一步都可在有穷时间内完成；
• （2）确定性：算法中每条指令必须有确切的含义，对于相同的输入只能得出相同的输出；
• （3）可行性：算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现；
• （4）输入：一个算法有零个或多个输入，这些输入取自于某个特定的对象的集合；
• （5）输出：一个算法有一个或多个输出，这些输出是与输入有着某种特定关系的量。

通常，设计一个“好”的算法应考虑达到以下目标：

• （1）正确性：算法应能够正确地解决求解问题；
• （2）可读性：算法应具有良好的可读性，以帮助人们理解；
• （3）健壮性：输入非法数据时，算法能适当地做出反应或进行处理，而不会产生莫名其妙的输出结果；
• （4）效率与低存储量需求：效率是指算法执行的时间，存储量需求是指算法执行过程中所需要的最大存储空间，这两者都与问题的规模有关。

7、时间复杂度

• （1）一个语句的频度是指该语句在算法中被重复执行的次数；
• （2）算法中所有语句的频度之和记为T(n)，它是该算法问题规模n的函数，时间复杂度主要分析T(n)的数量级；
• （3）算法中基本运算（最深层循环内的语句）的频度与T(n)同数量级，因此通常采用算法中基本运算的频度f(n)来分析算法的时间复杂度；
  • 取f(n)中随n增长最快的项，将其系数置为1作为时间复杂度的度量。例如，f(n) = an³ + bn² + cn的时间复杂度为O(n³)；
• （4）算法的时间复杂度记为T(n) = O(f(n))；
  • 式中O的含义是T(n)的数量级，其严格的数学定义是：若T(n)和f(n)是定义在正整数集合上的两个函数，则存在正常数C和n0，使得当n≥n0时，都满足0≤T(n)≤Cf(n)。
• （5）算法的时间复杂度不仅依赖于问题的规模n，也取决于待输入数据的性质。
  • 最坏时间复杂度是指在最坏情况下，算法的时间复杂度；
  • 平均时间复杂度是指所有可能输入实例在等概率出现的情况下，算法的期望运行时间；
  • 最好时间复杂度是指在最好情况下，算法的时间复杂度；
  • 一般总是考虑在最坏情况下的时间复杂度，以保证算法的运行时间不会比它更长；
• （6）在分析一个程序的时间复杂性时，有以下两条规则：
  • 加法规则：T(n) = T1(n) + T2(n) = O(f(n)) + O(g(n)) = O(max(f(n)，g(n)))；
  • 乘法规则：T(n) = T1(n) × T2(n) = O(f(n)) × O(g(n)) = O(f(n) × g(n))；
• （7）常见的渐近时间复杂度为：
  • O(1) < O(logn)（以2为底，后同） < O(n) < O(nlogn) < O(n²) < O(n³) < O(2ⁿ) < O(n!) < O(nⁿ)；

8、空间复杂度

• （1）算法的空间复杂度S(n)定义为该算法所耗费的存储空间，它是问题规模n的函数，记为S(n) = O(g(n))；
• （2）一个程序在执行时除需要存储空间来存放本身所用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为实现计算所需信息的辅助空间；
• （3）若输入数据所占空间只取决于问题本身，和算法无关，则只需分析除输入和程序之外的额外空间；
• （4）算法原地工作是指算法所需的辅助空间为常量，即O(1)；

第二章、线性表

1、知识框架
2、线性表的定义

• 线性表是具有相同数据类型的 n（n ≥ 0）个数据元素的有限序列，其中 n 为表长，当n = 0时线性表是一个空表。
• 若用L命名线性表，则其一般表示为：
  • L = (a₁, a₂, …, a_i, a_i+1, …, a_n)；
  • a₁是唯一的“第一个”数据元素，又称表头元素；
  • a_n是唯一的“最后一个”数据元素，又称表尾元素；
  • 除第一个元素外，每个元素有且仅有一个直接前驱；
  • 除最后一个元素外，每个元素有且仅有一个直接后继；

3、线性表的特点

• 表中元素的个数有限；
• 表中元素具有逻辑上的顺序性，表中元素有其先后次序；
• 表中元素都是数据元素，每个元素都是单个元素；
• 表中元素的数据类型相同，这意味着每个元素占有相同大小的存储空间；
• 表中元素具有抽象性，即仅讨论元素间的逻辑关系，而不考虑元素究竟表示什么内容；
• 线性表是一种逻辑结构，表示元素之间一对一的相邻关系。顺序表和链表是线性表这一逻辑结构在内存中的不同组织形式（存储结构）；

4、线性表的基本操作

• 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；
• DestroyList(&L);销毁操作，销毁线性表，并释放线性表 L 所占用的内存空间；
• 注意：基本操作的实现取决于采用哪种存储结构，存储结构不同，算法的实现也不同。

5、线性表的顺序表示—顺序表

• （1）用一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻；
• （2）特点：表中元素的逻辑顺序与其物理顺序相同；
• （3）随机存取（随机访问），即根据首地址和元素序号可在O(1)时间内找到指定的元素；
• （4）假定线性表的元素类型为ElemType，则线性表的顺序存储类型描述为：

//数组空间静态分配，可能会产生溢出
#define MaxSize 50//定义线性表的最大长度
typedef struct {
   
	ElemType data[MaxSize];//顺序表的元素数组
	int length;//顺序表的当前长度
} SqList;//顺序表的类型定义
1
2
3
4
5
6
7

//数组空间动态申请
#define InitSize 100//表长度的初始定义
typedef struct {
   
	ElemType *data;//指示动态分配数组的指针
	int MaxSize, length;//数组的最大容量和当前个数
} SeqList;//动态分配数组的顺序表的类型定义
1
2
3
4
5
6
7

动态申请得到的内存是连续的，同样属于顺序存储结构。C的初始动态分配语句为：

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

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

L.data = new ElemType[InitSize];
1

• （5）顺序表的存储密度高，每个结点只存储数据元素；
• （6）顺序表逻辑上相邻的元素物理上也相邻，所以插入和删除操作需要移动大量元素；

6、顺序表上基本操作的实现

（1）插入操作

• 在顺序表L的第 i（1<= i <= L.length + 1）个位置插入新元素 e 。若 i 的输入不合法，则返回false，表示插入失败；否则，将第 i 个元素及其后的所有元素依次往后移动一个位置，腾出一个空位置插入新元素 e，顺序表长度增加1，插入成功，返回true。

bool ListInsert(SqList &L, int i, ElemType e) {
   
	if( i < 1 || i > L.length + 1 )//判断i的范围是否有效
		return false;
	if( L.length >= MaxSize )//当前存储空间已满，不能插入
		return false;
	for( int j = L.length; j >= i; j -- )//将第i个元素及之后的元素后移
		L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;//在位置i处放e
	L.length ++;//线性表长度加1
	return true;
}
1
2
3
4
5
6
7
8
9
10
11
12

• 时间复杂度分析（假设顺序表长度为n）：
  • 最好情况：在表尾插入（即 i = n + 1），元素后移语句将不执行，时间复杂度为O(1)；
  • 最坏情况：在表头插入（即 i = 1），元素后移语句将执行 n 次，时间复杂度为O(n)；
  • 平均情况：在第 i 个位置插入元素的概率p_i = 1/(n+1)，元素后移语句要执行n-i+1次，所以移动结点的平均次数为 p_i * (n-i+1)（ i 从1到n+1求和）= n/2，所以平均时间复杂度为O(n)。
    

（2）删除操作

• 删除顺序表L中第 i（1 <= i <= L.length）个位置的元素，用引用变量e返回。若 i 的输入不合法，则返回false；否则将被删除元素赋给引用变量e，并将第 i + 1个元素及其后的所有元素依次往前移动一个位置，返回true。

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

• 时间复杂度分析（假设顺序表长度为n）：
  • 最好情况：删除表尾元素（即 i = n），无需移动元素，时间复杂度为O(1)；
  • 最坏情况：删除表头元素（即 i = 1），需移动除表头元素外的所有元素，时间复杂度为O(n)；
  • 平均情况：删除第 i 个元素的概率p_i = 1/n，需移动n-i个元素，所以移动元素的平均个数为p_i * (n - i)( i从1到n求和）= (n - 1)/2，所以平均时间复杂度为O(n)。
    

可见，顺序表中插入和删除操作的时间主要耗费在移动元素上，而移动元素的个数取决于插入和删除元素的位置。

(3)按值查找（顺序查找）

• 在顺序表L中查找第一个元素值等于 e 的元素，并返回其位序。

int LocateElem(SqList L, ElemType e) {
   
	for( int i = 0; i < L.length; i ++ ) {
   
		if( L.data[i] == e )
			
1
2
3
4
5