【初探数据结构】

如意.759

已于 2024-07-08 18:11:34 修改

阅读量797

点赞数 41

文章标签：数据结构

于 2024-07-08 18:04:08 首次发布

本文链接：https://blog.csdn.net/2402_82668782/article/details/139767538

版权

第一章数据结构绪论

1.1数据结构与算法

（1）什么是数据结构？

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。

（2）什么是算法？

算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。

简而言之算法就是描述解决问题的方法。

1.2数据结构与算法的重要性

目前校园招聘笔试一般采用Online Judge形式，一般都是20-30道选择题+2道编程题，或者3-4道编程题。

2020奇安信秋招C/C++方向

美团2021校招笔试

网易2021校招笔试

可以看出，现在公司对学生代码能力的要求是越来越高了，大厂笔试中几乎全是算法题而且难度大，中小长的笔试中才会有算法题。算法不仅笔试中考察，面试中面试官基本都会让现场写代码。而算法能力短期内无法快速提高了，至少需要持续半年以上算法训练积累，否则真正校招时笔试会很艰难，因此算法要早早准备。

第二章时间与空间复杂度

2.1算法的概念及特性

（1）算法的概念

算法是解决特定问题求解步骤的描述
在计算机中表现为
指令的有限序列并且每条指令表示一个或多个操作

简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

（2）算法的特性

输入、输出、有穷性、确定性和可行性
好的算法：应该具有正确性，可读性，健壮性，高效率和低存储量的特征

2.2算法的效率度量

（1）算法效率

如何衡量一个算法的好坏呢？比如对于以下斐波那契数列：

long long Fib(int N)
{
 if(N < 3)
 return 1;
 
 return Fib(N-1) + Fib(N-2);
}

斐波那契数列的递归实现方式非常简洁，但简洁一定好吗？那该如何衡量其好与坏呢？这就涉及到算法的复杂度了。

（2）算法的复杂度

算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。

时间复杂度主要衡量一个算法的运行快慢。

空间复杂度主要衡量一个算法运行所需要的额外空间。

在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

2.3时间复杂度

（1）时间复复杂度的概念

时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。

Tip：为什么不用运行时间衡量？

算法的环境不同，跑出来的时间自然有所影响因此我们需要通过代码本身来反映效率。

即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。

// 请计算一下Func1中++count语句总共执行了多少次？

void Func1(int N)
{

int count = 0;

for (int i = 0; i < N ; ++ i)
{
 for (int j = 0; j < N ; ++ j)
 {
 ++count;
 }
}
 

for (int k = 0; k < 2 * N ; ++ k)
{
 ++count;
}
 

int M = 10;

while (M--)
{
 ++count;
}
printf("%d\n", count);
}

我们计算出来的函数：

可以看到除了变量N还存在着其他的系数和常数，这是不太便于比较算法的优略性的。

我们可以引入大O的渐进表示法进行函数简化

（2）大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。

推导大O阶方法：

1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中，只保留最高阶项。

3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。使用大O的渐进表示法以后，Func1的时间复杂度为：

N = 10 F(N) = 100 N = 100 F(N) = 10000 N = 1000 F(N) = 1000000

Tip:原理其实很简单函数存在着阶位的比较（简单讲就是增长速度的比较）

当N很大时常数的影响微乎其微

当N很小时常数项影响反而很大

但是N很小时候我们认为这三个性能是一样的

因为CPU的运算速度太快，每秒至少上亿次，所以性能是几乎一样的

最终我们就可以只关注到阶位最大的一项，即大O渐进法

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。另外有些算法的时间复杂度存在最好、平均和最坏情况：

最坏情况：任意输入规模的最大运行次数(上界)

平均情况：任意输入规模的期望运行次数

最好情况：任意输入规模的最小运行次数(下界)

例如：在一个长度为N数组中搜索一个数据x

最好情况：1次找到

最坏情况：N次找到

平均情况：N/2次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

2.4空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度。空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟实践复杂度类似，也使用大O渐进表示法。

Tips：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

第三章顺序表和链表

3.1线性表的存储结构

线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

存储结构分为顺序存储结构和链式存储结构

3.2顺序表的概念及结构

顺序表的定义：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表的结构：一般可分为静态顺序表和动态顺序表

静态：使用定长数组存储元素

动态：使用动态开辟的数组存储

3.3实现顺序表

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

1.定义结构体和数据类型

typedef int SLDataType;
typedef struct SeqList
{
	SLDataType* arr;
	int size;//有效数据个数 定位数组下标 
	int capacity;//顺序表空间大小
}SL;

2.顺序表的初始化和销毁

void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->capacity = 0;
	ps->size = 0;
}
void SLDestory(SL* ps)
{
	if(ps->arr)
	{
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

3.检查顺序表的空间大小函数

void SLCheck(SL* ps)
{
	if (ps->capacity == ps->size)
	{
		//申请空间
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		//申请成功了
		ps->arr = tmp;
		ps->capacity = newcapacity;
	}
}

4顺序表的增加数据（尾插和头插）

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheck(ps);
	ps->arr[ps->size++] = x;

}
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	SLCheck(ps);
	for (int i = ps->size; i >0 ; i--)
	{
		ps->arr[i] = ps->arr[i-1];
	}
	ps->arr[0] = x;
	ps->size++;
}

5.顺序表的删除数据（尾删和头删）

void SLPopBack(SL* ps)
{
	assert(ps);
	assert(ps->size);
	--ps->size;
}
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);
	for (int i = 0; i<ps->size-1; i++)
	{
		ps->arr[i] = ps->arr[i+1];
	}
	--ps->size;
}

6.顺序表之指定位置的增删数据

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//防止越界访问
	assert(pos >= 0 && pos <= ps->size);
	//检查空间是否足够
	SLCheck(ps);
	for (int i = ps->size; i >pos ; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	++ps->size;
}
void SLErase(SL* ps, int pos)
{
	assert(ps);
	//防止越界访问
	assert(pos >= 0 && pos <= ps->size);
	for (int i = pos;i<ps->size-1;i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	--ps->size;
}

7.顺序表之查找数据

void SLFind(SL* ps, SLDataType x)
{
	int i = 0;
	assert(ps);
	for ( i = 0; i < ps->size; i++)
	{
		if(ps->arr[i] == x)
		{
			printf("找到了，下标是%d", i);
			break;
		}
	}
	if (i == ps->size)
	{
		printf("没有此数据");
	}

}

3.4链表的概念与分类

（1）链表的概念

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加⼏节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节车厢都是独力存在的。
车厢是独立存在的，且每节车厢都有车门。想象⼀下这样的场景，假设每节⻋厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从车头走到车尾？
最简单的做法：每节车厢里都放⼀把下⼀节车厢的钥匙。

链表里，每节“车厢”是怎样的呢？

与顺序表不同的是，链表里的每节"车厢"都是独立申请下来的空间，我们称之为“结点/节点”节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。

图中指针变量 plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第二个节点时，只需要修改plist保存的内容为0x0012FFA0。

（2）链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

1. 单向或者双向

2. 带头或者不带头

3. 循环或者非循环

虽然有这么多的链表的结构，但是实际中最常用还是两种结构：

Tips:

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

3.5单链表的实现

1.定义链表的结点，并定义结构体数据类型

//定义节点的结构
//数据+指向下一个节点的指针
typedef int SLTDataType;
typedef struct SlistNode {
	SLTDataType data;
	struct SlistNode* next;
}SLTNode;

2.结点的开辟

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror(newnode);
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

3.链表的增加数据（尾插和头插）

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//空链表和非空链表 
	//*pphead 指向第一个节点的指针 
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead==NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	//无所谓链表表是否为空
		newnode->next = *pphead;
		*pphead = newnode;
}

4.链表的删除数据（尾删和头删）

void SLTPopBack(SLTNode** pphead)
{
	//链表不能为空 *pphead
	assert(pphead && *pphead);
	SLTNode* prev = *pphead;
	SLTNode* ptail = NULL;
	//只有一个节点的话
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//有多个节点
		while (prev->next->next)
		{
			prev = prev->next;
		}
		prev->next = ptail;
		free(ptail);
		ptail = NULL;
	}
}
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

5.链表指定位置的增删

//为什么需要**pphead参数？ 因为头结点可能发生改变
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	SLTNode* prev = *pphead;
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	//要区分pos等于pphead时 prev怎么也找不到pos可能野指针
	else
	{
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && pos && *pphead);
	SLTNode* prev = *pphead;
	if (pos == *pphead)
	{
		/**pphead = pos->next;
		free(pos);
		pos = NULL;*/
		//也可以直接调用头删函数
		SLTPopFront(pphead);
	}
	else
	{
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;
	pos->next = del->next;
	free(del);
	del = NULL;
}

6.链表的查找

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

7.链表的销毁

void SListDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

后言

这就是典型的线性表——顺序表和链表

顺序表为物理顺序结构由有序的数组实现

链表为逻辑顺序结构由指针结点连接起来实现

我们应该夯实基础，手撕顺序表、链表，打造坚固地基~

如意.759

关注

41
点赞
踩
28

收藏

觉得还不错? 一键收藏
8
评论
【初探数据结构】

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简而言之算法就是描述解决问题的方法。
复制链接

扫一扫