两个队列实现一个栈

最新推荐文章于 2024-08-29 21:14:24 发布
最新推荐文章于 2024-08-29 21:14:24 发布
阅读量268 收藏
点赞数
分类专栏： 栈和队列的应用 数据结构 c语言 文章标签： 队列 栈 两个队列实现一个栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhao_miao/article/details/82083430
版权

  关于两个栈实现一个队列的问题：两个栈实现一个队列
这篇博客我们讲两个队列实现一个栈。

栈：后进先出
队列：先进先出

分析：
  入栈：
   哪一个队列有元素便入哪一个队列。
  出栈：
这里写图片描述
  返回栈顶元素：

这里写图片描述
  栈的大小
  两个队列的大小之和。
  栈判空
  两个队列均为空。

代码实现：

  设置一个栈由两个队列组成。队列为不带头结点的单链表，有两个指针，分别指向队头和队尾。

#define DataType int
typedef struct QNode
{
    DataType data;
    struct QNode *next;
}QNode;
typedef struct queue
{
    QNode *front;
    QNode *rear;
}Queue;
typedef struct Stack
{
    Queue q1;
    Queue q2;
}stack;

初始化栈
  初始化栈即初始化两个队列。

//初始化队列
void InitQueue(Queue *queue)
{
    assert(queue);
    queue->front = queue->rear = NULL;
}
//初始化栈
void InitStack(stack *s)
{
    assert(s);
    InitQueue(&s->q1);
    InitQueue(&s->q2);
}

压栈
  两个队列实现一个栈的方法必有一个队列为空，压栈时两个队列哪一个不为空，便往哪一个队列里面插元素，插元素时采用尾插法。

QNode *BuyNode(int d)
{
    QNode *node = (QNode*)malloc(sizeof(QNode));
    if (node == NULL)
    {
        printf("空间开辟失败！\n");
        return NULL;
    }
    node->data = d;
    node->next = NULL;
    return node; 
}
//压队列
void PushQueue(Queue *queue,DataType d)
{
    assert(queue);
    QNode *newnode = NULL;
    //队列为空
    if (queue->front == NULL)
    {
        queue->front = queue->rear = BuyNode(d);
    }
    //队列不为空
    else
    {
        //尾插
        newnode = BuyNode(d);
        queue->rear->next = newnode;
        queue->rear = newnode;
    }
} 
//队列为空
int EmptyQueue(Queue *queue)
{
    assert(queue);
    return queue->front == NULL;
}
//入栈
void PushStack(stack *s, DataType d)
{
    assert(s);
    if (!EmptyQueue(&s->q2))
    {
        //压入队列2
        PushQueue(&s->q2, d);
    }
    else
    {
        //压入队列1
        PushQueue(&s->q1, d);
    }
}

出栈
  哪一个队列不为空，将此队列的n-1个元素移入另一个队列，然后出队列即出栈。出队列采用头删法。

//头删
void Deletehead(Queue *queue)
{
    QNode *cur = NULL;
    if (queue->front == NULL)
    {
        printf("队列为空，无法删除!\n");
        return;
    }
    else if (queue->front == queue->rear)
    {
        free(queue->front);
        queue->front = queue->rear = NULL;
    }
    else
    {
        cur = queue->front;
        queue->front = queue->front->next;
        free(cur);
        cur = NULL;
    }
}
//出队列
void PopQueue(Queue *queue)
{
    QNode *cur = NULL;
    assert(queue);
    //tou删
    Deletehead(queue);
}

//返回队头元素
DataType QueueFront(Queue *queue)
{
    assert(queue);
    return queue->front->data;
}
//队列为空
int EmptyQueue(Queue *queue)
{
    assert(queue);
    return queue->front == NULL;
}
//栈为空
int EmptyStack(stack *s)
{
    assert(s);
    return EmptyQueue(&s->q1) && EmptyQueue(&s->q2);
}
//出栈
void PopStack(stack *s)
{
    assert(s);
    if (EmptyStack(s))
    {
        printf("栈为空！\n");
        return;
    }
    else if (!EmptyQueue(&s->q1))
    {
        while (QueueSize(&s->q1)>1)
        {
            PushQueue(&s->q2, QueueFront(&s->q1));
            PopQueue(&s->q1);
        }
        PopQueue(&s->q1);
    }
    else
    {
        while (QueueSize(&s->q2)>1)
        {
            PushQueue(&s->q1, QueueFront(&s->q2));
            PopQueue(&s->q2);
        }
        PopQueue(&s->q2);
    }
}

返回栈顶元素
  哪一个队列不空，返回它rear指针指向的数据返回。

//返回队尾元素
DataType QueueBack(Queue *queue)
{
    assert(queue);
    return queue->rear->data;
}
//栈顶元素
DataType TopStack(stack *s)
{
    if (EmptyStack(s))
    {
        printf("栈为空！\n");
        return -1;
    }
    else if (!EmptyQueue(&s->q1))
    {
        //返回队尾元素
        return QueueBack(&s->q1);
    }
    else
    {
        //返回队尾元素
        return QueueBack(&s->q2);
    }
}

栈的大小
  即两个队列的大小和。

//队列的大小
int QueueSize(Queue *queue)
{
    QNode *cur = NULL;
    int count = 0;
    assert(queue);
    cur = queue->front;
    while (cur)
    {
        count++;
        cur = cur->next;
    }
    return count;
}
//栈的大小
int SizeStack(stack *s)
{
    assert(s);
    return QueueSize(&s->q1) + QueueSize(&s->q2);
}
                                  整体代码：

.h文件


#include<stdlib.h>
#include<assert.h>
#include<stdio.h>


#define DataType int
typedef struct QNode
{
    DataType data;
    struct QNode *next;
}QNode;
typedef struct queue
{
    QNode *front;
    QNode *rear;
}Queue;


typedef struct Stack
{
    Queue q1;
    Queue q2;
}stack;

//初始化栈
void InitStack(stack *s);
//入栈
void PushStack(stack *s,DataType d);
//出栈
void PopStack(stack *s);
//栈顶元素
DataType TopStack(stack *s);
//队列的大小
int SizeStack(stack *s);

.c文件

#include"queue.h"


//初始化队列
void InitQueue(Queue *queue)
{
    assert(queue);
    queue->front = queue->rear = NULL;
}
//初始化栈
void InitStack(stack *s)
{
    assert(s);
    InitQueue(&s->q1);
    InitQueue(&s->q2);
}


QNode *BuyNode(int d)
{
    QNode *node = (QNode*)malloc(sizeof(QNode));
    if (node == NULL)
    {
        printf("空间开辟失败！\n");
        return NULL;
    }
    node->data = d;
    node->next = NULL;
    return node; 
}
//压队列
void PushQueue(Queue *queue,DataType d)
{
    assert(queue);
    QNode *newnode = NULL;
    //队列为空
    if (queue->front == NULL)
    {
        queue->front = queue->rear = BuyNode(d);
    }
    //队列不为空
    else
    {
        //尾插
        newnode = BuyNode(d);
        queue->rear->next = newnode;
        queue->rear = newnode;
    }
} 
//队列为空
int EmptyQueue(Queue *queue)
{
    assert(queue);
    return queue->front == NULL;
}
//入栈
void PushStack(stack *s, DataType d)
{
    assert(s);
    if (!EmptyQueue(&s->q2))
    {
        //压入队列2
        PushQueue(&s->q2, d);
    }
    else
    {
        //压入队列1
        PushQueue(&s->q1, d);
    }
}


//队列的大小
int QueueSize(Queue *queue)
{
    QNode *cur = NULL;
    int count = 0;
    assert(queue);
    cur = queue->front;
    while (cur)
    {
        count++;
        cur = cur->next;
    }
    return count;
}
//头删
void Deletehead(Queue *queue)
{
    QNode *cur = NULL;
    if (queue->front == NULL)
    {
        printf("队列为空，无法删除!\n");
        return;
    }
    else if (queue->front == queue->rear)
    {
        free(queue->front);
        queue->front = queue->rear = NULL;
    }
    else
    {
        cur = queue->front;
        queue->front = queue->front->next;
        free(cur);
        cur = NULL;
    }
}
//出队列
void PopQueue(Queue *queue)
{
    QNode *cur = NULL;
    assert(queue);
    //tou删
    Deletehead(queue);
}

//返回队头元素
DataType QueueFront(Queue *queue)
{
    assert(queue);
    return queue->front->data;
}
//栈为空
int EmptyStack(stack *s)
{
    assert(s);
    return EmptyQueue(&s->q1) && EmptyQueue(&s->q2);
}
//出栈
void PopStack(stack *s)
{
    assert(s);
    if (EmptyStack(s))
    {
        printf("栈为空！\n");
        return;
    }
    else if (!EmptyQueue(&s->q1))
    {
        while (QueueSize(&s->q1)>1)
        {
            PushQueue(&s->q2, QueueFront(&s->q1));
            PopQueue(&s->q1);
        }
        PopQueue(&s->q1);
    }
    else
    {
        while (QueueSize(&s->q2)>1)
        {
            PushQueue(&s->q1, QueueFront(&s->q2));
            PopQueue(&s->q2);
        }
        PopQueue(&s->q2);
    }
}


//栈的大小
int SizeStack(stack *s)
{
    assert(s);
    return QueueSize(&s->q1) + QueueSize(&s->q2);
}


//返回队尾元素
DataType QueueBack(Queue *queue)
{
    assert(queue);
    return queue->rear->data;
}
//栈顶元素
DataType TopStack(stack *s)
{
    if (EmptyStack(s))
    {
        printf("栈为空！\n");
        return -1;
    }
    else if (!EmptyQueue(&s->q1))
    {
        //返回队尾元素
        return QueueBack(&s->q1);
    }
    else
    {
        //返回队尾元素
        return QueueBack(&s->q2);
    }
}

测试文件：

#include"queue.h"

void Testqueue()
{
    stack s;
    //初始化栈
    InitStack(&s);
    //入栈
    PushStack(&s, 1);
    PushStack(&s, 2);
    PushStack(&s, 3);
    PushStack(&s, 4);
    PushStack(&s, 5);
    PushStack(&s, 6);
    printf("Top=%d\n", TopStack(&s));
    printf("size=%d\n", SizeStack(&s));

    //出栈
    PopStack(&s);
    printf("Top=%d\n", TopStack(&s));
    printf("size=%d\n", SizeStack(&s));
    PushStack(&s, 3);
    PushStack(&s, 4);

    printf("Top=%d\n", TopStack(&s));
    printf("size=%d\n", SizeStack(&s));
}
int main()
{
    Testqueue();
    system("pause");
    return 0;
}

这里写图片描述
运行结果：
这里写图片描述

zhao_miao
关注
专栏目录
用两个队列实现一个栈
hang_1994的博客
10-25 3071
我们通过一系列栈的压入和弹出操作来分析用两个队列模拟一个栈的过程。如图(a)所示，我们先往栈内压入一个元素A。由于两个队列现在都是空的，我们可以选择把A插入两个队列的任意一个。不妨插入queue1。接下来继续往栈内压入B、C两个元素，我们把它们都插入queue1。这个时候queue1包含3个元素A、B和C，其中A位于队列的头部，C位于队列的尾部。 　　现在我们考虑从栈内弹出一个元素。根据栈的后入...
如何用两个队列实现一个栈及其性能分析
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
03-31 848
在计算机科学中，栈（Stack）和队列（Queue）是两种常见的数据结构，它们各自有着独特的操作方式和应用场景。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。在某些特定场景下，我们可能需要使用一种数据结构来实现另一种数据结构的功能。本文将详细探讨如何使用两个队列来实现一个栈，并分析相关栈操作的运行时间。
栈和队列的实现
最新发布
m0_63703622的博客
08-29 792
栈和队列的知识点及实现
使用两个队列实现一个栈
热门推荐
jiange_zh的博客
01-25 1万+
队列是先进先出，而栈是先进后出；考虑到我们取栈顶元素的便利性，我们在实现时使得栈顶等于队列头；由于栈的pop弹出栈顶元素，而队列的pop也是弹出栈顶元素，所以我们需要特别处理的是插入操作。由于往栈中添加元素相当于往队列头添加元素，因此我们需要在两个队列中进行元素的转移，比较简单的实现是：1.q1和q2在任一时刻至少有一个为空，即如果有元素，所以元素只在同一个队列中。 2.当有元素需要插入时，将插入
用队列实现栈
程序员小祝的博客
02-25 495
题目： 用队列实现栈 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。 实现 MyStack 类： void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 int top() 返回栈顶元素。 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。 解析：（两个队列） 为了满足栈的特性，即最后入栈的元素最先出栈，在使用队列实现栈时，应满足队列前端的元素是
JS实现利用两个队列表示一个栈的方法
11-27
通过巧妙地操作这两个队列，我们可以实现栈的基本操作，如push（入栈）和pop（出栈）。 首先，我们需要理解栈和队列的基本操作。栈的操作包括： 1. push：将元素添加到栈顶。 2. pop：移除栈顶元素并返回其值。 3. ...
用两个队列实现一个栈 c++
03-26
6. 使用两个队列实现的栈，其空间复杂度为O(n)，其中n为栈中元素的个数。 以下是使用C语言实现的代码： ``` #include #include typedef struct Queue { int* data; int front; int rear; } Queue; typedef ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值