【数据结构】_3.栈与队列

最新推荐文章于 2024-08-08 18:03:08 发布
最新推荐文章于 2024-08-08 18:03:08 发布
阅读量338 收藏
点赞数
分类专栏： 数据结构（C&C++） 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63299495/article/details/127270178
版权

1.栈

1.1 栈的概念与结构

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

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

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

1.2 栈的实现

栈的实现可以使用数组和链表实现，相对而言数组的实现效果更优，数组在尾上插入数据的效率高且代价小：

//Stack.h

#pragma once
#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 StackDestory(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

//Stack.c
#include "Stack.h"
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackDestory(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)
		{
			printf("realloc fail\n");
			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];
}
bool StackEmpty(ST* ps)
{
	return ps->top == 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

1.3例题

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

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

A. 1432   B.2341  C. 3142  D.3421

解析：A：1入栈再出栈，234入栈再依次出栈；B：12入栈，2出栈，3入栈再出栈，4入栈再出栈，1出栈；C：不可能 D：123入栈，3出栈，4入栈再出栈，12出栈；

2.队列

2.1 队列的概念和结构

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

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

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

2.2 队列的实现

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

//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
{
	//int size;
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq);
void QueueDestory(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);


//Queue.c
#include "Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* bhcur = cur->next;
		free(cur);
		cur = bhcur;
	}
	pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
    else
    {
	    pq->tail->next = newnode;
	    pq->tail = newnode;
    }
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* bhhead = pq->head->next;
		free(pq->head);
		pq->head = bhhead;
	}
}
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->tail==NULL;也可
	return pq->head == NULL;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
}

2.3 队列应用场景

1.排队，保持绝对公平，先入先出；

2.二叉树广度优先遍历：BFS

3.队列与栈的互相实现

（1）栈实现队列：


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

void StackInit(ST* ps);
void StackDestory(ST* ps);
void StackPush(ST* ps,STDataType x);
void StackPop(ST* ps);
STDataType StackTop(ST* ps);
bool StackEmpty(ST* ps);
int StackSize(ST* ps);

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

void StackDestory(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)
		{
			printf("realloc fail\n");
			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];
}
bool StackEmpty(ST* ps)
{
	return ps->top == 0;
}
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

typedef struct
{
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->pushst);
    StackInit(&obj->popst);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->pushst,x);
}

int myQueuePop(MyQueue* obj) 
{
     if(StackEmpty(&obj->popst))
    {
    while(!StackEmpty(&obj->pushst))
    {
        StackPush(&obj->popst,StackTop(&obj->pushst));
        StackPop(&obj->pushst);
    }
    }
    int front=StackTop(&obj->popst);
    StackPop(&obj->popst);
    return front;
}

int myQueuePeek(MyQueue* obj) 
{
    if(StackEmpty(&obj->popst))
    {
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj)
{
    return StackEmpty(&obj->pushst)&&StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj)
{
    StackDestory(&obj->pushst);
    StackDestory(&obj->popst);
    free(obj);
}

（2）队列实现栈：

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

void QueueInit(Queue* pq);
void QueueDestory(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);
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* bhcur = cur->next;
		free(cur);
		cur = bhcur;
	}
	pq->head = pq->tail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode =(QNode*) malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* bhhead = pq->head->next;
		free(pq->head);
		pq->head = bhhead;
	}
}
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;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
    return size;
}

typedef struct
{
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() 
{
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    QueueInit (&obj->q1);
    QueueInit (&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) 
{
    if(!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) 
{
    Queue* emptyQ=&obj->q1;
    Queue* nonEmptyQ=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        nonEmptyQ=&obj->q1;
    }
    while(QueueSize(nonEmptyQ)>1)
    {
        QueuePush(emptyQ,QueueFront(nonEmptyQ));
        QueuePop(nonEmptyQ);
    }
    int top=QueueFront(nonEmptyQ);
    QueuePop(nonEmptyQ);
    return top;
}

int myStackTop(MyStack* obj) 
{
     if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
       return  QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) 
{
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) 
{
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}
_周游
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JiSuanQi.rar_jisuanqi_栈和队列_计算器 数据结构
09-20
总的来说，这个项目提供了对数据结构栈和队列的实际应用案例，是学习和理解这些基础数据结构的好教材。通过阅读和分析源代码，可以深入了解如何在实际问题中运用这些抽象数据类型，并提高编程技能。同时，Visual C++...
20190911练习题总结
qq_44941119的博客
09-13 350
编程题 （力扣766）如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。 给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。 示例 1: 输入: matrix = [ [1,2,3,4], [5,1,2,3], [9,5,1,2] ] 输出: True 解释: 在上述矩阵中, 其对角线为: “[9]”, “[5, 5]”, “[1, 1,...
动态数组练习题（一）
qq_43137918的博客
09-13 2219
选择题 1.设入栈顺序为A,B,C,D,E则出栈序列不可能为（B） A. EDCBA B. ADEBC C. ABCDE D. ABDCE 解题思路：我们首先要知道栈遵守先进后出的原则。出栈的方式有多种，所以这个题我们可以用排除法：A选项先入栈的后出，出栈顺序符合；B选项A先出栈说明A刚进去就出栈，D出栈的话，说明B，C在D之前入栈，此时栈中顺序是BC，然后E进栈出栈，下来必然是C出栈，而不是B，...
【求职】小米 2018 秋招测试开发工程师笔试题
瑞新の博客：bennyrhys
06-11 1489
小米 2018 秋招测试开发工程师笔试题 一、单选题 1.静态变量static 在不同的实例中地址是否一样？他们储存在什么区域？（ ） A. 地址一样，在堆栈区。 B. 地址不一样，在堆栈区。 C. 地址一样，在全局区。 D. 地址不一样，在全局区。 2.在网络字节序中，所谓”小端”(little endian)说法正确的是 （ ） A. 高字节数据存放在低地址处，低字节数据存放在高地址处 B. 低字节位数据存放在内存低地址处, 高字节位数据存放在内存高地址处 C. 和编译器相关 D. 上述答案都不正确 3
数据结构：面试题目-专项练习-栈-习题练习
世上再无张显宗
06-18 3460
1、下列关于栈叙述正确的是（ ）。 正确答案: D 你的答案: D (正确) 算法就是程序 设计算法时只需要考虑数据结构的设计 设计算法时只需要考虑结果的可靠性 以上三种说法都不对 解析：A：程序是数据结构+算法，错。 B,C：设计一个算法时，考虑的因素很多。首先要满足算法的五个基本特性：确定性，可行性，有穷性，输入，输出。其次，再从可读性，健壮性，低耦合高效率，低存储等方面进行优化。 2、一个栈的入栈序列是a,b,c,d,e，则栈的不可能的输出序列是（ ） 正确答案: C 你的答案: D (错误
数据结构_栈与队列.pdf
11-12
在本实验中，我们主要探讨了两种重要的数据结构——栈和队列，它们在计算机科学尤其是互联网技术领域中有着广泛的应用。栈被称为“后进先出”（LIFO，Last In First Out）的数据结构，而队列则是“先进先出”（FIFO...
数据结构_栈与队列.docx
11-12
数据结构中的栈与队列是两种非常基础且重要的抽象数据类型，它们在计算机科学和软件工程中有着广泛的应用。在互联网行业中，栈和队列常用于处理数据的临时存储、任务调度、网络请求处理等问题。 栈（Stack）遵循...
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
【数据结构-前缀哈希】力扣523. 连续的子数组和
sjsjs11的博客
08-05 368
当发现有两个余数相同的key的时候，对他们value作差，如果大于等于二，说明该子段长度大于等于二，这时候就找到了一个好的子数组，返回true，如果到最后都没有找到这样一个好的子数组，返回false。，其中 m 是数组 nums 的长度。解释：[23, 2, 6, 4, 7] 是大小为 5 的子数组，并且和为 42。输入：nums = [23,2,6,4,7], k = 13。输入：nums = [23,2,4,6,7], k = 6。输入：nums = [23,2,6,4,7], k = 6。
常见8种数据结构
qq_43575301的博客
08-08 691
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
数据结构：栈（含源码）
2401_86551514的博客
08-05 578
先判断容量是否有足够的空间让数据入栈，在第一次入栈是先给定4个空间，后面每次不够时就将空间数乘以2， 还有一个判断是否开辟成功（这个可以不写，一般都会开辟成功）。栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底，栈中的数据元素遵守后进先出的原则。我们在创建栈时，一般是创建支持动态增长的栈，定长的静态栈不实用。出栈非常的简单，只要将top数减少一个就行了，相当于是下一次入栈是直接把这个数据修改掉，就算没修改，打印时也不影响。
数据结构：链表经典算法OJ题
2401_86551514的博客
08-04 1042
在了解了链表的相关知识后，我们还需要一些题目进行练习加深对链表这方面知识的理解，也可以用来检测链表这块学的的怎么样，废话不多说，开始上手。
【数据结构】数组复习-二分查找法
最新发布
weixin_54096215的博客
08-08 340
[34] 在排序数组中查找元素的第一个和最后一个位置left = 0else:else:left = 0else:main()c++public:} else {left = 0;
数据结构——链式结构二叉树
2301_81888634的博客
08-02 705
我们已经学习了实现二叉树的两种方法：顺序结构（堆）和链式结构。敬请期待“二叉树OJ题”~
数据结构-递归
B13646141775的博客
08-05 841
递归简单实现及如何阅读递归代码
数据结构3—单链表（附源码）
l1894的博客
08-05 308
概念：链表是一种、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的实现的。结构：由一个个结点构成，每个结点是一个结构体（里面包含了数据域和指针域，其中指针域存储的是下一个结点的地址）
【数据结构的——红黑树】
Pumpkin_O的博客
08-08 814
红黑树是一种自平衡的二叉查找树，是一种高效的查找树，可以在Olog2n时间内完成查找、增加和删除等操作。有了二叉搜索树，为什么需要平衡二叉树？对于二叉搜索树，如果插入的数据是随机的，那么它就是接近平衡的二叉树，平衡二叉树（AVLTree）的操作效率较高，查增删的时间复杂度都是Olog2n。但是当插入的数据有序时，二叉搜索树的结点就会只在根结点的一侧，就变成了一个链表，操作效率也因此变低，时间复杂度变为了O(n)。
数据结构：双向链表
2303_81073778的博客
08-05 323
二、链表的图像。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值