Lesson4--栈和队列

已于 2023-02-08 12:15:18 修改
阅读量1.1k 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
于 2023-01-22 22:16:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiguazkb123/article/details/128749738
版权

目录

 

1.栈

1.1栈的概念及结构

1.2栈的实现

        初始化栈

        销毁栈

        栈的扩容

        入栈

        出栈

         获取栈顶元素

        获取栈中有效元素个数

        判空

程序代码如下

Stack.h

Stack.c

test.c

2.队列

2.1队列的概念及结构

​2.2队列的实现

        初始化队列

        队尾入队列

        队头出队列

        获取队列头部元素

        获取队列队尾元素

        获取队列中有效元素个数

        队列打印

        队列判空

        销毁队列

Queue.h

Queue.c

test.c

1.栈

1.1栈的概念及结构

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

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

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

 

可以使用数组（数组栈）或者链表（链表栈）实现栈。

数组栈实现更优一些。因为数组栈 尾插尾删效率更高，且缓存利用率高。

单链表，适合头插头删，如果用头作栈顶，可以设计成单链表，但是有点怪。用尾作栈底，要设计成双向链表，否则增删数据效率低。
 

 1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的 代价比较小。

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

// 初始化栈
void StackInit(ST* ps);
//栈空间检查
void StackCheckCapacity(ST* ps);
// 销毁栈
void StackDestroy(ST* ps);
// 入栈
void StackPush(ST* ps, STDataType x);
// 出栈
void StackPop(ST* ps);
// 获取栈顶元素
STDataType StackTop(ST* ps);
// 获取栈中有效元素个数
int StackSize(ST* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(ST* ps);

初始化栈

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

销毁栈

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

栈的扩容

void StackCheckCapacity(ST* ps)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}

 入栈

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	StackCheckCapacity(ps);
	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];
}

获取栈中有效元素个数

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

判空

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
bool StackEmpty(ST* ps)
{
	assert(ps);
	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	//换成下面语句就行了
	return ps->top == 0;
}

程序代码如下

Stack.h

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int STDataType;
typedef struct Stack
{
	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);
int StackSize(ST* ps);
bool StackEmpty(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

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

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

void StackCheckCapacity(ST* ps)
{
	assert(ps);

	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	StackCheckCapacity(ps);
	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];
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	/*if (ps->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	//换成下面语句就行了
	return ps->top == 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void test1()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	StackPush(&st, 3);
	StackPush(&st, 4);
	printf("%d ", StackTop(&st));

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

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

2.队列

2.1队列的概念及结构

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

  • 入队列：进行插入操作的一端称为队尾
  • 出队列：进行删除操作的一端称为队头

 2.2队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

typedef int QDataType;

//链式结构：表示队列
typedef struct QueueNode
{
	struct QueueNode* next;//指针域
	QDataType data;//数据域
}QueueNode;

//队列链表的头指针与尾指针
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

//初始化队列
void QueueInit(Queue* pq);
//扩队
QueueNode* BuyQueueNode(QDataType x);
//队尾入队列
void QueuePush(Queue* pq, QDataType x);
//队头出队列
void QueuePop(Queue* pq);
//获取队列头部元素
QDataType QueueFront(Queue* pq);
//获取队列队尾元素
QDataType QueueBack(Queue* pq);
//获取队列中有效元素个数
int QueueSize(Queue* pq);
//队列打印
void QueuePrint(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);

初始化队列

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

队尾入队列

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = BuyQueueNode(x);
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

队头出队列

void QueuePop(Queue* pq)
{
	assert(pq);
	//if (pq->head == NULL)
	//	return;
	assert(!QueueEmpty(pq));

	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

获取队列头部元素

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;
}

获取队列中有效元素个数

int QueueSize(Queue* pq)
{
	assert(pq);

	int n = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		++n;
		cur = cur->next;
	}

	return n;
}

队列打印

void QueuePrint(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");

}

队列判空

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

销毁队列

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;// QueueNode* cur =NULL
	while (cur != NULL)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}

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

Queue.h

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

typedef int QDataType;

//链式结构：表示队列
typedef struct QueueNode
{
	struct QueueNode* next;//指针域
	QDataType data;//数据域
}QueueNode;

//队列链表的头指针与尾指针
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

//初始化队列
void QueueInit(Queue* pq);
//扩队
QueueNode* BuyQueueNode(QDataType x);
//队尾入队列
void QueuePush(Queue* pq, QDataType x);
//队头出队列
void QueuePop(Queue* pq);
//获取队列头部元素
QDataType QueueFront(Queue* pq);
//获取队列队尾元素
QDataType QueueBack(Queue* pq);
//获取队列中有效元素个数
int QueueSize(Queue* pq);
//队列打印
void QueuePrint(Queue* pq);
//队列判空
bool QueueEmpty(Queue* pq);
//销毁队列
void QueueDestroy(Queue* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"Queue.h"

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

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;// QueueNode* cur =NULL
	while (cur != NULL)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}
QueueNode* BuyQueueNode(QDataType x)
{
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = BuyQueueNode(x);
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
void QueuePrint(Queue* pq)
{
	QueueNode* cur = pq->head;
	while (cur)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");

}

void QueuePop(Queue* pq)
{
	assert(pq);
	//if (pq->head == NULL)
	//	return;
	assert(!QueueEmpty(pq));

	QueueNode* next = pq->head->next;
	free(pq->head);
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
}

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;
}

int QueueSize(Queue* pq)
{
	assert(pq);

	int n = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		++n;
		cur = cur->next;
	}

	return n;
}

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

test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"Queue.h"


void test1()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePrint(&q);
	/*QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);*/
	QueuePrint(&q);

	printf("%d\n", QueueFront(&q));
	printf("%d\n", QueueBack(&q));
	QueueDestroy(&q);

}

void test2()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QDataType front = QueueFront(&q);
	printf("%d ", front);
	QueuePop(&q);

	QueuePush(&q, 3);
	QueuePush(&q, 4);

	while (!QueueEmpty(&q))
	{
		QDataType front = QueueFront(&q);
		printf("%d ", front);
		QueuePop(&q);
	}
	printf("\n");
}
int main()
{
	//test1();
	test2();
	return 0;
}

xiguazkb123
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈和队列
weixin_44091229的博客
04-15 165
1.栈 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 类似用一种结构实现尾插尾删的操作。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 栈的实现： 栈的实现一般可以使用数组或者链表实现...
Lesson4--栈和队列.pdf
10-06
栈和队列 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。栈中的数据元素遵守后进先出（Last In First Out，LIFO）的原则。栈有多种实现方式，包括数组实现和链表实现，数组实现相对来说效率较...
【C++】STL——queue的介绍和使用、queue的push和pop函数介绍和使用、queue的其他成员函数
Crocodile1006的博客
08-03 1万+
STL、queue的介绍、queue的使用、queue构造函数、queue的成员函数、empty()（检测队列是否为空，是返回true，否则返回false）size()（返回队列中有效元素的个数）front()（返回队头元素的引用）back()（返回队尾元素的引用）push()（在队尾将元素val入队列）pop()（将队头元素出队列）
C++-queue：queue基本用法【q.push(x)、q.front()、q.back()、q.pop()、q.size()、q.empty()】
热门推荐
u013250861的博客
12-20 1万+
为了降低时间复杂度，将数组当作一个首尾相连的圆环，分别用两个标志front、rear代表队列的头部和尾部。删除元素时，队首标志往后移，添加元素时，若队尾没有空间，考虑数组的头部空间若还有，则在队头添加元素，防止数组内存空间的流失。出队操作：数组头部元素出队之后，头部之后的元素均需要往前移动一个位置，时间复杂度为O（n）设置一个标志变量flag，同时满足front=rear且flag=1时为满队列。入队操作：在数组的末尾添加元素，时间复杂度为O（1）链表头为队列头部，链表尾为队列尾部。空一个元素，保持为空。
JAVA栈和队列（数据结构）
m0_66714418的博客
04-20 110
栈（Stack）：是一种基于后进先出(LIFO)原则的数据结构，只允许在一端插入和删除元素。在栈中，插入元素的一端被称为栈顶，删除元素的一端被称为栈底。栈用于许多算法和应用程序中，如寻路算法、内存管理和表达式求值等。压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。出栈：栈的删除操作叫做出栈。出数据在栈顶。
比特数据结构课件-Lesson4-栈和队列.pdf
07-07
本节重点介绍了两种基本的数据结构：栈和队列。 栈是一种遵循后进先出（LIFO）原则的数据结构。在这个结构中，最新的元素（即最后加入的元素）总是最先被移除。栈有两个主要操作：压栈（进栈/入栈），即向栈顶添加...
Lesson3--顺序表_链表.pdf
10-06
线性表是一种在实际中广泛使用的数据结构，常见的线性表有顺序表、链表、栈、队列、字符串等。线性表在逻辑上是线性结构，也就是说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常...
lesson-7
03-31
1. **数据结构与算法**：数据结构是存储和组织数据的方式，如数组、链表、栈、队列、树和图等。算法则是解决问题或执行任务的精确步骤，如排序算法（冒泡排序、快速排序）、查找算法（二分查找）等。掌握好这些基础...
6-3 Deque_pta_C++_6-3deque_
10-02
用户可能需要编写自定义函数，使用deque解决特定问题，例如实现一个双端队列的栈模拟或队列模拟。 在文件名称列表中只有一个文件“6-3 Deque”，这可能是一个源代码文件，包含了练习的实现或示例。打开这个文件，你...
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 671
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 573
递归算法，爬楼梯等解法
数据结构--单链表实现
LH__1314的博客
07-05 1643
链表和顺序表都是线性表的一种，但是顺序表在物理结构和逻辑结构上都是连续的，但链表在逻辑结构上是连续的，而在物理结构上不一定连续；来看以下图片来认识链表与顺序表的差别这里以动态顺序表为例，和链表中的单链表对比一下动态顺序表单链表这里就可以很清晰的看到顺序表的底层其实就是一个数组，数据的是连续存储的（顺序表物理结构连续）；而链表它每一个数据都不是连续的（链表物理结构上不一定连续）。链表节点通过观察上图，我们会发现链表每一个节点都存放在数据和下一个节点的地址。
二分查找和斐波那契查找
weixin_50960004的博客
07-13 149
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
5Python的Pandas：数据结构
最新发布
XiaoCai
07-13 229
Pandas是基于强大的NumPy库开发的，它继承了NumPy中的一些数据结构，也继承了NumPy的高效计算特性。
Redis 底层数据结构
xsgnzb的专栏
07-09 375
是列表和哈希表底层的实现之一，当只包含数字和短的字符串时，使用这个结构。由压缩列表和节点构成。压缩链表包含字节大小、尾指针偏移量、节点个数、节点列表、结束标识。编码类型包括int16、int32、int64，元素数组里的类型和编码类型相同。是有序集合的底层实现之一，由跳跃表和跳跃表节点组成。当新元素比元素数组里存放的类型比大时，会进行类型升级，重新分配空间和排序。跳跃表和平衡数的区别是，跳跃表查询复杂度平均跟平衡树一样是logn，最差是n²，但是它的实现很简单。上个节点的长度是动态的，分为1字节和5字节。
数据结构之链表详解及示例（C，C#，C++）
qq_35320456的博客
07-13 693
链表是一种灵活且强大的数据结构，适用于需要频繁插入和删除操作的场景。本文通过C、C#、C++三种语言展示了链表的基本操作，帮助读者理解链表的工作原理。在实际应用中，应根据具体需求选择合适的链表变种，如单向链表、双向链表或循环链表。掌握链表是成为优秀程序员的必经之路。
PHP数据结构之队列
likeshopgood的博客
07-09 444
队列是数据结构中的重要组成部分，尤其在多线程处理、任务调度和消息队列系统中发挥着关键作用。关于我们本文由ChatMoney团队出品，ChatMoney专注于AI应用落地与变现，我们提供全套、持续更新的AI源码系统与可执行的变现方案，致力于帮助更多人利用AI来变现，欢迎进入ChatMoney获取更多AI变现方案！
数据结构 —— 最小生成树
qq_67693066的博客
07-05 1160
数据结构 —— 最小生成树
新概念英语第二册lessons1-10知识点及练习.pdf
07-12
此外，Lesson1还介绍了一些实用的短语和表达，如 "be interesting" 表示有趣，"get angry" 意为生气，"turn round" 指的是转身，"pay attention" 是注意，"none of your business" 意思是不关你的事，"in the end" ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值