数据结构进阶篇 之 【二叉树顺序存储（堆）】的整体实现讲解（赋完整实现代码）

已于 2024-03-27 20:36:21 修改
阅读量1.1k 收藏 40
点赞数 51
分类专栏： 数据结构篇 文章标签： 数据结构 算法 经验分享 笔记 leetcode 链表 动态规划
于 2024-03-27 18:24:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foodsx/article/details/137061141
版权

在这里插入图片描述

做人要谦虚，多听听别人的意见，然后记录下来，看看谁对你有意见

一、二叉树的顺序（堆）结构及实现

1.二叉树的顺序结构

2.堆的概念及结构

3.堆的实现

3.1 向下调整算法 AdJustDown

3.2 向上调整算法 AdJustUP

3.3 堆的创建

3.3.1 向上建堆
3.3.2 向下建堆
3.3.3 堆的初始化与销毁
3.3.4 堆的插入（压栈）
3.3.5 取堆顶的数据
3.3.6 堆的删除
3.3.7 堆的数据个数
3.3.8 堆的判空

二、堆的完整实现代码

三、完结撒❀

–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀-正文开始-❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–❀–

一、二叉树的顺序（堆）结构及实现

1.二叉树的顺序结构

堆
物理结构：数组
逻辑结构：二叉树

顺序结构存储就是使用数组来存储，普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费，而完全二叉树更适合使用顺序结构存储。

可能有些同学不太清楚普通二叉树使用数组来存储为什么会造成空间上的浪费，这里给大家讲解一下：
我们使用数组进行二叉树的存储时，父子节点之间需要满足的关系为：

parent = (child+1)/2;
leftchild = parent2-1;
rightchild = parent2+2;
ps:parent指父节点在数组中的下标位置，leftchild指左子节点在数组中的下标位置，rightchild指右子节点在数组中的下标位置

那么对于满二叉树和完全二叉树，我们按照一层一层（层序）往数组中进行存储。
举例如下图所示，大家可以按照下图简单计算验证一下父子之间是否满足父子关系：
在这里插入图片描述

可以知道，对于满二叉树和完全二叉树进行层序存储在数组中，按照下标计算都是满足上面所述的父子关系。

而对于普通二叉树（非满二叉树，非完全二叉树），我们依然按照上面存储进行计算
在这里插入图片描述
可以发现不符合父子节点之间的关系，问题在于2节点的右节点为空，而在存储时对于空节点我们并没有在数组中进行存储记录，相当于在数组中少了一个位置，那么我们如果把空节点加上，如下图：
在这里插入图片描述
这样就满足了父子间的关系，但是对于下标为4的位置并没有存储数据，就造成了空间浪费。

所以，对于普通二叉树我们一般使用链式结构进行存储，避免空间浪费。

现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

2.堆的概念及结构

如果有一个关键码的集合K = {K0，K1，K2，…，Kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki<=K2i+1且Ki<=K2i+2(Ki>=K2i+1且Ki>=K2i+2)i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质：

1.堆中某个节点的值总是不大于或不小于其父节点的值；
2.堆总是一棵完全二叉树;

在这里插入图片描述
堆的兄弟节点（同一父节点的子两个子节点）之间是不论大小的，而对于小堆其父节点的值一定小于子节点，对于大堆其父节点的值一定大于子节点。

3.堆的实现

堆初始化结构：

//堆初始化
void HPInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->capacity = php->size = 0;
}

在给定一个数组去实现成堆之前我们需要先了解内部实现的核心逻辑。

3.1 向下调整算法 AdJustDown

现在我们给出一个数组，逻辑上看做一颗完全二叉树。

int arr[] = {27,15,19,18,28,34,65,49,25,37}

我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。
向下调整算法有一个前提：左右子树必须是一个堆，才能调整。
上面数组逻辑上的二叉树可画为：
在这里插入图片描述
可以看出来，根节点27影响了整体的小堆结构，那么我们如何将其转变为小堆呢？
在这里插入图片描述

（制作不是很好大家将就着看看就行）
按照上面图片显示的流程，我们在逻辑上就把之前的二叉树变成了小堆排序，而其逻辑实现思想就是向下调整。

向下调整：

再强调一边：
向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

从根开始，比较其子节点的大小，如果为大堆排序就将父节点与子节点中较大的节点交换，如果为小堆就将父节点与子节点中较小的节点交换。交换完毕继续重复以上逻辑，直到父节点大于子节点（大堆）或是父节点小于子节点（小堆）即可完成堆排序。

代码实现：

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

//向下调整O(logN)
void AdJustDown(HPDataType* a, int n, int parent)
{
	//从左孩子开始,child为小孩子那个
	 int child = parent * 2 + 1;

	 while (child<n)
	 {
		 
		 if (child + 1 < n && a[child] > a[child + 1])
		 {
			++child;
		 }

		 if (a[child] < a[parent])//小堆<,大堆>
		 {
			 Swap(&a[parent], &a[child]);
			 parent = child;
			 child = child * 2 + 1;
		 }
		 else
		 {
			 break;
		 }
	 }
}

3.2 向上调整算法 AdJustUP

在一个二叉树的数组中如果我们尾插了一个数据，可能就导致结构不再是堆。

所以我们如果是在现有的一个堆里进行数据尾插存储，那么我们要保证数据插入后还是堆，这时一般使用向上调整算法。

下面我们给出一个数组，请画出其逻辑结构二叉树：

int arr[] = {10,15,56,25,30,70}

二叉树：

在这里插入图片描述
如果我将5尾插在数组当中，那么就相当于是将56节点的右孩子连了一个5节点：
在这里插入图片描述
这显然已经不是小堆了，调整逻辑如下：
在这里插入图片描述
这就是向上调整的整体逻辑：

如果是进行小堆排序，将尾节点值与其父节点的值进行比较，如果小于父节点就交换，如果进行大堆，那就判断子节点是否大于父节点，若是大于就交换。

代码实现：

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

//向上调整 O(logN)
void AdJustUP(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	//while (1)严格来说不行
	while(child>0)
	{
		if (a[child] < a[parent])//小堆<,大堆>
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

向下调整算法和向上调整算法的时间复杂度都为O（logN），大家感兴趣可以算一下。

3.3 堆的创建

向上调整和向下调整都是基于已经形成了堆上面，那么如果随便给一个本就不是堆的数组，我们该如何进行建堆呢？

3.3.1 向上建堆

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个小堆，现在我们通过算法，把它构建成一个小堆。

int a[] = {5，3，6，8，2，1};

根节点左右子树不是小堆，我们怎么调整呢？

这里我们从根的左孩子节点开始向上调整，根据数组存储顺序向后以此执行，直到最后一个节点为止。

其二叉树为：
在这里插入图片描述
调整逻辑：
在这里插入图片描述
从根节点的子节点开始，进行向上调整，一次调整完毕将子节点对应数组下标加1进入下一个节点进行向上调整，直到除了根的所有节点都调整完毕，二叉树便变成了堆。

代码实现：

//向上调整 O(logN)
void AdJustUP(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	//while (1)严格来说不行
	while(child>0)
	{
		if (a[child] < a[parent])//小堆<,大堆>
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//初始化建堆
void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->size = php->capacity = n;

	//向上建堆 O(N*logN)
	for (int i = 1; i < php->size; i++)
	{
		AdjustUp(php->a, i);
	}
}
3.3.2 向下建堆

向下建堆就是根据向下调整的逻辑进行。

我们把二叉树分为其根和子树，再把子树分为其根和子树，将每一个分好的子树都进行向下调整，直到叶子节点为止。

我们还拿上面数组为例：

int a[] = {5，3，6，8，2，1};

这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成小堆。

调整逻辑：在这里插入图片描述
代码实现：

//向下调整O(logN)
void AdJustDown(HPDataType* a, int n, int parent)
{
	//从左孩子开始,child为小孩子那个
	 int child = parent * 2 + 1;

	 while (child<n)
	 {
		 
		 //假设法选出左右节点中大/小的节点
		 if (child + 1 < n && a[child] > a[child + 1])
		 {
			++child;
		 }

		 if (a[child] < a[parent])//小堆<,大堆>
		 {
			 Swap(&a[parent], &a[child]);
			 parent = child;
			 child = child * 2 + 1;
		 }
		 else
		 {
			 break;
		 }
	 }
}

//初始化建堆
void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->size = php->capacity = n;
		//向下建堆 O(N)
	for (int i = (php->size - 1 - 1) / 2; i >= 0; i--)
	{
		AdJustDown(php->a, php->size, i);
	}
}

向上建堆和向下建堆的时间复杂度分别为O（N*logN），O（N）。
因为向下建堆的时间复杂度小，所以我们在实际工作中进行建堆一般是选择向下建堆。

3.3.3 堆的初始化与销毁

在数据结构中，创建任何结构，都需要对其进行初始化和销毁。

代码实现：

//堆初始化
void HPInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->capacity = php->size = 0;
}

//堆销毁
void HPDestory(HP* php)
{
	assert(php);

	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}
3.3.4 堆的插入（压栈）

插入一个数到数组的尾上，再进行向上调整算法，直到满足堆。
代码实现：

//向上调整 O(logN)
void AdJustUP(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	//while (1)严格来说不行
	while(child>0)
	{
		if (a[child] < a[parent])//小堆<,大堆>
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//压栈 O(logN)
void HPPush(HP* php, HPDataType x)
{
	assert(php);

	//判断空间是否足够
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		php->a = tmp;
		php->capacity = newcapacity;
	}

	php->a[php->size] = x;
	php->size++;

	//数据尾插向上调整
	AdJustUP(php->a, php->size-1);
}
3.3.5 取堆顶的数据

在建好的堆中返回其根部数据。
代码实现：

//返回根数据
HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size);

	return php->a[0];
}
3.3.6 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

代码实现：

//向下调整O(logN)
void AdJustDown(HPDataType* a, int n, int parent)
{
	//从左孩子开始,child为小孩子那个
	 int child = parent * 2 + 1;

	 while (child<n)
	 {
		 
		 if (child + 1 < n && a[child] > a[child + 1])
		 {
			++child;
		 }

		 if (a[child] < a[parent])//小堆<,大堆>
		 {
			 Swap(&a[parent], &a[child]);
			 parent = child;
			 child = child * 2 + 1;
		 }
		 else
		 {
			 break;
		 }
	 }
}

//删除根数据O(logN)
void HPPop(HP* php)
{
	assert(php);
	assert(php->size);

	//将根数据与最后一个子叶交换，再删除最后一个数据
	Swap(&php->a[0], &php->a[php->size-1]);
	php->size--;

	//向下调整
	AdJustDown(php->a, php->size, 0);
}
3.3.7 堆的数据个数

代码实现：

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}
3.3.8 堆的判空

代码实现：

//判断堆是否为空
bool HPEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

二、堆的完整实现代码

Heap.h:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <time.h>

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

//小堆

//堆初始化
void HPInit(HP* php);
//初始化建堆
void HPInitArray(HP* php, HPDataType* a, int n);

//堆销毁
void HPDestory(HP* php);

//压栈
void HPPush(HP* php, HPDataType x);

//返回根数据
HPDataType HPTop(HP* php);

//删除根数据
void HPPop(HP* php);

//堆的数据个数
int HPSize(HP* php);

//判断堆是否为空
bool HPEmpty(HP* php);

Heap.c:

#include "Heap.h"

//堆初始化
void HPInit(HP* php)
{
	assert(php);

	php->a = NULL;
	php->capacity = php->size = 0;
}

//堆销毁
void HPDestory(HP* php)
{
	assert(php);

	free(php->a);
	php->a = NULL;
	php->capacity = php->size = 0;
}

void Swap(HPDataType* px, HPDataType* py)
{
	HPDataType tmp = *px;
	*px = *py;
	*py = tmp;
}

//向上调整 O(logN)
void AdJustUP(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	//while (1)严格来说不行
	while(child>0)
	{
		if (a[child] < a[parent])//小堆<,大堆>
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//压栈 O(logN)
void HPPush(HP* php, HPDataType x)
{
	assert(php);

	//判断空间是否足够
	if (php->size == php->capacity)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		php->a = tmp;
		php->capacity = newcapacity;
	}

	php->a[php->size] = x;
	php->size++;

	//数据尾插向上调整
	AdJustUP(php->a, php->size-1);
}

//返回根数据
HPDataType HPTop(HP* php)
{
	assert(php);
	assert(php->size);

	return php->a[0];
}

//向下调整O(logN)
void AdJustDown(HPDataType* a, int n, int parent)
{
	//从左孩子开始,child为小孩子那个
	int child = parent * 2 + 1;

	while (child < n)
	{

		if (child + 1 < n && a[child] > a[child + 1])
		{
			++child;
		}

		if (a[child] < a[parent])//小堆<,大堆>
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//删除根数据O(logN)
void HPPop(HP* php)
{
	assert(php);
	assert(php->size);

	//将根数据与最后一个子叶交换，再删除最后一个数据
	Swap(&php->a[0], &php->a[php->size-1]);
	php->size--;

	//向下调整
	AdJustDown(php->a, php->size, 0);
}

int HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

//判断堆是否为空
bool HPEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

//初始化建堆
void HPInitArray(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->size = php->capacity = n;

	//向上建堆 O(N*logN)
	/*for (int i = 1; i < php->size; i++)
	{
		AdjustUp(php->a, i);
	}*/

	//向下建堆 O(N)
	for (int i = (php->size - 1 - 1) / 2; i >= 0; i--)
	{
		AdJustDown(php->a, php->size, i);
	}
}

//建堆排序

//排序
// 升序
//小堆时间复杂度太大O(N^2),用大堆进行排序O(N*logN)
//大堆

//升序  大堆 O(N*logN)
//降序  小堆 O(N*logN)
void HeapSort(HPDataType* a, int n)
{
	//根据数组直接建堆 O(N)
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdJustDown(a, n, i);
	}

	//交换根和尾的位置，删除尾，再向上调整 O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdJustDown(a, end, 0);
		--end;
	}
}

三、完结撒❀

如果以上内容对你有帮助不妨点赞支持一下，以后还会分享更多编程知识，我们一起进步。
最后我想讲的是，据说点赞的都能找到漂亮女朋友❤
在这里插入图片描述

.自定义.
关注
  • 51
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 20
    评论
专栏目录
严蔚敏数据结构c语言版本可运行源码、完全c语言代码实现.zip
06-14
《严蔚敏数据结构C语言版本可运行源码与完全C语言代码实现》是一份针对初学者和进阶者极具价值的学习资源。这份压缩包包含了严蔚敏教授编著的经典教材《数据结构》中所有算法的C语言实现，旨在帮助读者深入理解数据...
严蔚敏 - 数据结构 (C 语言版) 第二版 新版 PPT + 习题答案 + 源代码 + 算法演示动画
04-10
1. 数据结构的基本概念：在计算机科学中，数据结构是指一组数据的存储结构，包括线性结构（如数组、链表）、树形结构（如二叉树、堆）、图结构以及散列结构等。理解这些基本概念对于理解和设计高效的算法至关重要。 ...
严蔚敏_数据结构_c语言版算法实现
01-18
《严蔚敏_数据结构_c语言版算法实现》是一份以C语言为编程工具，深入讲解数据结构的教程。这份资料包含多个章节，涵盖了数据结构的基础到进阶内容，为学习者提供了丰富的实践代码，帮助理解和掌握数据结构的精髓。 ...
武大数据结构课件-C++语言实现
06-26
4. **排序与查找算法**：这些课件可能包含了排序算法（如冒泡排序、插入排序、快速排序、归并排序、堆排序等）和查找算法（如顺序查找、二分查找、哈希查找）的讨论，这些都是数据结构课程的重点。 5. **图**：单元...
零基础学数据结构源代码
09-11
二叉树、平衡树（AVL树、红黑树）和堆（优先队列）是常见的树型数据结构，书中可能涵盖了它们的创建、查找、插入和删除操作。 6. **图**：图由节点和边组成，用于表示对象之间的复杂关系。图遍历（深度优先搜索、...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1067
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 286
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 714
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构---二叉树
weixin_47808575的博客
07-22 47
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 735
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】堆的实现以及建堆算法和堆排序
2301_81670477的博客
07-19 973
哈喽，各位小伙伴大家好！上期给大家讲了树，二叉树以及堆。今天带着大家实现堆这个数据结构，以及堆排序。话不多说，咱们进入正题！向大厂冲锋！
数据结构之细说链表
m0_73634434的博客
07-17 1082
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1102
24暑假刷题day15打卡 二叉树进阶
数据结构~~顺序表
最新发布
TU^的博客
07-22 374
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
数据结构和算法（刷题）- 用栈实现队列
yunshancangcang_的博客
07-19 365
出队涉及AB两栈的迁移。这是均摊时间复杂度，均摊到每次出队上就是。只用1个栈肯定不行，得用两个栈。思考：入队的时间复杂度显然是。思路：一个栈A，一个栈B。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 174
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
《数据结构-用C语言描述第三版》课后答案 第三章
m0_62469100的博客
07-19 992
b[2] = 2;b[n+1] = 2;i>=2;i--){若调用 bin ( A ,5)，给出 A 数组中第1个到第6个数组元素的值。答：数组中的值为每次递归将后面一个元素赋值为2，然后前面的元素分别加等其前面的元素。
【手撕数据结构】把玩顺序表
apple_61439616的博客
07-19 887
顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤数组线性结构又是什么意思，这就不得不提到线性表了线性表（linear list）是n个具有相同特性的数据元素的有限序列线性表是⼀种在实际中⼴泛使 ⽤的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串注意的是，他在逻辑结构上一定是连续的，但在物理结构上不一定是连续的.线性表在物理上存储时，通常以数组和链式结构的形式存储那么我们知道，数组在内存中存储也是连续的，并且也是类型一致，那么他与顺序表的区别是什么呢.
数据结构 - 队列（精简介绍）
mydaily_的博客
07-19 393
循环队列（Circular Queue），也称为环形队列，是一种队列数据结构，它将队列的最后一个位置连接到队列的第一个位置，使其形成一个环。在循环队列中，队列的前端和后端都可以绕回到数组的起始位置，从而有效利用数组的空间。单端队列升级版，允许在队头和队尾都进行元素的插入删除操作。，队列中元素会根据某种规则进行优先级排序。只能从尾部插入，头部取出元素。普通队列为单端队列，先进先出（FIFO）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值