王道考研 -- 数据结构 笔记

上面这张图来自课件，发现这张图将计算机四大基础学科之间的关系很好的体现出来了，故贴在这。

第一章 绪论

1.1 数据结构的基本概念

数据元素、数据项

数据元素是数据的基本单位。数据元素由数据项组成。
如，在饭馆排队的顾客，可用以下数据元素和数据项表示：

数据结构、数据对象

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
数据对象是具有相同性质的数据元素的集合，是数据的一个子集。

索引存储：

第二章 线性表

2.1 线性表的定义和操作

2.1.1 线性表的定义（逻辑结构）

线性表是具有相同数据类型的 n 个数据元素的有限序列，其中 n 为表长，当 n = 0 时，线性表是一个空表。若用 L 命名线性表，则一般表示为：L = {a1, a2, ... , an}。
位序：也就是元素在线性表中的位置。位序从 1 开始，在编程时，数组从 0 开始。
表头元素为 a1 和表尾元素为 a2。
除头尾元素外，每个元素都有一对直接前驱和直接后驱。

2.1.2 线性表的基本操作

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 的长度，即表中元素的个数。
PrintList(L)：打印表。按顺序输出线性表 L 的所有元素值。
Empty(L)：判断是否为空。若 L 为空表，则返回 true，否则返回 false。

Tips：
操作数据结构的思路：创销、增删改查。
实际开发中，可根据实际需求定义其他操作。
关于引用 &：引用运算符是 C++ 中的运算符，C 中没有这种操作。

比起学会“How”（怎么做），更重要的是想明白“Why”（为什么要这么做）。

2.2 线性表的顺序表示

如何获取数据元素的长度？
使用 sizeof() 函数。

2.2.1 顺序表的定义

用顺序存储的方式实现线性表。顺序存储，也就是将逻辑上相邻的元素存储在相邻的物理位置上。

2.2.2 顺序表的实现

静态分配

用静态分配的方式实现顺序表，表的长度后续不可再发生改变。

代码实现示例：

#define MaxSize 10 // 定义最大长度 

typedef struct {
	int data[MaxSize]; // ElemType = int, * 用静态的“数组”存访数据元素 
	int length; // 顺序表的当前长度 
} SqList;

// 初始化顺序表 
void InitList(SqList &L) {
	L.length = 0; // 顺序表初始化为0 
}

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

动态分配

malloc() 函数的作用：会申请一片存储空间，并返回存储空间第一个位置的地址，也就是该位置的指针。

#define InitSize 10 // 顺序表的初始长度
typedef struct {
	int * data; // ElemType = int, * 声明动态分配数组的指针 
	int MaxSize; // 顺序表的最大容量
	int length; // 顺序表的当前长度 
} SqList;

// 初始化顺序表 
void InitList(SqList &L) {
	// 用 malloc 函数申请一片连续的存储空间 
	L.data = (int *)malloc(InitSize * sizeof(int));
	L.length = 0;
	L.MaxSize = InitSize;
}

// 增加动态数组的长度 
void IncreaseSize(SqList &L, int len) {
	int * p = L.data;
	L.data = (int *)malloc((L.MaxSize + len) * sizeof(int));
	for (int i = 0; i < L.length; i++)
		L.data[i] = p[i]; // 将数据复制到新区域 
	L.MaxSize = L.MaxSize + len; // 顺序表最大长度增加len 
	free(p); // 释放原来的内存空间 
}

int main() {
	SqList L; // 声明一个顺序表 
	InitList(L); // 初始化顺序表 
	
	IncreaseSize(L, 5);
	
	return 0;
}

2.2.3 顺序表的特点

• 可随机访问，查找元素所需时间复杂度为 O(1) 。
• 存储密度高，每个节点只存储数据元素。
• 拓展容量不方便（即使使用动态分配的方式实现，拓展长度的时间复杂度也比较高，因为需要把数据复制到新的区域）。
• 插入删除操作不方便，需移动大量元素：O(n) 。

静态分配与动态分配的对比：

静态分配无法拓展容量，动态分配可以拓展容量。

2.2.4 顺序表的基本操作

1. 插入

#define MaxSize 10 // 定义最大长度 

typedef struct {
	int data[MaxSize]; // 用静态的“数组”存访数据元素 
	int length; // 顺序表的当前长度 
} SqList;

bool ListInsert(SqList &L, int i, int 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;
} 

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

时间复杂度分析

• 最好的情况：在表尾插入，无需移动元素。O(1) 。
• 最坏的情况：在表头插入，需移动所有元素。O(n) 。
• 平均情况：所有位置插入的可能性都为 p = 1/(n+1) ，则平均时间复杂度 = O[np + (n-1)p + ··· + 0*p] = O(n/2)，也就是 O(n) 。

2. 删除

#define MaxSize 10 // 定义最大长度 

typedef struct {
	int data[MaxSize]; // 用静态的“数组”存访数据元素 
	int length; // 顺序表的当前长度 
} SqList;

bool ListInsert(SqList &L, int i, int 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;
} 

bool ListDelete(SqList &L, int i, int &e) {
	if (i < 1 || i > L.length)
		return false;
	e = L.data[i-1]; // 将被删除的元素赋值给e 
	for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 
		L.data[j-1] = L.data[j];
	L.length--;
	
	return true; 
}

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

时间复杂度分析

• 最好时间复杂度：删除表尾，O(1)。
• 最坏时间复杂度：删除表头，后续 n-1 个元素全部前移，O(n)。
• 平均时间复杂度：每个元素被删除的概率都为 p = 1/n，O[(n-1)p + (n-2)p + ··· + 0*p] = O[(n-1)/2] = O(n)

3. 查找

a. 按位查找

GetElem(L, i)

/* 静态分配的按位查找 */ 

#define MaxSize 10 // 定义最大长度 
typedef struct {
	ElemType data[MaxSize]; // 用静态的“数组”存访数据元素 
	int length; // 顺序表的当前长度 
} SqList;

ElemType GetElem(SqList L, int i) {
	return L.data[i-1];
}

/* 动态分配的按位查找 */ 

#define InitSize 10 // 顺序表的初始长度 
typedef struct {
	ElemType * data; // ElemType = int, * 声明动态分配数组的指针 
	int MaxSize; // 顺序表的最大容量
	int length; // 顺序表的当前长度 
} SqList;

ElemType GetElem(SqList L, int i) {
	return L.data[i-1];
}

时间复杂度分析

由于元素连续存放，可以根据起始地址和元素大小立刻找到元素——随机存取特性。

最好时间复杂度 = 最坏时间复杂度 = 平均时间复杂度 = O(1)

b. 按值查找

LocateElem(L, e)

#define InitSize 10 // 顺序表的初始长度 
typedef struct {
	ElemType * data; // ElemType = int, * 声明动态分配数组的指针 
	int MaxSize; // 顺序表的最大容量
	int length; // 顺序表的当前长度 
} SqList;

// 查找第一个元素值为e的元素，并返回其位序 
int LocateElem(SqList L, ElemType e) {
	for (int i = 0; i < L.length; i++)
		if (L.data[i] == e)
			return i+1; // 数组下标为i的元素值等于e，返回其位序i+1 
	return 0; // 没有查找到 
}

时间复杂度分析

• 最好时间复杂度：目标在表头，O(1) 。
• 最坏时间复杂度：目标在表尾，O(n) 。
• 平均时间复杂度：目标元素在任何位置的概率都为 p = 1/n，则平均时间复杂度为 O[1 * 1/n + 2 * 2/n + ··· + n * 1/n] = O[(n+1)/2] = O(n) 。

C 中不能用 == 判断两个结构体是否相等