探索数据结构：树-二叉树-堆（2）

最新推荐文章于 2024-09-15 11:10:00 发布
最新推荐文章于 2024-09-15 11:10:00 发布
阅读量959 收藏 18
点赞数 26
文章标签： 数据结构 算法 c语言 visualstudio 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81324046/article/details/139722415
版权

探索数据结构：树-二叉树-堆（3）


前言：
上一个章节（ 树-二叉树-堆（2））我们学习了二叉树的储存结构以及结构的实现，还学习了堆的概念、结构、堆的实现和向上调整和向下调整算法。
所以，今天我们继续来学习堆和二叉树的相关知识！
在这里插入图片描述

一、堆

1.1堆的插入

在这里插入图片描述
注意：这里的插入的前提是已经满足堆的条件的前提下进行的
代码实现：

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	//插入之前先判断空间是否充足
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : 2 * hp->capacity;
		HPDataType* new = (HPDataType*)realloc(hp->a, newcapacity * sizeof(HPDataType));

		hp->a = new;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;

	//插入完后继续执行向下调整，保持堆的结构
	AdjustUp(hp->a,hp->size-1);

}

1.2堆的删除

这里堆的删除指的是删除堆顶的数据，那面对这种情况我们该怎么办呢？
在这里插入图片描述
这里我们可以将栈顶的数据与栈底的数据做一个交换，然后我们删除栈底的数据，最后在进行向下调整算法，这样就可以删除栈顶数据了。
在这里插入图片描述
代码实现：

// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	if (hp->size == 0)//此时堆内没有数据了
	{
		return;
	}
	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	if (hp->size > 0)
	{
		AdjustDown(hp->a, hp->size, 0);
	}
	
}

二、堆的应用

2.1堆排序

1.建堆（利用堆删除思想来进行排序）

  • 升序 建大堆
  • 降序 建小堆

有的人可能会想着如果排序的要求是升序，我直接建一个小堆不就行了吗？
在这里插入图片描述
在这里有一种方法可以暂且满足这个升序，但是只是让结果是升序，并没有将数组里面变成升序。代码如下：

int a[] = { 4,2,8,1,5,6,9,7,3,2,23,55,232,66,222,33,7,1,66,3333,999 };
	HP hp;
	HPInit(&hp);//堆的初始化
	for (size_t i = 0; i < sizeof(a)/sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}

	int i = 0;
	while (!HPEmpty(&hp))
	{
		printf("%d ", HPTop(&hp));
		HPPop(&hp);
	}
	printf("\n");

这里有的人又会有另外一种思路了，我再创建一个数组，每次在删除堆顶的元素时我将堆顶数据先保存到我创建的这个数组里面，这样最后我创建的这个数组里面的内容不就是有序了吗。这个确实是一种方法，但是如果我的数据量非常大的时候，你就需要创建一个非常大的数组，这也导致你代码的效率非常低。代码如下：

int a[] = { 4,2,8,1,5,6,9,7,3,2,23,55,232,66,222,33,7,1,66,3333,999 };
	HP hp;
	HPInit(&hp);
	for (size_t i = 0; i < sizeof(a)/sizeof(int); i++)
	{
		HPPush(&hp, a[i]);
	}

	int i = 0;
	while (!HPEmpty(&hp))
	{
		a[i] = HPTop(&hp);//取栈顶的数据放入到数组当中
		i++;
		HPPop(&hp);
	}
	printf("\n");
  • 升序建大堆的原因：
       当你建完大堆后，将堆顶的数据和最后一个数据进行交换，这样最后一个数据就是最大值了，接下来我们只需对剩下的n-1（假设堆内数据个数为n）个数据进行调整建堆就行了，这样最后数组里面的数据就是升序的了。因此降序建小堆也很容易理解了。
    在这里插入图片描述

2.2 Top-k问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

对于Top-k问题，我们能想到的就是先将数据排个序，然后根据自己的需求去取数据就行，但是前提是数据量少的情况下，如果数据量非常大的情况下，排序的话就非常困难了，所以这里最佳的解决方式就是利用堆来解决这个问题。基本思路如下：

1.用数据集合中前K个元素来建堆

  • 求前k个最大的元素，则建小堆。
    这样利用堆的删除就可以求出前K个最大的元素。
  • 求前k个最小的元素，则建大堆。
    这样利用堆的删除就可以求出前K个最小的元素。

2.3堆相关所有代码

Heap.h文件：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int HPDataType;

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


void AdjustDown(HPDataType* a, int n, int parent);//数组  数组个数  


//堆的初始化
void HeapInit(Heap* hp);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
bool HeapEmpty(Heap* hp);

Heap.c文件：

#include"Heap.h"

void Swap(HPDataType* a, HPDataType* b)
{
	HPDataType tmp = *a;
	*a = *b;
	*b = tmp;
}

//堆的初始化
void HeapInit(Heap* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->capacity = hp->size = 0;
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);
	free(hp->a);
	hp->a = NULL;
	hp->capacity = hp->size = 0;

}
void AdjustUp(HPDataType* a,int child)
{
	int parent = (child - 1) / 2;

	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void AdjustDown(HPDataType* a, int n, int parent)  
{
	//假设左孩子小
	int child = parent * 2 + 1;

	while (child < n )
	{
		if (a[child] > a[child + 1] && child + 1 < n)//假设不成立,.....child + 1 <n是因为可能会超出数组边界，导致访问越界错误。
		{
			child++;
		}

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

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);
	//插入之前先判断空间是否充足
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : 2 * hp->capacity;
		HPDataType* new = (HPDataType*)realloc(hp->a, newcapacity * sizeof(HPDataType));

		hp->a = new;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;

	//插入完后继续执行向下调整，保持堆的结构
	AdjustUp(hp->a,hp->size-1);
	//AdjustDown(hp->a, hp->size, 0);
}

// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	if (hp->size == 0)//此时堆内没有数据了
	{
		return;
	}
	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	if (hp->size > 0)
	{
		AdjustDown(hp->a, hp->size, 0);
	}
	
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	assert(hp);

	return hp->a[0];

}
// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);
	return hp->size;
}
// 堆的判空
bool HeapEmpty(Heap* hp)
{
	assert(hp);
	return hp->size == 0;
}

三、二叉树链式结构的实现

3.1前提说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树， 快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

typedef int BTDataType;
typedef struct BinaryTreeNode
{
 BTDataType data;
 struct BinaryTreeNode* left;
 struct BinaryTreeNode* right;
}BTNode;
 
BTNode* CreatBinaryTree()
{
 BTNode* node1 = BuyNode(1);
 BTNode* node2 = BuyNode(2);
 BTNode* node3 = BuyNode(3);
 BTNode* node4 = BuyNode(4);
 BTNode* node5 = BuyNode(5);
 BTNode* node6 = BuyNode(6);
 
 node1->left = node2;
 node1->right = node4;
 node2->left = node3;
 node4->left = node5;
 node4->right = node6;

 return node1;
 }

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解。
      如果对二叉树的基本内容有些遗忘的可以看二叉树（1）了解一下

3.2二叉树的遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
一般二叉树的遍历分为前序遍历、中序遍历、后序遍历、层序遍历。

（1）前序遍历

前序遍历指的是一个二叉树遍历的顺序是先遍历根节点，然后再遍历左子树，最后再遍历右子树。
代码实现：

//前序遍历
void prevOrder(BTNode*root)
{
	if (root == NULL)
	{
		return;
	}
	printf("%d  ", root->data);
	prevOrder(root->left);
	prevOrder(root->right);

}

（2）中序遍历

中序遍历指的是一个二叉树遍历的顺序是先遍历左子树，然后遍历根节点，最后遍历右节点。
代码实现：

//中序遍历
void Inorder(BTNode*root)
{
	if (root == NULL)
	{
		return;
	}
	Inorder(root->left);
	printf("%d  ", root->data);
	Inorder(root->right);
}

（3）后序遍历

后序遍历指的是 一个二叉树遍历的顺序是先遍历左子树，然后遍历右子树，最后再遍历根节点。
代码实现：

//后序遍历
void endOrder(BTNode* root)
{
	if (root ==NULL)
	{
		return;
	}
	endOrder(root->left);
	endOrder(root->right);
	printf("%d  ", root->data);
}

（4）层序遍历

层序遍历指的是遍历一个二叉树的方式是一层一层的遍历的。
如下图所示：首先遍历的是A节点，然后在遍历B节点，接下来就依次一层一层的的遍历。

在这里插入图片描述
层序遍历代码实现思路：这里二叉树的层序遍历我们要使用到队列的知识，对该部分知识有遗忘的可以看（栈-队列）内容回顾一下。这里我们总体的思路就是一层带一层,具体可以看下面 的流程图。
在这里插入图片描述
这里我们先将节点（也就是上图的1节点）入队列，然后再将节点出队列，出完后将该节点的左右子树节点进行入队列（上图的1节点出队列后将它的左右子树节点2和3入队列）。然后再出队列中队头的数据，然后继续将它的左右子树节点入队列（上图的2节点出完队列后将它的左右子树节点4和5出队列）。最后不断的入队列和出队列，直到队列为空时，代表层序遍历结束。

代码实现：

3.3二叉树的扩展问题

扩展一

// 二叉树结点个数
int BinaryTreeSize(BTNode* root);

代码实现：

// 二叉树结点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

这里我们运用递归的思路，如果节点为空，就return 0，如果不为空，那么节点的个数就是左子树的节点+右子树的节点+自己本身这个节点。

扩展二

// 二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root);

代码实现：

// 二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)//判断是否为叶子节点
	{
		return 1;
	}

	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

这里一样也是用了递归的思路，如果节点为空，就return 0，如果不为空就判断该节点是否为叶子节点，如果是就return 1，然后总的叶子节点个数就是左子树的叶子节点+右子树的叶子节点。

扩展三

// 二叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k);

代码实现：

// 二叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
			return 1;
	}
	return BinaryTreeLevelKSize(root->left,k-1) + BinaryTreeLevelKSize(root->right,k-1);

}

扩展三

// 二叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);

代码实现：

// 二叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* ret1=BinaryTreeFind(root->left,x);
	if (ret1)
	{
		return ret1;
	}
	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
	{
		return ret2;
	}
}

3.4二叉树相关代码

#include<stdio.h>
#include<stdlib.h>


typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	node->data = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}


BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}
//前序遍历
void prevOrder(BTNode*root)
{
	if (root == NULL)
	{
		return;
	}
	printf("%d  ", root->data);
	prevOrder(root->left);
	prevOrder(root->right);

}
//中序遍历
void Inorder(BTNode*root)
{
	if (root == NULL)
	{
		return;
	}
	Inorder(root->left);
	printf("%d  ", root->data);
	Inorder(root->right);
}
//后序遍历
void endOrder(BTNode* root)
{
	if (root ==NULL)
	{
		return;
	}
	endOrder(root->left);
	endOrder(root->right);
	printf("%d  ", root->data);
}

// 二叉树结点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

// 二叉树叶子结点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)//判断是否为叶子节点
	{
		return 1;
	}

	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

// 二叉树第k层结点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
			return 1;
	}
	return BinaryTreeLevelKSize(root->left,k-1) + BinaryTreeLevelKSize(root->right,k-1);

}

// 二叉树查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* ret1=BinaryTreeFind(root->left,x);
	if (ret1)
	{
		return ret1;
	}
	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
	{
		return ret2;
	}
}

在这里插入图片描述

麻木的根号三
关注
[数据结构] -堆与二叉树 【学习笔记】
Iiverson2000的博客
04-26 974
二叉树 1、满二叉树：k层满二叉树节点总数位（2^k）-1 2、完全二叉树：可以不满，但必须按顺序 告诉你一棵二叉树有N个节点，那么他的高度是多少？ 2^k - 1 =N k = log(N+1) 若根节点为第一层，那么非空二叉树的第i层上最多有2^(i-1)个节点 若根节点为第一层，那么深度为h的二叉树的最大结点数是 2^h -1 度为零的节点个数比度为二的节点个数多一个：n0 = n2 +1; 来两道题练练手，看看概念理解的怎么样？ 1、某二叉树共有 399 个结点，其中 有199个为 度为2的
【数据结构】---“二叉树”--“堆”
weixin_52563203的博客
08-12 154
二叉树的实现，堆，堆排序，topk问题
探索数据结构：分支的世界之二叉树与堆
x3262551980的博客
07-04 1549
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
数据结构：二叉树与树
m0_72625526的博客
05-25 2691
树是一种非线性的数据结构，它是n(n >= 0)个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足：2.1 有且仅有一个特定的称为根的结点。2.2 当n > 1时，其余结点可分为m(m > 0)个互不相交的有限集T1 ……Tm，其中每个集合本身又是一棵树，并且称为根的子树。显然，树的定义是递归的，即在树的定义中又用到其自身，树是一种递归的数据结构。树作为一种逻辑结构，同时也是一种分层结构，具有以下两点特点：2.3 树的根结点没有前驱，除根结点外的所有结点有且只有一个前驱。
数据结构算法Coursera-UCSD-HSE：UC San Diego和HSE的数据结构和算法Coursera专业化
02-05
在数据结构方面，课程会讲解各种类型的数据组织方式，如数组、链表、栈、队列、散列表、树（二叉树、平衡树如AVL树和红黑树）、图等。这些数据结构各有特点，适用于不同的场景。例如，数组提供随机访问，但插入和...
数据结构演示--离线版
03-10
8. **堆**：一种特殊的树形数据结构，通常用于优先队列实现。 9. **堆排序和快速排序**：两种高效的排序算法，基于不同的策略对数据进行排序。 离线版的“数据结构演示”可能会涵盖这些内容，并提供互动式的体验，...
Java数据结构面试题集锦：深入探索数据结构的核心概念和应用
06-14
2. **Java 中的数据结构**：Java 提供了多种内置数据结构，如： - **数组**：连续内存空间，通过索引访问，支持静态大小。 - **链表**：非连续内存结构，通过指针连接，插入和删除操作快。 - **栈**：后进先出...
[2022 ICLR] Pyraformer: Low-Complexity Pyramidal Attention for Long-Range 时空序列建模和预测
小卜妞的博客
04-21 4169
Pyraformer: Low-Complexity Pyramidal Attention for Long-Range T-S Modeling and Forecasting 低复杂度的金字塔型注意力模型，用于长时序列建模和预测 我们研究的时空数据类任务（预测或异常检测等），需要考虑时间和空间两个维度。目前的研究成果在空间维度基本是以图卷积为主导，不同之处在于不同工作中定义的图类型有所不同，一般是静态图（即地理位置形成的天然拓扑图），还有结合时间或POI等额外信息计算得到的节点拓扑关系，一般称为动态
【数据结构与算法基础】树与二叉树的互化
wayne_lee_lwc的博客
12-11 4069
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
【数据结构】线段树复杂应用
2302_80811345的博客
09-13 1061
随着星际网络的进一步建设和规模的增大，一个新的问题出现在网络工程师面前——地址空间不够用了！原来，星际网络采用了传统的 IPv6 协议，虽然有2128级别的可用地址数量，但面对广袤无垠的宇宙和爆炸式增长的网络用户数，如此庞大的地址空间也面临了用尽的那一天。新的通信协议的研发工作交给了著名的网络科技圣地——西西艾弗星。最终，经过2333年的不懈努力，西西艾弗星的工程师们设计出了一种新的协议——“西西艾弗IP协议”，又称 IPxxaf。在 IPxxaf 协议中，一个地址由n位二进制位组成，其中。
数据结构---非线性--树
2301_80434764的博客
09-13 786
本文将详细介绍树及其变体在计算机科学中的应用及实现。首先，将概述树的基本概念、结构及其实际应用，包括树的表示方法及在各种应用场景中的重要性。接着，深入探讨二叉树的基本概念、特殊类型及其性质，并比较顺序存储和链式存储这两种主要存储结构。 在探讨二叉树的顺序结构及实现时，重点讲解堆的概念与结构，涵盖堆的向上和向下调整算法、建堆的时间复杂度以及堆的插入和删除操作，并讨论堆在排序和Top-K问题中的应用。最后，讨论二叉树的链式结构实现，包括各种遍历方式（如前序、中序、后序和层序遍历）和常见接口。
【数据结构】顺序表的定义和实现
m0_74209563的博客
09-13 573
顺序表是指用的方式实现线性表顺序存储：把的元素存储在的存储单元中，元素之间的关系由存储单元的邻接关系来体现【看到这是否会和我有同样的疑问：顺序表和数组是一样的吗？这个问题可以参考这篇文章的解释】
重头开始嵌入式第三十九天（数据结构 栈）
qq_64792908的博客
09-13 733
栈是一种数据结构，它具有以下特点：1. 只能在一端进行插入和删除操作，这一端被称为栈顶。2. 遵循“后进先出”（Last In First Out，LIFO）的原则。也就是说，最后进入栈的元素最先被弹出。3. 可以用数组或链表来实现。例如，把书一本一本叠放在桌子上，只能从最上面取书或放书，这就类似栈的操作。后放上去的书先被拿走，符合“后进先出”原则。
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
BamBoo_Bean的博客
09-13 651
C语言-数据结构 弗洛伊德算法(Floyd)邻接矩阵存储
Java-数据结构-二叉树-基础 (oﾟ▽ﾟ)o
2303_80388948的博客
09-12 928
OK，到这里呢，我们的二叉树基础就到这里就结束了，我们接下来看看关于二叉树的相关的习题，并且在题中我们会看见我们 二叉树的创建方法。让我们期待下次的博客吧！！！拜拜啦~~~
数据结构——栈和队列（队列的定义、顺序队列以及链式队列的基本操作）
weixin_74209413的博客
09-13 1173
队列和栈一样，也是限定只能在表的“端点”进行的线性表。队列在插入的时候，只能在表尾进行插入，在删除的时候，只能在表头进行删除。（先进先出），表尾即队尾，表头即队头。栈和队列是线性表的子集（是插入和删除位置受限的线性表）由于队列的操作具有先进先出的特性，使得队列成为程序设计中解决类似排队问题的有用工具。队列的逻辑结构与同线性表相同，仍为一对一关系。队列的存储结构有顺序队和链队，以循环顺序队列更常见。关键是掌握入队和出队操作，具体实现依顺序队或链队的不同而不同。
数据结构—顺序表
最新发布
2301_80151359的博客
09-15 468
线性表是一种在实际中广泛使用的数据结构，线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
《征服数据结构》滚动数组
数据结构和算法
09-12 278
摘要：1，一维滚动数组的介绍2，多维滚动数组的介绍1，一维滚动数组的介绍滚动数组不是一种数据结构，它是一种算法优化思想，滚动数组的作用在于优化空间，降低空间复杂度，每次使用固定的一些存储空间。比如我们常见的斐波那契数列：f[n] = f[n – 1] + f[n – 2] ，普通的写法如下：Java 代码：//1、2、3、5、8、13、21、34、…… privateintfibonacci...
非线性结构探索：树与二叉树的数据特性
"本文主要介绍了数据结构中的树与二叉树的基本概念，包括树的定义、节点关系、树的性质以及相关术语。" 在计算机科学中，数据结构是组织和存储数据的方式，它对于高效地执行算法至关重要。线性数据结构如数组、链表...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值