两个队列实现一个栈-优快云博客

本文链接：https://blog.youkuaiyun.com/zhao_miao/article/details/82083430

该博客主要讲解两个队列实现一个栈的问题。介绍了栈后进先出、队列先进先出的特点，分析了入栈、出栈、返回栈顶元素、栈大小及判空的方法，还给出了代码实现，包括栈的初始化、压栈、出栈等操作，最后提及了相关文件和运行结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

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

栈的大小
两个队列的大小之和。
栈判空
两个队列均为空。

代码实现：

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

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

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