【线性结构】栈和队列

已于 2024-07-24 15:19:36 修改
阅读量127 收藏
点赞数 1
分类专栏： 数据结构和算法 # 数据结构 文章标签： 数据结构 算法 c++
于 2023-01-30 17:38:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zty857016148/article/details/128804481
版权

一、栈

在这里插入图片描述

  • 我们使用数组实现栈结构。

快速复习

  • 结构定义：
    顺序表实现栈，
    定义顺序表结构体：指针，大小，容量。

  • 相关函数：

    • 构造析构：

      1. 初始化：分配初始空间，设置大小容量。

      2. 销毁：释放动态内存，大小容量清零。

    • 增删查改：

      1. 遍历：普通循环遍历

      2. 压栈：判满，扩容，赋值，top++；

      3. 弹栈：判空，取top-1数据，top–，返回数据；

      4. 栈顶：判空，返回top-1数据；

    • 判空判满：

      1. 大小：return top；

      2. 判空：return top == 0；

      3. 判满：return top == capacity

1.结构的声明及定义

typedef int STDataType;

typedef struct stack{
	STDataType *arr;
	int top;
	int capacity;
}ST;

ST st;
StackInit(&st);

2.初始化栈

void StackInit(ST *pst){
	assert(pst != NULL);
	pst->capacity = 0;
	pst->top = 0;
	pst->arr = NULL;
}
  • top可以初识化为0，压栈时top位置先赋值再++，此时top表示栈顶元素的下一个位置。
  • top还可以初始化为-1，压栈时top先++再赋值，此时top表示栈顶元素的位置。

2.压栈

void StackPush(ST *pst, STDataType val){
	assert(pst != NULL);
	//检查是否需要扩容
	if (Stacksize(pst) == pst->capacity){
		int newcapacity = pst->capacity == 0 ? 5 : pst->capacity * 2;
		STDataType *tmp = (STDataType*)realloc(pst->arr, newcapacity * sizeof(STDataType));
		if (tmp == NULL){
			perror("StackPust");
			exit(1);
		}
		pst->arr = tmp;
		pst->capacity = newcapacity;
	}
	//压栈
	pst->arr[pst->top] = val;
	pst->top++;
}

3.弹栈

void StackPop(ST *pst){
	assert(pst != NULL);
	assert(!StackEmpty(pst));
	pst->top--;
}

STDataType StackTop(ST *pst){
	assert(pst != NULL);
	assert(!StackEmpty(pst));
	return pst->arr[pst->top - 1];
}

void Test2(){
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	StackPush(&st, 5);

	while (!StackEmpty(&st)){
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
}
  • 弹栈操作需提前检测栈是否为空
  • 注意，这里返回的是top-1位置的值

4.销毁栈

void StackDestroy(ST *pst){
	assert(pst != NULL);
	free(pst->arr);
	pst->arr = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

5.获取栈中有效元素个数

int Stacksize(ST *pst){
	assert(pst != NULL);
	return pst->top;
}

6.检测栈是否为空

bool StackEmpty(ST *pst){
	assert(pst != NULL);
	return pst->top == 0;
}

二、队列

在这里插入图片描述

  • 由于队列队头出队，队尾入队的性质，使用链表实现队列更为方便。

快速复习

  • 结构定义：
    单链表（可带头）实现队列，
    定义节点结构体：数据，指针；
    定义队列结构体：头、尾指针，大小。

  • 相关函数：

    • 构造析构

      1. 初始化：将头尾指针置空，设置大小；

      2. 销毁：释放各节点，直到NULL；（删空改尾指针）

    • 增删查改

      1. 遍历：遍历各节点数据，直到NULL；

      2. 入队：创建节点，链接到队尾，size++；（首添改头指针）

      3. 出队：判空，取数据，头删，size--，返回数据；（删空改尾指针）

      4. 取队头队尾：判空，返回队头/队尾数据；

    • 判空判满

      1. 大小：return size；

      2. 判空：return head == NULL；

1.结构的声明及定义

typedef int QDataType;
//声明链表的节点
typedef struct QueueNode{
	QDataType data;
	struct QueueNode *next;
}QueueNode;
//声明队列
typedef struct Queue{
	struct QueueNode *head;//头指针
	struct QueueNode *tail;//尾指针，方便尾插入队
}Queue;

Queue que;
QueueInit(&que);

2.初始化队列

void QueueInit(Queue *pq){
	assert(pq!=NULL);
	pq->head = NULL;
	pq->tail = NULL;
}

3.队尾入队

void QueuePush(Queue *pq, QDataType val){
	assert(pq != NULL);

	QueueNode *newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->data = val;
	newnode->next = NULL;
	//不带哨兵位的链表需要考虑改变头指针的指向
	if (pq->head == NULL){
		pq->head = pq->tail = newnode;
	}
	else{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

4.队头出队

void QueuePop(Queue *pq){
	assert(pq != NULL);
	assert(!QueueEmpty(pq));

	QueueNode *del = pq->head;
	pq->head = del->next;
	free(del);

	if (pq->head == NULL){
		pq->tail = NULL;
	}

}

队头出队需要注意两点：

  1. 需要提前检测队列是否为空
  2. 最后一个元素出队后，切记将tail置空。

5.获取队头、队尾元素

//获取队头元素
QDataType QueueFront(Queue *pq){
	assert(pq != NULL);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}
//获取队尾元素
QDataType QueueBack(Queue *pq){
	assert(pq != NULL);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}
  • 注意提前检测队列是否为空

6.获取队列中有效元素的个数

int QueueSize(Queue *pq){
	assert(pq != NULL);
	QueueNode *cur = pq->head;
	int n = 0;

	while (cur != NULL){
		cur = cur->next;
		n++;
	}
	return n;
}

7.检测队列是否为空

bool QueueEmpty(Queue *pq){
	assert(pq != NULL);
	return pq->head == NULL;
}

8.销毁队列

void QueueDestroy(Queue *pq){
	assert(pq != NULL);
	QueueNode *del;
	while (pq->head != NULL){
		del = pq->head;
		pq->head = del->next;
		free(del);
	}
	pq->tail = NULL;
}
  • 循环结束后，注意将tail指针置空。

三、循环队列

循环队列：
1. 符合先进先出
2. 循环队列的容量是固定的
3. 无论是数组实现还是链表实现，都要多开一个空间。存k个数据，开k+1个空间。否则无法实现判空和判满。
4. front == tail 为空
5. tail+1== front 为满（数组实现考虑循环）

循环队列可以采用循环链式结构或数组结构，一下的代码是链式结构的实现。想要看数组结构请点击这里 >>>>【【Leetcode算法|第3期】栈和队列（栈和队列的简单应用、循环队列）】

1.结构的声明及定义

typedef int CQueDataType;

typedef struct CirQueueNode{
	CQueDataType data;
	struct CirQueueNode *next;
}CQNode;

typedef struct CirQueue{
	CQNode *head;
	CQNode *tail;
	int sz;
}CQue;

2.初始化循环队列

void CQueInit(CQue *pq, int k){
	//开辟K+1个节点的内存空间
	pq->head = pq->tail = (CQNode*)malloc(sizeof(CQNode));
	for (int i = 0; i < k; i++)
	{
		CQNode *newnode = (CQNode*)malloc(sizeof(CQNode));
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
	pq->tail->next = pq->head;//首尾相连，构造环状结构
	pq->tail = pq->head;//将队列置空
	pq->sz = 0;
}
  • 循环队列的容量是固定的
  • 无论是数组实现还是链表实现，都要多开一个空间。存k个数据，开k+1个空间。否则无法实现判空和判满。

3.队尾入队

void CQuePush(CQue *pq, CQueDataType val){
	assert(pq != NULL);
	assert(!CQueFull(pq));

	pq->tail = pq->tail->next;//先移动指针
	pq->tail->data = val;//后赋值
	pq->sz++;
}
  • 入队前要先判满
  • 这里先移动尾指针再赋值是为了让尾指针指向队尾元素，方便读取队尾元素的值。
  • 当然也可以先赋值再移动指针，但此时尾指针指向的是队尾元素的后一个节点。而由于单链表指针不能向前移动，所以在读取队尾元素时必须需要从头遍历到尾才行。

4.队头出队

CQueDataType CQuePop(CQue *pq){
	assert(pq != NULL);
	assert(!CQueEmpty(pq));

	CQueDataType data = pq->head->next->data;//取head->next
	pq->head = pq->head->next;
	pq->sz--;
	return data;
}
  • 出对前要先判空
  • 由于入队时是先移动尾指针再赋值，所以读取队头元素的值时应该读取的是队头指针指向元素的下一个元素的值。

5.获取对头/队尾元素

CQueDataType CQueHead(CQue *pq){
	assert(pq != NULL);
	assert(!CQueEmpty(pq));

	return pq->head->next->data;
}

CQueDataType CQueTail(CQue *pq){
	assert(pq != NULL);
	assert(!CQueEmpty(pq));

	return pq->tail->data;
}

6.检测队列是否为空/满

bool CQueEmpty(CQue *pq){
	assert(pq != NULL);
	return pq->head == pq->tail;
}

bool CQueFull(CQue *pq){
	assert(pq != NULL);
	return pq->tail->next == pq->head;
}

int CQueSize(CQue *pq){
	assert(pq != NULL);
	return pq->sz;

	/*int ct = 0;
	CQNode *cur = pq->head;
	while (cur != pq->tail)
	{
		ct++;
		cur = cur->next;
	}
	return ct;*/
}

7.销毁队列

void CQueDestroy(CQue *pq){
	assert(pq != NULL);

	CQNode *cur = pq->head->next;
	CQNode *del;
	while (cur != pq->head){
		del = cur;
		cur = cur->next;
		free(del);
	}
	free(pq->head);
	pq->head = pq->tail = NULL;
	pq->sz = 0;
}

注意：不能从队头指针销毁到队尾指针，否则无法将循环队列完全销毁会造成内存泄漏。

芥末虾
关注
专栏目录
数据结构-栈和队列
qq_39610697的博客
03-15 954
栈和队列 栈和队列都是线性数据结构，逻辑结构和线性表相同。 栈和队列的插入和删除操作受到某些限制，与线性表不同，也被称为操作受限的线性表。 栈 栈是一种插入和删除都只能在表的同一端操作的线性表。 允许进行插入和删除操作的一端叫栈顶(Top)，也叫表尾；另一端叫做栈底(Bottom)，也叫表头。 栈中没有元素时称为空栈。 向栈中插入元素的操作称为进栈或入栈(push)，从栈中删除元素的操作称为退栈或出栈(pop)。 栈是按照先进后出(FILO,First In Last Out)或后进先出(L
队列的入队和出队
weixin_44573938的博客
05-28 1万+
队列是一个特殊的线性表，队列简称为“对”。 队列的插入元素的操作称为“入队”或者“入队列”，删除元素的操作称为“出队”或者“出队列”。 那么，队列是如何插入元素和删除元素的呢。 队列有两种存储结构，一种是顺序排列，另一种是链式排列。 队列的元素存放的都是地址连续的单元。而队列的特征是“先进先出”，且队列的入队只允许队尾操作，rear增加一位。队头front不允许修改。队列的出队则相反，只允许队头操作，front增加一位，队尾rear不允许修改。所以为了避免“假溢出”这个问题我以顺序队列的循环队列为例来讲解。
数据结构之队列
jiaomubai的博客
02-05 3627
什么是队列 队列（queue）是一种线性数据结构。与同为线性数据结构的栈不同的是队列中的元素遵循的是先进先出（First In First Out）的规则，和在现实中排队一样，讲究的是先来后到的原则。队列出口端叫做队头（front），队列的入口端叫做队尾（rear）。 与栈类似，队列这种线性数据结构既可以用数组来实现，也可以用链表来实现。用数组来实现时，我们可以自行规定队尾的位置，比如说规定最后一个元素的下一个位置为队尾，或者规定最后一个元素所在的位置为队尾，这两种都行，毕竟是自己实现的。本文规定最后一
572-数据结构(队列理论)
LINZEYU666的博客
09-17 857
队列 队列底层也是通过数组或者链表实现的 队列基于数组或者链表规定增加元素和删除元素的规则和方向 队列的元素入队和出队：先进先出，后进后出，和我们排队买东西是一样的 元素从队尾入队，从队头出队 我们要定义2个成员变量，一个指向队头，一个指向队尾 刚开始的时候，它们都指向0号位置。 也就是说，初始化的时候，如果队列底层是基于数组实现的， 现在入队： 从队尾入队 rear含义：末尾元素的下一个位置 现在继续入队 现在要出队： 从队头出队 我们出队，只需要把指向队头的标识first移动一下，让它访问
C语言查看队头元素,C语言实现循环队列的初始化&进队&出队&读取队头元素&判空-1...
weixin_26779013的博客
05-23 1656
目前，处在学习数据结构+ing，由于之前学过了队列，今天就把自己写过的代码做了一些完善分享给大家，希望能够帮助到有需要的朋友，有不足的地方欢迎大家交流 φ(゜▽゜*)♪队列是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出的特性。一、系统用到的抽象数据类型定义：ADT Queue{数据元素：可以是任意类型的数据，但必须属于同一个数据对象。数据关系：队...
c语言队头元素出队并置为u,数据结构课程设计图的存储与遍历.doc
weixin_33074843的博客
05-22 367
数据结构课程设计图的存储与遍历中南大学题 目学生姓名指导教师学 院专业班级完成时间课程设计目的1.1掌握图的邻接表存贮结构。1.2掌握队列的基本运算实现。1.3掌握图的邻接表的算法实现。1.4掌握图的广度优先搜索周游算法实现。1.5掌握图的深度优先搜索周游算法实现第二章 设计内容和要求对任意给定的图(顶点数和边数自定)，建立它的邻接表并输出，然后利用队列的五种基本运算(置空队列、进队、...
线性结构 -- 栈和队列
柳絮
10-18 3289
线性结构 – 栈和队列 线性结构是一个有序数据元素的集合。 常用的线性结构有：线性表，栈，队列，双队列，数组，串。 常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。 特征： 1．集合中必存在唯一的一个"第一个元素"； 2．集合中必存在唯一的一个"最后的元素"； 3．除最后元素之外，其它数据元素均有唯一的"后继"； 4．除第一元素之外，其它数据元素均有唯一的"前驱"。 数据结构...
数据结构栈和队列试题及答案
11-26
队列和栈都是运算受限的线性表，只允许在表的一端进行特定的插入和删除操作，该说法正确。 18. **栈和队列的基本属性** 栈和队列都是线性表，但它们分别采用了LIFO和FIFO的规则来约束插入和删除操作，该说法正确...
实验一： 线性结构应用栈与队列应用
09-20
掌握顺序表、链表存储结构，以及线性表、栈和队列的基本操作，并能够在实际问题背景下的灵活运用线性表、栈或队列特性，综合运用程序设计、算法分析等知识解决实际问题。（可参考实验任务书） 2.实验工具 vc / dev...
线性结构- 栈与队列.rar
09-16
在本压缩包“线性结构- 栈与队列.rar”中，主要探讨了两种重要的线性结构——栈和队列，这两种数据结构在编程和算法设计中具有广泛的应用。 首先，栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构...
线性结构线形表栈和队列PPT学习教案.pptx
10-11
线性结构中的线形表，包括栈和队列，是数据结构的基础概念，它们在计算机科学和编程中扮演着重要角色。线性表是数据的一种有序存储方式，而栈和队列则是线性表的特殊形式，具有特定的访问规则。 栈是一种后进先出...
链队列的简单操作（入队，出队，输出队元素等）
口中冰的博客
10-27 3万+
定义一个节点，里面包含元素类型，指向下一个节点的指针。然后定义一个结构体，里面两个指针，指向队头和队尾 typedef struct QNode { int data; struct QNode * next; }QNode, * Queue; typedef struct { Queue front; Queue rear; }LinkQueue; 入队操作要注意别...
队列的入队、出队基本操作
热门推荐
leumber的专栏
10-17 4万+
队列先进先出的线性表（FIFO）队尾：队列中指定了用来插入数据的一端 队头：队列中指定了用来删除数据的一端 入队：数据的插入动作 出队：数据的删除动作 1.顺序队列//顺序队列 #define QUEUESIZE 64typedef struct _sequ { dataType data[QUEUESIZE]; int front; int rear; }SeQueue,*
带头结点的队列出队操作
等风来
07-31 720
① 判空，判断队列是否为空，若为空，返回false if(Q.front == Q.rear) return false; ② 创建临时变量存储要出队元素： LinkNode *p = Q.front -> next; x = p.data; ③ 队头指针后继指向要出队元素的后继元素： Q.fronot->next = p-> next; ④ 判断要出队的元素是否为最后一个元素，若为最后一个元素，应该将队尾指针指向头节点。 if(Q.rear == p) { Q.rear = Q.fron
【笔记】数据结构12
m0_52024881的博客
09-29 567
看到的社区的一个知识总结，这里记录一下。
数据结构—排序
最新发布
2302_81258662的博客
10-03 1078
在数据结构中，排序是一种将数据元素重新排列的过程，通常是为了使它们按照特定的顺序（如升序或降序）组织起来。排序在计算机科学中非常重要，下面是一些常见的数据结构排序方法和它们的特点。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1140
本文介绍了数据结构中的AVL树，给出了C++的代码实现
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1274
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
深入理解 C# 中的集合与数据结构
qq_45728381的博客
10-02 1364
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
数据结构栈和队列：基本运算与应用
"队列的基本运算-数据结构栈和队列PP" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和修改。本资源主要关注两种特殊的数据结构：栈和队列，它们都是线性数据结构的变体。 栈是一种“后进先出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

芥末虾

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

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

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

打赏作者

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

抵扣说明：

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

余额充值