【数据结构】栈和队列

最新推荐文章于 2024-09-20 17:00:23 发布
最新推荐文章于 2024-09-20 17:00:23 发布
阅读量289 收藏 5
点赞数 7
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67582098/article/details/128346280
版权

文章目录

栈

一、栈的概念及其结构

一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端

**称为栈顶，另一端称为栈底。**栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

出栈：栈的删除操作叫做出栈。出数据也在栈顶。

在这里插入图片描述

在这里插入图片描述

【注意】栈和栈区的区别：栈区是内存划分的一块区域，属于操作系统的学科，而栈是在内存中管理数据的一种结构，采用在堆上开辟/申请空间的方式，属于数据结构学科。

栈的相关概念选择题

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

栈的顺序是（ ）。

A 12345ABCDE

B EDCBA54321

C ABCDE12345

D 54321EDCBA

【解析】 B 这道题我们只要根据栈的特点(后进先出/先进后出)，就可知答案选B

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

A 1,4,3,2

B 2,3,4,1

C 3,1,4,2

D 3,4,2,1

【解析】 C 题目中告诉我们，进栈过程中可以出栈，所以对于这种题我们可以对照选项来分析有没有这种出栈序列的可能，依次对他们进行分析：

A

在这里插入图片描述

B

在这里插入图片描述

C

对于C来说，我们要取出3，就不许入栈1和2，然后选项中3出栈后，紧接着就要1出栈，要1出栈就必须2要先出栈，显然是不可能的。

D

在这里插入图片描述

二、栈的实现

栈是一种特殊的线性表，所以既可以用顺序表实现，也可以用链表实现，这里我们用顺序表实现，理由如下：

1.栈的插入和删除操作都在栈顶，也就是在数据的尾部进行操作，而顺序表在尾部插入和删除的时间效率为O(1),链表(非双向循环链表)则每次都需要遍历一遍，找到尾部进行插入和删除的操作，而双向循环链表结构复杂，空间内存占用大，综合而言顺序表比较合适。

2.从整体而言，顺序表扩容和链表频繁malloc空间的效率是差不多的。只是顺序表可能会存在一定的空间浪费，但顺序表的缓存利用率高(局部性原理)。

3.顺序表支持随机访问，链表却做不到。

1.栈结构的定义

栈的定义和顺序表一样，只是我们习惯用top，而不是size。top用来获取栈顶的元素。

//结构和符号的定义
typedef int STDataType;  //重命名数据类型，数据类型更改时只需要改这一个地方即可

typedef struct StackNode
{
	STDataType* a;    //指向动态开辟的数组
	int top;          //记录栈顶
	int capacity;     //记录容量，容量满时扩容
}ST;

2.初始化栈

初始化栈的时候可以先开辟一定大小的空间，也可以先不开辟，在入栈的时候开辟，我这里先不开辟空间。

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

3.入栈

由于我们在初始化的时候没有开辟空间，在进行入栈操作的时候需要检查容量进行扩容(第一次入栈的时候开辟空间)，入栈的时候需要考虑是数据是放在top的位置还是top++的位置，这个需要看初始化的时候top的初始值，top=-1,放在top++的位置，top是0，放在top的位置。

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//检查是否需要扩容
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	//入栈
	ps->a[ps->top] = x;
	ps->top++;
}

4.出栈

出栈的时候需要检查栈的容量是否为空，然后top–即可。

//出栈
void StackPop(ST* ps)
{
	assert(ps);

	//栈为空时不能出栈
	assert(!StackEmpty(ps));

	ps->top--;
}

5.返回栈顶元素

返回栈顶元素的时候同样需要判断栈是否为空，也需要注意top的初始值，top初始值是-1时返回ps->top位置的值，top的初始值是0,则返回ps->top-1位置的值。

//返回栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];//数组下标从0开始返回ps->top-1;从-1开始返回ps->top
}

6.判断栈是否为空

//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

7.返回栈元素的个数

//返回栈元素的个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

8.销毁栈

//销毁栈
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

【注意】我们不需要定义一个栈的打印函数，因为栈不能遍历，如果我们需要获取栈顶的前一个函数，我们首先需要把栈顶的元素出栈，然后获取栈顶的元素。

三、完整代码

1.Stack.h

#pragma once  //防止头文件被重复包含

//头文件的声明
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

//结构和符号的定义
typedef int STDataType;  //重命名数据类型，数据类型更改时只需要改这一个地方即可

typedef struct StackNode
{
	STDataType* a;    //指向动态开辟的数组
	int top;          //记录栈顶
	int capacity;     //记录容量，容量满时扩容
}ST;


//函数的声明
//初始化栈
void StackInit(ST* ps);
//销毁栈
void StackDestroy(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);

//返回栈顶元素
STDataType StackTop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//返回栈元素的个数
int StackSize(ST* ps);

2.Stack.c

#include "Stack.h"

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//销毁栈
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//检查是否需要扩容
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	//入栈
	ps->a[ps->top] = x;
	ps->top++;
}

//出栈
void StackPop(ST* ps)
{
	assert(ps);

	//栈为空时不能出栈
	assert(!StackEmpty(ps));

	ps->top--;
}

//返回栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];//数组下标从0开始返回ps->top-1;从-1开始返回ps->top
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}
//返回栈元素的个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

3.test.c

#include "Stack.h"

// 解耦 -- 低耦合 高内聚
// 数据结构建议不要直接访问结构数据，一定要通过函数接口访问
void TestStack()
{
	ST st;
	//初始化栈
	StackInit(&st);

	//入栈
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);

	//打印栈顶元素
	printf("%d ", StackTop(&st));
	//出栈
	StackPop(&st);

	printf("%d ", StackTop(&st));
	StackPop(&st);

	StackPush(&st, 4);
	StackPush(&st, 5);

	//栈不能遍历，只能获取栈顶元素之后，出栈一个元素
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	printf("\n");

	//销毁栈
	StackDestroy(&st);

}

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

队列

一、队列的概念及其结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出

FIFO(First In First Out) 入队列。

入队列：进行插入操作的一端称为队尾 出队列。

出队列：进行删除操作的一端称为队头。

在这里插入图片描述

队列概念相关选择题

以下( )不是队列的基本运算？

A 从队尾插入一个新元素

B 从队列中删除第i个元素

C 判断一个队列是否为空

D 读取队头元素的值

【解析】B 队列只能删除对头的元素，即第一个元素。

二、队列的实现

1.队列结构的定义

队列和栈一样，既可以用顺序表实现，也可以用链表来实现，这里我们用单链表来实现，理由如下：

1.队列只能删除对头的元素，链表的头插头删的效率为O(1)，这里我们用单链表就足够了，不需要用双向带头循环链表，不然这样结构太复杂，有点大材小用了。

2.使用链表可以按需申请空间，避免了空间的浪费。

但是我们使用单链表实现队列的时候，单链表尾插和计算队列长度的时候的时间效率为O(N)，这些不太好，用复杂链表又不太合适，所以我们在这里增加三个变量，一个节点指针指向对头，一个指针指向队尾，还有一个用来记录队列元素个数的size。

结构的定义

//结构和符号的定义
typedef int QDataType;  //数据类型重定义

//定义队列的一个节点
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;   //记录队列的头
	QNode* tail;   //记录队列的尾
	int size;      //记录队列的长度
}Queue;

2.初始化队列

初始化的时候，需要头结点的指针和尾节点的指针置为空，size置为0.

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

3.从队尾入队列

因为队列和栈一样，只能从一端插入数据，所以我们不用单独写一个创建节点的函数。

由于这里我们使用了结构体来记录队列的头和队列的尾，那么我们这里改变队列的头和尾时只需要改变结构体即可，所以只需要传一级指针。这里我们我们要考虑第一次入队和非第一次入队两种情况。

//队尾入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	//开辟新节点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		//节点的数据复制为x，指针置为空
		newnode->data = x;
		newnode->next = NULL;
	}

	//空队列在队列头部
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		//尾指针后移
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

4.从队头出队列

这里我们除了正常的队列进行判空之外，还需要注意的是，当队列只有一个元素的时候，我们删除了之后会让头指针置空，但尾指针仍然会指向头删之前的那个节点，会形成野指针，所以只有一个元素(pq->head==pq->tail)的时候，我们删除了之后要把两个指针都置为空。

//对头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));  //队列为空时不能出队列

	//只有一个元素的时候，出队列之后，头尾指针都置为空
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}

	pq->size--;
}

5.获取队头元素

获取元素时都要判断队列是否为空。

//获取对头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

6.获取队尾元素

//获取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

7.获取队列长度

我们没有加size这个变量的时候，只能遍历计数计算队列的长度。

//返回队列元素个数
int QueueSize(Queue* pq)
{
	assert(pq);

	/*int count = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		count++;
	}
	return count;*/


	return pq->size;
}

8.判断队列是否为空

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

9.销毁队列

销毁队列的时候，首先要把节点遍历是否，然后再释放头结点和尾结点。

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);

	//遍历删除
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}

	pq->head = pq->tail = NULL;
}

三、完整代码

1.Queue.h

#pragma once   //防止头文件被重复包含

//包含头文件
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

//结构和符号的定义
typedef int QDataType;  //数据类型重定义

//定义队列的一个节点
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;   //记录队列的头
	QNode* tail;   //记录队列的尾
	int size;      //记录队列的长度
}Queue;


//函数的声明
//初始化队列
void QueueInit(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);
//队尾入队列
void QueuePush(Queue* pq, QDataType x);
//对头出队列
void QueuePop(Queue* pq);
//获取对头元素
QDataType QueueFront(Queue* pq);
//获取队尾元素
QDataType QueueBack(Queue* pq);
//判断队列是否为空
bool QueueEmpty(Queue* pq);
//返回队列元素个数
int QueueSize(Queue* pq);

2.Queue.c

#include "Queue.h"

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);

	//遍历删除
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;
		free(del);
	}

	pq->head = pq->tail = NULL;
}

//队尾入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	//开辟新节点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	else
	{
		//节点的数据复制为x，指针置为空
		newnode->data = x;
		newnode->next = NULL;
	}

	//空队列在队列头部
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		//尾指针后移
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

//对头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));  //队列为空时不能出队列

	//只有一个元素的时候，出队列之后，头尾指针都置为空
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* del = pq->head;
		pq->head = pq->head->next;

		free(del);
		del = NULL;
	}

	pq->size--;
}

//获取对头元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

//获取队尾元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL && pq->tail == NULL;
}

//返回队列元素个数
int QueueSize(Queue* pq)
{
	assert(pq);

	/*int count = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		count++;
	}
	return count;*/


	return pq->size;
}

3.test.c

#include "Queue.h"

void TestQueue()
{
	Queue q;

	//初始化队列
	QueueInit(&q);

	//队尾入队列
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	//获取对头元素
	printf("%d ", QueueFront(&q));
	//出队列
	QueuePop(&q);

	printf("%d ", QueueFront(&q));
	QueuePop(&q);

	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePush(&q, 7);

	//获取队列元素的个数
	int count = QueueSize(&q);
	printf("%d\n", count);

	//遍历队列
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");

	//销毁队列
	QueueEmpty(&q);
}

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

ULL && pq->tail == NULL;
}

//返回队列元素个数
int QueueSize(Queue* pq)
{
assert(pq);

/*int count = 0;
QNode* cur = pq->head;
while (cur)
{
	cur = cur->next;
	count++;
}
return count;*/


return pq->size;

}




### 3.test.c

```c
#include "Queue.h"

void TestQueue()
{
	Queue q;

	//初始化队列
	QueueInit(&q);

	//队尾入队列
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	//获取对头元素
	printf("%d ", QueueFront(&q));
	//出队列
	QueuePop(&q);

	printf("%d ", QueueFront(&q));
	QueuePop(&q);

	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePush(&q, 7);

	//获取队列元素的个数
	int count = QueueSize(&q);
	printf("%d\n", count);

	//遍历队列
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n");

	//销毁队列
	QueueEmpty(&q);
}

int main()
{
	TestQueue();
	return 0;
}
椿融雪
关注
专栏目录
百度2020校招C++/PHP研发工程师笔试卷（第三批）
lvlongjuan的博客
03-11 625
下列关于关键路径的叙述中错误的是（D）A关键路径是指在带权有向图中从源点到汇点的所有路径中具有最大路径长度的路径；B关键路径上的所有活动都是关键活动，可通过加快关键活动来缩短整个工程的工期；CAOE网中，关键路径上活动的时间延长多少，整个工程的时间也就随之延长多少；DAOE网中的关键路径并不唯一，可通过加快某一条关键路径中关键活动速度来缩短整个工程工期；单选题对于数列4、5、6、7、9、12、18、23，如果采用折半查找元素9，请问需要查找几次？（B）A2。
数据结构--栈
qq_turn
06-13 2099
第十一章 26题 给一个整数数组，找到两个数使得他们的和等于一个给定的数 target。 你需要实现的函数 twoSum 需要返回这两个数的下标, 并且第一个下标小于第二个下标。注意这里下标的范围是 1 到 n，不是以 0 开头。 样例： 给出 numbers = [2, 7, 11, 15], target = 9, 返回 [1, 2]. // An highlighted block var...
栈和队列知识点总结
Akalaka的博客
03-08 8008
栈和队列知识点总结一、栈-入栈与出栈二、循环队列-入队与出队三、栈的存储空间为S(1:m)，初始状态为top=m+1四、带链的栈和带链的队列五、线性链表-存储空间不连续六、线性结构与非线性结构-判断准则 一、栈-入栈与出栈 栈的存储空间为S(1:50)，初始状态为top=51，即栈的初始状态为空。当第一个元素进栈后，top=50，第二个元素进栈后，top=49,第三个元素进栈后，top=48,以此类推，若第三个元素出栈后，top=48，第二个元素出栈后，top=50。即每进栈一个元素，top－1;每出栈一个
计算机二级知识点——栈
VICI的博客
11-30 4901
栈 该考点在笔试考试中，是一个必考的内容，在笔试考试中出现的几率为100%。 要搞懂这个知识点，我们首先要明白什么是线性表： 线性表： 线性表，又称线性结构，具有以下特征： 1．集合中必存在唯一的一个"第一个元素"；（即数组元素a[0]） 2．集合中必存在唯一的一个"最后的元素"；(即数组元素a[9]) 3．除最后元素之外，其它数据元素均有唯一的"后继"； 4．除第一元素之外，其它数据元素均有唯一...
【数据结构与算法】- 栈+队列
m0_56051805的博客
06-21 2720
含有最经典的括号匹配和车厢调度等问题，更深入地了解栈和队列。
数据结构 栈和队列
qq_52847866的博客
06-15 4351
5. 访问效率：顺序存储结构的元素在内存中是连续存储的，对于 CPU 缓存等硬件有较好的利用效率，因此在访问速度上可能更快。特殊矩阵的压缩存储可以大幅减少存储空间的占用，提高存储效率，并在某些情况下加速矩阵的运算和操作。需要注意的是，多维数组的存储方式可能会影响程序的性能，特别是对于大型多维数组和对数组访问频繁的场景。总之，栈和队列都是重要的数据结构，在不同的应用场景中发挥着关键的作用。栈和队列都是常见的数据结构，可以使用不同的存储结构进行实现，包括顺序存储结构和链式存储结构。函数判断栈是否为空。
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构栈和队列练习题答案.doc
04-02
数据结构
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
用c语言顺序表实现栈
weixin_56667446的博客
10-29 728
用c语言顺序表实现栈 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 Stack.h #pragma once #include <stdio.h> #include <stdlib.h> #include <asse
【数据结构知识点总结】三、栈和队列
叶柖的博客
10-25 2269
栈（Stack）是一种线性表，只允许在一端进行插入或删除操作。 顺序栈 采用顺序存储的栈称为顺序栈。
判断栈是否为空_栈c++
weixin_39913141的博客
11-28 9367
顺序栈与链栈的实现总算把你给盼来了现在才关注我 确实是晚了点但没关系 来了就好工具：vs code 、ppt操作系统：LinuxSUMMER目录1.栈的定义与概念2.栈的实现方式3.栈的操作3.1、初始化与清空3.2、进栈与退栈操作3.3、判断栈是否为空、获取栈顶元素与求栈长度之间的操作3.4、栈的遍历4.栈的一些题目1.栈的定义与概念栈：...
王道408考研数据结构-线性表-第二章
qq_55882840的博客
09-17 1258
2.1 线性表的定义2.1.1 线性表的定义线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，其中n为表长，当n=0 时线性表是一个空表。若用L命名线性表，则其一般表示为式中，a1是唯一的“第一个”数据元素，又称表头元素；an是唯一的“最后一个”数据元素，又 称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继(“直接前驱”和“前驱”、“直接后继”和“后继”通常被视为同义词)。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 611
数据结构之字典和哈希表
【用Java学习数据结构系列】对象的比较（Priority Queue实现的前提）
最新发布
2302_81249757的博客
09-20 412
上一篇文章已经给大家大致了解了一下Priority Queue以及它的底层实现---堆，但是其实大家可以发现我们上一篇文章的对象是 int 类型，所以我们进行向上调整和向下调整时我可以使用 “<” “ >” “ ==” 进行比较他们的大小进行比较调整，但是如果我们的Priority Queue 里储存的是一个对象呢？那么这时就涉及到对象的比较了。那么对象如何进行比较就往下看看这篇文章吧。
数据结构(7.3_3)——平衡二叉树的删除
m0_65240792的博客
09-17 477
删除结点后，要保持二叉排序树的特性不变(左<中<右)若删除结点导致不平衡，则需要调整平衡1、寻找最小不平衡子树2、没找到最小不平衡子树，结束查询1、删除结点552、寻找最小不平衡子树3、找最小不平衡树下，“个头”最高的儿子、孙子 4、根据孙子的位置，调整平衡(LL/RR/LR/RL) 5、检查不平衡性是否向上传导 1、删除结点2、寻找最小不平衡子树3、找最小不平衡树下，“个头”最高的儿子、孙子 4、根据孙子的位置，调整平衡(LL/RR/LR/RL) 5、检查不平衡性是否向上传导 1、删除结点2、寻找最
数据结构day2
m0_74933801的博客
09-17 605
D选项正确地使用了点操作符（）来访问结构体stud中的 name 成员。由于 name 是一个字符数组，它可以被printf函数的 %s格式说明符直接用作字符串输出，这正是题目所要求的。①输入学生信息②输出学生信息③计算学生的成绩总分、平均分④按照学生的分数进行排序⑤输出排序后的数组#define Stu_num 5 // 定义学生数量为5//定义学生结构体int id;//学号//姓名//分数}Stu;//输入函数//输出函数//排序函数// 计算总分// 计算平均分。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

椿融雪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值