【数据结构】数据结构中的隐藏玩法——栈与队列

最新推荐文章于 2024-06-12 18:54:42 发布
最新推荐文章于 2024-06-12 18:54:42 发布
阅读量1.2k 收藏 64
点赞数 93
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++ java 开发语言 线性回归 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjh20040819/article/details/139156215
版权

前言：

哈喽大家好，我是野生的编程萌新，首先感谢大家的观看。数据结构的学习者大多有这样的想法：数据结构很重要，一定要学好，但数据结构比较抽象，有些算法理解起来很困难，学的很累。我想让大家知道的是：数据结构非常有趣，很多算法是智慧的结晶，我希望大家在学习数据结构的过程是一种愉悦的心情感受。因此我开创了《数据结构》专栏，在这里我将把数据结构内容以有趣易懂的方式展现给大家。

1.栈

1.1栈的定义

怎么给大家引入队列概念呢？有了，我们在中学学习化学时肯定接触过下面这个实验器材：

胶头滴管是我们在学习化学常使用的一种实验器材，胶头滴管用于精确地滴取液体。它通常由一个透明的玻璃或塑料瓶身和一个连接瓶身和滴液管的胶头组成。 我们使用时一般是将胶头浸入所需液体中，轻轻按压胶头，使其充满液体，将胶头滴管垂直放置到需要滴液的容器中，轻轻松开手指，让液体滴下。后进入胶头滴管的液体将会先滴出，先进入的胶头滴管的液体反而后滴出，像这样的例子反而可以引入数据结构——栈。

在我们软件应用中，栈这种后进先出的数据结构的应用是非常普遍的。比如我们用浏览器上网时不管什么浏览器都有一个“后退键”，当我们点击后可以按访问顺序逆序加载浏览过的网站。比如你正在浏览一篇介绍C语言相关内容的博客，你在看博主分享的代码，突然发现一个函数博主没详细介绍，你也不了解这个函数的功能，打开了CPlusPlus网站搜索它的功能，找到之后你又想返回去接着阅读，这时候单击左上角的“后退键”。如下图：

很多软件都有撤销操作，这也是使用栈来实现的，当然不同的软件具体实现代码会有很大差异，不过原理都是一样的。 栈是限定仅在表尾进行插入和删除操作的线性表。我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何数据元素的栈称为空栈，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。首先我们要知道栈是一个线性表，也就是说，栈元素具有线性关系，即前驱后驱关系，只不过它是一种特殊的线性表，前面定义中提到了在线性表的表尾进行插入和删除操作，这里的表尾指得是栈顶，而不是栈底。它的特殊之处就在于限制了这个线性表的插入和删除位置，他始终只在栈顶进行，这也就使得：栈底是固定的，最先进入栈的只能在栈底。栈的插入操作，叫做进栈，也叫压栈、入栈。

栈的删除操作，叫做出栈，有的也叫弹线。 

1.2进栈出栈的变化形式

这个最先进栈的元素，是不是只能是最后出栈呢？答案是不一定的，要看什么情况。栈对线性表的插入和删除的位置进行了限制，并未对元素出栈的时间进行限制，也就是说，在不是所有的元素都进栈的情况下，事先进入栈的元素也可以出栈，只要保证是栈顶元素就行，举例来说，如果我们现在是3个整型数字1、2、3依次进栈，会有哪些出栈的次序呢？

  1. 第一种：1、2、3进，再3、2、1出，这是最简单最好理解的一种，出栈次序为3、2、1。
  2. 第二种：1进，1出，2进，2出，3进，3出，也就是一个一个出嘛，出栈次序为1、2、3。
  3. 第三种：1进，2进，2出，1出，3进，3出。出栈次序为2、1、3。
  4. 第四种：1进，1出，2进，3进，3出，2出。出栈顺序为1、3、2。
  5. 第五种：1进，2进，2出，3进，3出，1出。出栈顺序为2、3、1。

有没有可能是3、1、2这样的次序呢？肯定是不会的，因为3先出栈的话，就意味着3曾经进过栈，既然3都进栈了，那么1和2也早就进栈了，此时2一定是在1的上面，更接近栈顶，那么出栈只可能是3、2、1，不然不满足1、2、3依次进栈的要求，所以不会出现1会比2先出栈的情况。下面给大家举两个简单的练习：

1.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。

A.12345ABCDE

B.EDCBA54321

C.ABCDE12345

D.54321EDCBA

答案：B

2.若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）

A.1432

B.2341

C.3142

D.3421

答案：C

1.3栈的各个功能的实现

上面我们也提到了栈是一个特殊的线性表，所以线性表的顺序存储和链式存储对于栈来说，也同样适用。所以栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些：

  1. 存储效率高：数组使用连续的内存空间存储数据，在访问元素时，可以直接通过索引访问，不需要额外的指针，因此访问速度更快。而链表每个节点需要存储数据和指向下一个节点的指针，占用更多的内存空间。
  2. 空间效率高：数组的存储空间是预先分配的连续内存块，不需要额外的指针来表示节点之间的链接关系，因此相对于链表来说，占用的内存空间更小。
  3. 实现简单：使用数组实现栈，只需要一个指针来表示栈顶的位置，通过调整指针的位置即可进行进栈和出栈操作。而链表实现栈需要额外的指针来表示栈顶和节点之间的链接关系，实现起来更加复杂。
  4. 随机访问：由于数组支持随机访问，可以直接通过索引访问栈中的任意元素。而链表只支持顺序访问，需要从头节点开始依次遍历到目标节点。
  5. 空间预分配：数组在创建时需要指定大小，可以根据需求进行空间的预分配。而链表可以根据实际情况动态调整大小，但可能会导致频繁的内存分配和释放操作。

所以在这里我们就是用数组来实现栈。我们先来定义一下栈的结构：

typedef int STDatatype;
typedef struct stack
{
	STDatatype* a;
	int top;      //栈顶
	int capacity;//容量
}ST;

1.3.1栈的初始化和销毁

通过上面栈的结构的定义，可以看出来它和我们之前写的顺序表极其相似，栈的初始化和顺序表基本相同：函数接受一个指向栈对象的指针pst，并使用assert断言函数确保pst不为 NULL，以确保安全性。接下来，将栈对象pst的成员变量a设置为 NULL。这表示栈中的元素存储数组当前为空，因为还没有分配内存。将栈对象pst的成员变量capacity设置为 0,这表示栈的当前容量为0，还没有分配内存。那么top初始化也为0吗？很多的数据结构相关书籍在介绍栈的初始化的时候都将top初始化为-1，这是因为栈为空栈的时候top等于0，当栈中有一个元素的时候top也为0，因此通常把空栈的判定条件定位top等于-1。当然将top初始化为0也是可以的，top的意义会发生变化，这时候我们让top指向的时栈顶的下一个元素。大多数书上都是以-1来初始化，那我就用0来初始化。我们来实现一下栈的初始化函数：

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

 栈的销毁是将栈占用的内存空间释放掉，栈的销毁具体操作步骤为：

  1. 将栈对象的成员变量a设置为 NULL，表示栈中的元素存储数组为空。
  2. 将栈对象的成员变量capacity设置为 0，表示栈的容量为0。
  3. 将栈对象的成员变量top设置为 0，表示栈为空。

我们来实现一下栈的销毁：

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

1.3.2栈中的入栈和出栈操作

栈的入栈具体操作步骤为：

  1. 检查栈是否已满。如果栈已满，那么无法将新元素入栈。这种情况下，可能需要扩展栈的容量或者处理溢出的方式。
  2. 如果栈未满，则将新元素放置在栈顶位置。
  3. 前面我们说了给top定义为0（即栈顶的下一个元素），所在这里我们还要将top+1。

我们来实现一下入栈的操作：

void STPush(ST* pst, STDatatype x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		ST* tmp = (ST*)realloc(pst->a, sizeof(ST));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return -1;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

栈的出栈具体操作步骤为：

  1. 检查栈是否为空。如果栈为空，无法执行出栈操作，因为栈中没有元素可以出栈，这时候我们可以使用assert断言一下。
  2. 如果栈非空，则将栈顶元素移除。在数组实现栈中，可以通过将栈顶指针减1，来实现将栈顶元素出栈。

我们来具体实现一下出栈的操作：

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

1.3.3栈中的其他操作

 我们在栈中能进行的操作不仅仅只有入栈和出栈两种操作，在这里再和大家介绍一些其他的操作。首先先来介绍获取栈顶元素操作，其具体操作步骤为：

  1. 检查栈是否为空。如果栈为空，无法获取栈顶元素，因为栈中没有元素可用。这时候我们仍然可以用assert来断言一下。

  2. 如果栈非空，则返回栈顶元素的值。注意不要返回top所在位置，因为我们给它的定义是栈顶的下一个元素。

我们来实现一下获取栈顶元素的函数：

STDatatype STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

获取栈中元素的个数实现就简单了，直接返回top的值即可，我们来实现一下这个函数：

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

 判断栈是否为空我们只需要判断top是否为0即可，我们来实现一下 ：

int STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

1.4多文件实现栈

stack.h文件：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDatatype;
typedef struct stack
{
	STDatatype* a;
	int top;      //栈顶
	int capacity;//容量
}ST;
void STInit(ST* pst);//栈的初始化
void STPush(ST* pst, STDatatype x);//栈的插入
void STPop(ST* pst);//栈的删除
STDatatype STTop(ST* pst);//获取栈顶元素
int STSize(ST* pst);//获取栈中有效的元素个数
int STEmpty(ST* pst);//检测栈是否为空
void STDestroy(ST* pst);//栈的销毁

 stack.c文件：

#include"stack.h"
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}
void STPush(ST* pst, STDatatype x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		ST* tmp = (ST*)realloc(pst->a, sizeof(ST));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return -1;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}
STDatatype STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}
int STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

test.c文件（用来测试函数功能）：

#include"stack.h"
void Test1()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	printf("%d ", STTop(&s));
	STPop(&s);
	printf("%d\n", STTop(&s));
	STPop(&s);
	STPush(&s, 4);
	STPush(&s, 5);
	while (!STEmpty(&s))
	{
		printf("%d ", STTop(&s));
		STPop(&s);
	}
	printf("\n");
}
int main()
{
	Test1();
	return 0;
}

 

2.队列 

2.1队列的定义

 大家在使用电脑的时候都应该经历过这种情况：电脑有时候疑似死机状态，鼠标点击什么都好像没有效果，无论怎么点击文件都没动静，就当我们失去耐心的时候，想要将它重启的时候，它好像清醒过来一样，把你刚才的操作全部按顺序执行了一遍——疯狂弹窗。这是因为操作系统在当时CPU一时忙不过来，等前面的事情忙完之后，后面多个指令需要通过一个通道输出，按先后次序排队执行造成的结果。再比如我们在某个网红店铺进行网购时，我们想要询问客服时，客服人员相对于顾客是较少的，在所有客服都占线的情况下，客户会被要求等待，直到某个客服空下来，才能让和先等待的客户联系，这里也是因为对当前所有联系客服的客户进行了排队处理。

上面的例子中都是应用了一种数据结构来实现刚才提到的先进先出的排队功能，这就是队列。队列是只允许一端进行插入的操作，而在另一端进行删除操作的线性表。队列是一种先进先出（First In First Out）的线性表，简称FIFO，允许插入的一端称为队尾，允许删除的一端称为队头。下图中1就是这个队列的队头，4是这个队列的队尾。这样我们就可以删除时总是从队头开始，而插入时从队尾插入。这也符合我们的一个习惯：排在第一个优先出队列，最后来的排队尾。

2.2 队列的各个功能的实现

队列和栈一样也是一种特殊的线性表，它一般也可以使用数组或者链表来实现，队列和栈不一样，它使用链表实现更优一些：

  1. 动态扩容：链表实现的队列可以动态地增加或减少节点，不需要预先定义容量。当需要插入新的元素时，可以直接创建新的节点并将其插入到队列的尾部，而不需要考虑数组的容量限制。这样可以更灵活地适应不同规模的数据。
  2. 内存利用率高：链表实现的队列只会使用实际需要的内存，不会浪费额外的内存。相比之下，数组实现的队列必须预先分配一定大小的连续内存空间，如果队列的实际大小远小于数组的容量，就会造成内存浪费。
  3. 插入和删除操作高效：链表实现的队列在插入和删除操作上具有较高的效率。在链表中插入或删除一个节点的时间复杂度是 O(1)，而在数组中插入或删除一个元素则需要移动其他元素，其时间复杂度是 O(n)。当队列的规模很大时，链表实现的队列会更加高效。
  4. 队列长度无限制：链表实现的队列的长度理论上没有限制，只受限于计算机内存的大小。相比之下，使用数组实现的队列必须预先定义一个固定的容量，当元素数量超过容量时，需要进行扩容操作。
  5. 更容易实现其他特殊操作：链表实现的队列更容易实现一些特殊操作，例如反转队列、合并队列等。这是因为链表的灵活性和可动态调整的特性，使得实现这些操作更为简单。

 在这里我们使用链表来实现队列，我们先来定义一下队列的结构：

typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* tail;
	int size;
}Queue;

在上面的定义中，我们首先定义了一个结构体QueueNode，用该结构体表示队列中的节点，它包含两个成员变量：

  1. data：存放在节点中的数据。
  2. next：指向下一个节点的指针。

 然后又定义了一个结构体Queue来表示队列本身，它包含三个成员变量：

  1. phead：指向队列头部的指针。该指针指向队列中的第一个节点。
  2. tail：指向队列尾部的指针。该指针指向队列中的最后一个节点。
  3. size：表示队列的大小，即队列中节点的数量。

2.2.1队列的初始化和销毁

 我们初始化时只需要将队列的成员变量初始化为合适的初值就可以了，我们来实现一下队列的初始化：

void QueueInit(Queue* q)
{
	assert(q);
	q->phead = q->tail = NULL;
	q->size = 0;
}

 队列销毁的操作具体步骤为：

  1. 遍历队列元素：从队列的头指针开始，依次遍历队列中的每个节点。

  2. 释放节点内存：通过free函数释放每个节点的内存空间。确保释放节点时，先保存下一个节点的指针，然后释放当前节点的内存。

  3. 然后将队列的头指针和尾指针置空，给size赋值为0，表示是一个空的队列。

我们来实现一下队列的销毁：

void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->phead = q->tail = NULL;
	q->size = 0;
}

2.2.2队列的入队和出队操作

使用上面的定义方法使我们在队列的操作更加方便快捷：

  1. 入队操作可以将新元素添加到队列的尾部，只需将新节点插入到tail指针所指的节点后面，并更新tail指针为新节点。
  2. 出队操作可以从队列的头部删除一个元素，只需将phead指针指向下一个节点，并释放原来头部节点的内存空间。
  3. 获取队列大小只需直接访问size变量的值。

 我们先来实现一下队列的入队操作：

void QueuePush(Queue* q, QDataType x)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return -1;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (q->tail == NULL)
	{
		q->phead = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}

我们来实现一下队列的出队操作：

void QueuePop(Queue* q)
{
	assert(q);
	assert(q->phead);
	QNode* cur = q->phead;
	q->phead = q->phead->next;
	free(cur);
	cur = NULL;
	if (q->phead == NULL)
		q->tail = NULL;
	q->size--;
}

既然在上面提到了获取队列的大小，那我们就来实现一下：

int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}

2.2.3获取队列的队头和队尾元素

获取队列的队头元素的具体操作步骤为：

  1. 检查队列是否为空：判断队列的头指针是否为空，如果为空则表示队列为空，无法获取队头元素。
  2. 返回队头元素的值：如果队列不为空，直接返回队列的头指针所指向的节点的值。

我们来实现一下获取队头元素的操作：

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->phead);
	return q->phead->data;
}

获取队尾元素操作的具体步骤为：

  1. 检查队列是否为空，如果队列为空，则无法获取队尾元素。
  2. 返回队尾元素的值：如果队列不为空，直接返回队列尾指针所指向节点的值。

我们来实现一下获取队尾元素的操作：

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->tail);
	return q->tail->data;
}

2.3多文件实现队列

Queue.h文件：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;
typedef struct Queue
{
	QNode* phead;
	QNode* tail;
	int size;
}Queue;
void QueueInit(Queue* q);//队列的初始化
void QueuePush(Queue* q, QDataType x);//队尾入队列
void QueuePop(Queue* q);//对头出队列
QDataType QueueFront(Queue* q);//获取队头元素
QDataType QueueBack(Queue* q);//获取队尾元素
int QueueSize(Queue* q);//获取队列中的元素个数
int QueueEmpty(Queue* q);//检测队列是否为空
void QueueDestroy(Queue* q);//队列的销毁

Queue.c文件：

#include"Queue.h"
void QueueInit(Queue* q)
{
	assert(q);
	q->phead = q->tail = NULL;
	q->size = 0;
}
void QueuePush(Queue* q, QDataType x)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return -1;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (q->tail == NULL)
	{
		q->phead = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}
void QueuePop(Queue* q)
{
	assert(q);
	assert(q->phead);
	QNode* cur = q->phead;
	q->phead = q->phead->next;
	free(cur);
	cur = NULL;
	if (q->phead == NULL)
		q->tail = NULL;
	q->size--;
}
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(q->phead);
	return q->phead->data;
}
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(q->tail);
	return q->tail->data;
}
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->phead == NULL;
}
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->phead = q->tail = NULL;
	q->size = 0;
}

test.c文件（用来测试函数功能）：

#include"Queue.h"
void Test1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("\n");
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");
	QueueDestroy(&q);

}
int main()
{
	Test1();
	return 0;
}

野生的编程萌新
关注
  • 93
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 54
    评论
专栏目录
数据结构期末通关——栈与队列PPT
08-16
bilibili账号642257246，视频教程配套课件
数据结构第三章笔记——栈和队列
10-21
数据结构第三章笔记——栈和队列
数据结构——算法竞赛中熠熠生辉的两朵金花—“栈“和“队列“
weixin_52621323的博客
12-15 1469
一篇长文，亿点图片，详细演示，带你逐渐把栈和队列在程序设计大赛中的玩法弄明白呀~
数据结构——栈
weixin_69224277的博客
10-12 385
数据结构——栈
408复习笔记——数据结构（三）：栈和队列
qq_44161734的博客
06-22 497
408考研笔记系列（三）（PS：本人使用的是王道四本书和王道视频） 数据结构：（三）栈和队列前言一、简介二、主要内容2.1 栈2.1.1 顺序栈2.2.2 链栈2.2 队列三、常见题及易错题归纳 前言 上一章节里，我们知道了一种线性逻辑结构的线性表，并且知道了线性表的两种存储结构，分别是顺序存储结构的顺序表和链式存储结构的链表，其中链表又包括单链表、双链表、循环链表和静态链表，他们每个都有自己的特点；这一章节我们将开始学习两个新的线性逻辑结构的数据结构：栈和队列。 一、简介 栈和队列其实也是一种线性表
Java数据结构与算法解析——优先级队列
weixin_BJ050106的博客
08-13 171
如果使用有序数组，那么每一次插入的时候，通过插入排序将元素放到正确的位置，时间复杂度为O(n)，但是如果要获取最大值的话，由于元阿苏已经有序，直接返回数组末尾的 元素即可，所以时间复杂度为O(1).要实现删除最大元素，可以添加一段类似于选择排序的内循环代码，将最大元素的和边界元素交换后删除它，和对栈的pop()方法的实现一样。基于用数组表示的完全三叉树构造堆并修改相应的代码并不难，对应数组中1至N的N个元素，位置k的结点大于大于等于3k-1,3k，3k+1的结点，小于位于[(k+1)/3]下取整的结点。..
数据结构——栈和队列，循环队列，两队列实现栈，两栈实现队列，括号匹配问题
2301_81739147的博客
06-02 1011
数据结构，栈，队列详细讲解，栈和队列应用
【JAVA数据结构】优先级队列——堆
爱打酱油的新一的博客
10-11 706
优先级对列——堆
Java数据结构与算法解析(十三)——优先级队列
热门推荐
一个码农的博客
10-21 1万+
在很多应用中，我们通常需要按照优先级情况对待处理对象进行处理，比如首先处理优先级最高的对象，然后处理次高的对象。最简单的一个例子就是，在手机上玩游戏的时候，如果有来电，那么系统应该优先处理打进来的电话。在这种情况下，我们的数据结构应该提供两个最基本的操作，一个是返回最高优先级对象，一个是添加新的对象。这种数据结构就是优先级队列(Priority Queue) 。定义优先级队列和通常的栈和队列一样，只
数据结构与算法——第五节 树和堆
jxwd的博客
01-21 1145
树的定义及相关定义 树的定义 树的节点的相关概念 树的表示法（存储法） 1、双亲表示法： 2、孩子表示法 3、孩子兄弟表示法： 二叉树的概念及相关概念 二叉树的概念 二叉树的特点： 特殊的二叉树 1、斜树： 2、满二叉树 3、完全二叉树 3、二叉树的性质 4、二叉树的存储 顺序存储 链式存储 5、二叉树的遍历方法 1、前序遍历 2、中序遍历 3、后续遍历 4、层序遍历 堆（优先队列） 堆的概念： 堆的性质（两条）： 堆的
《Java数据结构》——优先级队列（小根堆的模拟实现）
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
05-27 3257
什么是堆呢？他和二叉树有什么恩怨情仇🤔 怎样用小根堆来模拟实现优先级队列呢？一起来看看吧！
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构：导论、栈与队列
01-20
导论 算法的特征：有穷性（finiteness），确定性（definiteness），输入，输出，有效性/可行性（effectiveness） O表示法表示的是当N->某一值或者无穷大时，斜率的变化。重要的是曲线的形状，而不是...栈（Stack） LIF
Python 实现数据结构中的的栈队列
09-19
主要介绍了Python 实现数据结构中的的栈，队列,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
C++:十大排序
最新发布
2301_80418172的博客
06-12 991
十大排序CPP
ACM算法学习路线、清单
qq_45477639的博客
06-10 1921
算法与数据结构学习路线
C语言刷题（函数）
2303_82176667的博客
06-09 800
一个数如果恰好等于它的所有因子(不包括它本身)之和，这个数就称为“完数”。
C数据结构：排序
2301_80655639的博客
06-12 1035
若按照错误方法来：例如：begin = 0，end = 3，那么mid = 1，begin1 = 0，end1 = 2，递归左右区间为[0，2]也就是begin = 0，end = 2，那么mid = 1，begin1 = 0，end1 = 2，这样又递归就会出现栈溢出的情况，所以必须要按照 上面代码的方式走。然后这个for循环做的就是遍历原数组，将原数组的值减去最小值，这个值映射到count数组中，让这个下标的值++，这样就会统计这个值出现的次数，而与原数组建立的关系就是减去一个min的关系。
数据结构栈与队列实验
05-22
数据结构中，栈和队列都是非常重要的线性数据结构，它们都可以通过数组和链表来实现。在实验中，我们可以通过编写程序来实现栈和队列的基本操作，从而更好地理解它们的实现原理和使用方法。 在栈实验中，我们通常会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

野生的编程萌新

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值