数据结构----栈和队列

已于 2023-10-20 11:44:25 修改
阅读量103 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 java 开发语言
于 2021-08-10 10:31:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41420788/article/details/119550652
版权

栈和队列

栈

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

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

栈的接口实现

结构
typedef int STDatatype;
typedef struct Stack
{
	STDatatype *a;
	int top;
	int capacity;
}ST;
入栈
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("rellaoc fail\n");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}
初始化和销毁

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

void StackDestroy(ST* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	--ps->top;
}
判空 大小 栈顶
bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

STDatatype StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->a[ps->top - 1];
}

队列

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出
FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头
在这里插入图片描述
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低

队列的接口实现

结构
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* phead;
	QueueNode* ptail;
}Queue;
初始化 销毁
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
}
void QueueDestory(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* cur = pq->phead;
	while (cur->next)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
}
入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->next = NULL;
	newnode->data = x;
	if (newnode == NULL)
	{
		perror("Push");
		exit(-1);
	}
	if (pq->phead == NULL)
		pq->phead = pq->ptail = newnode;
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = pq->ptail->next;
	}
		

}
出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		//free(pq->ptail);//重复释放会崩溃
		pq->phead = NULL;
		pq->ptail = NULL;
	}
	else
	{
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

}
大小 队头 队尾 判空
int QueueSize(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* cur = pq->phead;
	int size = 0;
	while (cur->next)
	{
		size++;
		cur = cur->next;
	}
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL && pq->ptail == NULL;
}
总结

链表要改变传入的指针(改变头)：

  1. 传二级指针
  2. 带哨兵位（避开改变）
  3. 返回值接收新的地址
  4. 结构体包裹(详见上面队列的实现)

队列拓展(环形队列)

(尾－头＋表长)%表长队列头指针为front，队列尾指针为rear，队列容量为M， 则元素个数为|rear-front+M|%M
循环队列是一种线性数据结构，其操作表现基于 FIFO原则 并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
环形队列可以使用数组实现，也可以使用循环链表实现
我们下面使用数组实现在这里插入图片描述
我们定义两个节点（头尾 front rear）为区分满的状态和空的状态，我们需要额外增加一个空的空间作为满的标识(rear+1=front)
注意：
当rear在数组位时额外讨论 ((obj->front)%=(obj->k+1))取模

实现接口
结构
typedef struct {
   int *a;//动态数组
   int front;
   int rear;
   int k;//最多存放元素个数
} MyCircularQueue;
初始化 释放
MyCircularQueue* myCircularQueueCreate(int k) {
   MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
   obj->a=(int*)malloc(sizeof(int)*(k+1));
   obj->k=k;
   obj->front=0;
   obj->rear=0;
   return obj;
}
void myCircularQueueFree(MyCircularQueue* obj) {
   assert(obj);
   free(obj->a);
   free(obj);
}
判空判满
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
   assert(obj);

   if(obj->front==obj->rear)
       return true;
   else
       return false;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
   assert(obj);

   if((obj->rear+1)%(obj->k+1)==obj->front)//当rear在数组尾时(数组有>k+1个元素,下标最大为k)
       return true;
   else    
       return false;
}
入队出队
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
   assert(obj);

   if(myCircularQueueIsFull(obj))
       return false;
   obj->a[obj->rear]=value;
   (obj->rear)++;
   (obj->rear)%=(obj->k+1);
   return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
   assert(obj);

   if(myCircularQueueIsEmpty(obj))
       return false;
   obj->front++;
   (obj->front)%=(obj->k+1);
   return true;
}
头尾元素
int myCircularQueueFront(MyCircularQueue* obj) {
   assert(obj);
   if(myCircularQueueIsEmpty(obj))
       return -1;
   return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
  assert(obj);
   if(myCircularQueueIsEmpty(obj))
       return -1;
   return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];
   //当rear为0的时候减1会出现问题
}

用队列实现栈

OJ链接

分析：

  1. 定义两个队列
  2. 入栈操作相当于给非空队列进行入队操作
  3. 出栈操作相当于非空队列的队尾元素出队，此时需要把非空队列除最后一个元素之外的其余元素入队到空队列，然后出队最后一个队尾元素
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

/** Initialize your data structure here. */

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

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    QueueNode* newnode=(QueueNode*)malloc(sizeof(QueueNode));
    if(!QueueEmpty(&obj->q1)){
        QueuePush(&obj->q1,x);
    }   
    else{
        QueuePush(&obj->q2,x);
    }
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* empty=&obj->q1;
    Queue* nonempty=&obj->q2;
    if(QueueEmpty(&obj->q2))
    {
        empty=&obj->q2;
        nonempty=&obj->q1;
    }
    while(QueueSize(nonempty)>1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }
    int front=QueueFront(nonempty);
    QueuePop(nonempty);
    return front;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    assert(obj);
    if(QueueEmpty(&obj->q2))
        return QueueBack(&obj->q1);
    else
        return QueueBack(&obj->q2);
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return (QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2));
}

void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
    free(obj);
}

用栈实现队列

OJ链接

分析：

  1. 创建两个栈，一个栈进行入队操作，另一个栈进行出队操作
  2. 出队操作： 当出队的栈不为空是，直接进行出栈操作，如果为空，需要把入队的栈元素全部导入到出队的栈，然后再进行出栈操作
typedef struct {
    //入队栈
    Stack pushST;
    //出队栈
    Stack popST;
} MyQueue;
 
/** Initialize your data structure here. */
MyQueue* myQueueCreate(int maxSize) {
    MyQueue* pqueue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&pqueue->pushST, maxSize);
    StackInit(&pqueue->popST, maxSize);
    return pqueue;
}
 
/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    //入队栈进行入栈操作
    StackPush(&obj->pushST, x);
}
 
/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    //如果出队栈为空，导入入队栈的元素
    if(StackEmpty(&obj->popST) == 0)
    {
        while(StackEmpty(&obj->pushST) != 0)
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    int front = StackTop(&obj->popST);
    //出队栈进行出队操作
    StackPop(&obj->popST);
    return front;
}
 
/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    //类似于出队操作
    if(StackEmpty(&obj->popST) == 0)
    {
        while(StackEmpty(&obj->pushST) != 0)
        {
            StackPush(&obj->popST, StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    
    return StackTop(&obj->popST);
}
 
/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST) == 0
        &&  StackEmpty(&obj->popST) == 0;
}
 
void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);
    
    free(obj);
}
4nc414g0n
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构-队列和栈有什么区别
readerss的博客
08-28 1237
数据结构-队列和栈有什么区别 1：队列和栈是两种不同的数据结构。它们有以下区别： （1）操作的名称不同。队列的插入称为入队，队列的删除称为出队。栈的插入称为进栈，栈的删除称为出栈。 （2）可操作的方式不同。队列是在队尾入队，队头出队，即两边都可操作。而栈的进栈和出栈都是在栈顶进行的，无法对栈底直接进行操作。 （3）操作的方法不同。队列是先进先出（FIFO），即队列的修改是依先进先出的原则进行的。新...
数据结构-栈和队列
2302_79539362的博客
12-04 1856
数据结构-栈和队列
线性结构 -- 栈和队列
柳絮
10-18 3211
线性结构 – 栈和队列 线性结构是一个有序数据元素的集合。 常用的线性结构有：线性表，栈，队列，双队列，数组，串。 常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图。 特征： 1．集合中必存在唯一的一个"第一个元素"； 2．集合中必存在唯一的一个"最后的元素"； 3．除最后元素之外，其它数据元素均有唯一的"后继"； 4．除第一元素之外，其它数据元素均有唯一的"前驱"。 数据结构...
数据结构--栈，队列
includeevey的博客
08-08 1953
一篇好的文章离不开你的观看
数据结构-栈和队列篇
qq_44663230的博客
09-05 1896
栈和队列思维导图+栈和队列习题
数据结构 --- 栈和队列
weixin_52625645的博客
10-10 1053
栈和队列基础知识
数据结构---栈和队列
weixin_63219391的博客
03-06 1022
本文介绍了栈和队列的概念和结构，文内包含栈和队列的实现代码，以及扩展：使用队列实现栈和使用栈实现队列。
Java数据结构-队列
QUIXOTIC_的博客
04-04 1095
队列，循环队列
数据结构--栈和队列
w_z_j
03-29 2177
1.栈 1.1栈的概念 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素的操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈内元素遵从先进后出的规则。压栈就是插入数据的操作，出栈就是删除数据的操作，都在栈顶实现。 1.2栈的实现 栈的实现可以由链表和数组分别实现，不过考虑到栈的特性，还是选择用数组来实现栈，因为数组在删除和添加尾部数据时消耗较少。 //栈的实现类似顺序表的实现 typedef int STDataType; typedef struct Stack {
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。...栈、队列和数组是C语言数据结构中的三个基本概念，栈的实现需要考虑到实际情况，栈的应用非常广泛，栈的优点和缺点需要被正确地考虑。
数据结构学习-队列/栈
04-28
### 数据结构学习——队列与栈 ...通过以上介绍可以看出，队列和栈都是基础且重要的数据结构，在程序设计中有着不可替代的作用。理解它们的基本概念和实现方法，对于提高编程能力和解决实际问题具有重要意义。
数据结构-栈和队列的使用
03-25
栈和队列是两种基础且广泛使用的线性数据结构，它们在程序设计中扮演着重要角色。本篇将详细介绍这两种数据结构及其在C语言中的实现。 栈（Stack）是一种后进先出（Last In First Out, LIFO）的数据结构，类似于...
【初阶数据结构篇】单链表的实现（赋源码）
最新发布
2301_79849925的博客
07-25 1505
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1225
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 419
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1157
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
"软件基础: 第四章 数据结构-栈和队列，第五章数据结构-栈、队列简介
在软件基础课程的第五章中，我们学习了数据结构中的栈和队列的概念和实现方法。本章主要包括了栈和队列的基本概念、顺序栈、链接栈、队列、顺序队列、环形队列和链接队列等内容。 在第四章中，我们首先介绍了数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值