【C语言】栈和队列的相互实现

已于 2022-07-01 14:31:49 修改
阅读量839 收藏 9
点赞数 6
分类专栏： 算法 文章标签： 数据结构 c语言 visual studio code
于 2022-07-01 14:24:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62537611/article/details/125523833
版权

目录

用队列实现栈

代码实现

完整代码

用栈实现队列

 代码实现

完整代码

用队列实现栈

力扣链接：用队列实现栈

这个题目，使用队列模拟实现栈，我们是使用C语言来实现，由于C语言没有相应的库所以我们要先手写一个队列出来，在此之前我们还要对队列和栈的性质有所了解 ，可以参考我之前写的文章——（队列的模拟实现）和（栈的模拟实现）

方法：两个队列

为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是最后入栈的元素。所以我们可以使用两个队列实现栈的操作，其中一个队列用来存储栈内的元素，另一个队列用来倒数据。

入栈操作：把数据入队到其中一个队列中，另一个队列保持为空队列。

出栈操作：将存储了栈内元素的队列倒到另一个空的队列中，当倒了只剩下一个数据时停止，将这个数据出队就达到了出栈的效果。

  

代码实现

 创建两个队列

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

初始化 

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

 首先看一下这样写行不行？

这样写当然是不行的，因为它是带返回值的，所以我们要返回我们创建的地址，但是st是局部变量，出了这个函数就销毁了，那你接受到的只能是野指针。

所以这里只能用静态的或者malloc动态的，出了这个函数也不会被销毁，但是malloc更好，那我们就用malloc的，然后初始化这两个队列 就行了。

入栈

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

 这里就需要倒数据了，但是我们不知道哪个为空，哪个不为空，我们可以用假设法。先假设一个为空 ，一个不为空，再来一个if语句判断一下，确定哪个为空，哪个不为空。然后将非空队列的数据倒入空的队列中去，当非空对列倒的只剩下一个数据时就停止，最后pop掉这个数据。

 获取栈顶元素

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) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

 我们不仅要销毁这两个队列，还要free掉队列中指针指向的链表。

完整代码


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

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

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	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;
	}
	pq->size++;
}

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

	//1.一个节点
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;//避免野指针问题
	}
	//2.多个节点
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
	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;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	/*int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}*/
	return pq->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) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);

    free(obj);
}

用栈实现队列

力扣链接：用栈实现队列

这个题目是用栈实现队列，我们依然使用C语言来写，C语言没有相应的库，所以我们还是要先手写一个栈才能实现题目中要求的函数接口。

方法：两个栈

一个队列是先进先出，一个栈是先进后出，新进的数据肯定是在栈底。我们可以这样做，指定一个栈专门进数据，指定另外一个栈专门出数据。

入队操作：向push栈中入数据。

 出对操作：将push栈中的数据全部倒入pop栈中，pop栈中数据的顺序刚好与push栈中的数据顺序相反，正好满足队列的性质，最后在push栈的栈顶出数据就行了。

 

 代码实现

创建两个栈

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

 指定一个栈专门进数据，指定另外一个栈专门出数据。

初始化

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

销毁队列

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

初始化和销毁队列的方法和上面题目的方法一致，就不多讲了。

入队

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

 入对只需要push进栈就行啦。

出队

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->popst))
    {
        //如果pop栈为空，则把push栈的数据倒过来
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    int front=StackTop(&obj->popst);
    StackPop(&obj->popst);
    return front;
}

 首先要判断一下popst栈为不为空，如果为空，则把push栈的数据倒过来，不为空就直接在pop栈出数据。

取对头元素

int myQueuePeek(MyQueue* obj) {
     if(StackEmpty(&obj->popst))
    {
        //如果pop栈为空，则把push栈的数据倒过来
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

 这个就简单了，只需要取pop栈的栈顶的数据返回就可以了。

判空

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

两个栈等于一个队列，所以两个栈都需要判空。 和上面的题目一样。

完整代码


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

//判空
bool StackEmpty(ST* ps);

//栈的元素个数
int StackSize(ST* ps);
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	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)
		{
			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)
{
	assert(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))
    {
        //如果pop栈为空，则把push栈的数据倒过来
        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))
    {
        //如果pop栈为空，则把push栈的数据倒过来
        while(!StackEmpty(&obj->pushst))
        {
            StackPush(&obj->popst,StackTop(&obj->pushst));
            StackPop(&obj->pushst);
        }
    }
    return StackTop(&obj->popst);
}

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

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

总结：这两个题目是很相似的，你会写其中一个，那么另一个也不是什么难事。

晚风相伴
关注
专栏目录
数据结构（用C语言描述）：栈和队列基本概念、实现
Ezra1991的博客
10-17 1130
栈和队列 栈 栈的基本概念 栈的定义 栈(Stack)：只允许在一端进行插入或删除操作的线性表。 栈顶(Top): 线性表允许进行插入和删除的那一端 栈底(Bottom): 固定的，不允许进行插入和删除操作的另一端。 空栈：不含任何元素的空表。 栈的一个明显的操作特性：后进先出(Last In First Out, LIFO),故又称为后进先出的线性表。 ...
数据结构C语言篇《三》栈和队列概念，模拟函数实现，以及相关OJ面试题
愿你有青春亦可奔赴
05-22 1162
#pragma once typedef int DataType; typedef struct Stcak { DataType *arr; int capacity; //容量大小 int size; //有效元素个数---栈顶 }Stack; //栈的初始化 void StackInit(Stack *ps); //入栈 void StackPush(Stack *ps, DataType data); //出栈 void StackPop(Stack *ps); //获取栈顶元
C语言用两个栈实现一个队列的功能
10-22
用量个栈实现一个队列，使其可以有进队和出队的操作。
力扣232 - 用栈实现队列【C语言实现】
做技术人 · 产优质博客 · 找好工作
11-24 1957
力扣232 - 用栈实现队列，教你如何使用双栈实现队列操作
通过“ 栈 ”实现“ 队列 ”
最新发布
2302_80867815的博客
07-25 1202
在上期博客中我们通过在队列里面进行数据倒换来成功的实现了栈，那我们试试能不能通过在两个栈里面倒换数据来实现队列呢？根据之前的实现“ 栈 ”的经验我们可以重新定义一个结构体里面储存着两个栈就可以了，一个用来入数据一个用来出数据ST pushst;ST popst;} MyQueue;我们完成栈和队列的互相实现，我们对栈和队列的理解就加深了一点。后面也会在带来一些关于队列和栈的题目，从而进一步加深。
C语言-用栈实现队列
梦中破的博客
11-13 2365
用栈实现队列 栈是先进后出的数据结构，队列是先进先出的数据结构，所以当往队列中插入数据时，可以直接入栈。只是队列中先插入的在队首，队列中先插入的在栈底。 弹出队首的数据，实际就是删掉栈底的数据，直接删除不了，可以利用另一个辅助栈，将当前栈中数据全部依次弹出，并push到辅助栈中，这时当前栈的栈底元素就变成了辅助栈的栈顶元素，直接pop掉辅助栈的栈顶元素就行。 队列从队首到队尾的元素始终是辅助栈栈顶到栈尾+当前栈栈底到栈尾。辅助栈栈顶对应着队列队首，这就说明当辅助栈不为空时，队列的pop,可以直接对辅助栈p
C语言 用栈实现队列
qq_39121641的博客
05-10 261
typedef struct { int* stk; int stkSize; int stkCapacity; } Stack; Stack* stackCreate(int cpacity) { Stack* ret = malloc(sizeof(Stack)); ret->stk = malloc(sizeof(int) * cpacity); ret->stkSize = 0; ret->stkCapacity = cpa
C语言用栈实现队列(数据结构)
weixin_62029250的博客
12-01 1792
1.首先需要两个栈来模拟队列的出队和入队 2.假设入队1 2 3 4 ,如果要出队则不能直接出栈.需要进行数据的搬移: 先把s1的数据全部放入s2中,然后再在s2出栈->整个队列出队: 3.如果再要入队则将入队元素放入s1,若要出队则出栈s2元素,若s2为空则继续搬移s1的元素到s2即可. 4.总结:入队:s1 出队:s2 5.代码如下: typedef int Datatype; typedef struct stack { Datatype* arr; ..
栈和队列的应用实现 进制间的相互转换 C++
11-03
栈和队列的应用实现 进制间的相互转换 C++
数据结构-栈和队列
theglasssky的博客
12-11 995
关于栈和队列的基本操作方式
实验三 栈和队列的基本操作实现及其应用
LJing_T的博客
10-16 2367
一、实验目的 1、   熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。 2、      学会使用栈和队列解决实际问题。 二、实验内容 1、自己确定结点的具体数据类型和问题规模： 分别建立一个顺序栈和链栈，实现栈的压栈和出栈操作。 分别建立一个顺序队列和链队列，实现队列的入队和出队操作。 2、设计算法并写出代码，实现一个十将二进制转换成2进制数。
C语言栈和队列代码实现
08-08
包含内容：栈、队列、循环队列的数组实现方式和链表实现方式
C语言实现栈与队列
05-17
用C实现的栈与队列，可以加载使用。详见博文http://blog.csdn.net/pirateleo/article/details/7574598 共包含5个文件
C语言栈和队列的实现
k666499436的博客
05-28 5028
详细讲解栈与队列的定义和特性，用C语言分别实现顺序栈、链栈、顺序(循环)队列、链队列，已经顺序存储与链式存储的区别
使用栈实现队列——基于C语言
qq_38705421的博客
08-13 247
今天使用之前实现的栈实现队列。 下面是Main.c文件： #include "StackToQueue.h" #include <stdio.h> int main() { StackToQueue* queue = StackToQueueCreate(); if(queue != NULL) { int i, len = -1, data = -1; for(i = 0; i < 100; i++) { StackToQueueEnqueue(que
C++用栈实现队列
weixin_42326997的博客
11-05 464
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（push、pop、peek、empty）： 实现 MyQueue 类： void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false 说明： 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和
用栈模拟实现队列(c语言版)
@初阶牛的博客
06-10 995
力扣题:用栈实现队列(c语言版)
C语言——栈与队列的实现
weixin_40203143的博客
12-28 3037
栈与队列都是受限的线性表，均可以通过顺序表（数组）和链表两种方式得到实现。只不过栈是FILO，队列是FIFO，即栈和队列在出和入的方式上有所不同。而通过数组和链表实现的区别，即为数组与链表本身的区别：数组的存储空间是连续的，不可动态扩展；链表的存储空间是不连续的，可以动态扩展。下面具体来说。 一、栈的实现： 栈有栈底和栈顶，栈底是固定的，栈顶指向栈最顶上的第一个数据；数据的入栈和出栈只能在栈顶...
利用栈实现队列(C语言实现)
。烊了
06-19 3454
在上一篇优化后队列的实现(C语言实现) 中，虽然我们对队列的时间复杂度进行了优化，但是却让代码的可读性变差了，代码显得略微臃肿（当然，这些话你看看就好，主要是为了奉承这篇博文的）。 这里主要实现的是：利用栈来实现队列 基本思路： 1，创建两个栈 2，两个栈合并起来组装成一个队列，分别取名为instack,outstack，用于进队列，出队列 3，比如有1,2,3,4,5 需要进入队列，先将这一串数压入instack栈中，假设压入顺序为1,2,3,4,5（1为栈底），再将instack中的数据移入outst
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值