用队列实现栈（C语言）

题目：

分析

这道题要求我们使用两个队列实现一个栈，我们知道队列的性质是先进先出，而栈的性质是后进先出，这就要求我们不断变换两个队列以达到目的

在这个oj题中我们需要实现栈的压栈、出栈、获取栈顶元素、栈的判空四个操作，但是我们对这个栈进行操作，就要对两个队列进行操作，因此我们先需要实现队列的代码，我将完整队列的代码放在最后，有需要的可以看看

这是我对队列的大致定义

typedef int QDataType;

typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;

_front指针指向队列头部，_rear指针指向队列尾部，size用来储存有效数据个数

1.栈的定义和创建、销毁

先定义一个这样的栈

typedef struct {
    Queue que1;
    Queue que2;
} MyStack;

对这个栈中两个队列的初始化实际上就是对这个栈的初始化

MyStack* myStackCreate() {
    MyStack* tmp = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&tmp->que1);
    QueueInit(&tmp->que2);
    return tmp;
}

栈的销毁同理

void myStackFree(MyStack* obj) {
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);
    QueueDestroy(&obj->que1);
    free(obj);
}

注意：在往后的代码中，我会默认que1不是空的那一个队列，通过判空以及交换操作，保证每个函数的操作都是对que1进行的

2.压栈

压栈的操作相对简单，只需要在不是空的那个队列尾部插入数据

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(QueueEmpty(&obj->que1))
    {
        Swap(&obj->que1,&obj->que2);
    }

    QueuePush(&obj->que1,x);
}

3.出栈

出栈是这道题比较麻烦的一个地方，队列的性质让它只能从队列头部弹出数据，但是出栈操作需要让它从尾部弹出数据，两个地方未免矛盾

在上面我们默认que1是不为空的队列，所以我们就可以先获取有效元素个数，遍历que1，将que1中的元素压到que2中，保留que1的最后一个元素，如下图：

这时只需要保存que1的最后一个元素的值，并将它弹出，再将que1、que2指针进行交换（保证que1不是空队列），返回保存的元素值，我们就实现了出栈操作

int myStackPop(MyStack* obj) {
    assert(obj);
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);

    int n = QueueSize(&obj->que1);
    int i = 0;
    while(QueueSize(&obj->que1)>1) 
    {
        QueuePush(&obj->que2,QueueFront(&obj->que1));
        QueuePop(&obj->que1);
    }
    
    int n1 = QueueFront(&obj->que1);
    QueuePop(&obj->que1);

    Swap(&obj->que1,&obj->que2);
    return n1;
}

4.获取栈顶元素和判空

这两个操作不难，只需要用到我写的队列函数中的几个接口就能实现

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);

    int n = QueueBack(&obj->que1);
    return n;
}

bool myStackEmpty(MyStack* obj) {
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);

    return QueueEmpty(&obj->que1);
}

完整代码

我将队列函数的实现放在了前面，后面才是实现栈的代码

// 链式结构：表示队列 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* _next;
	QDataType _data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* _front;
	QNode* _rear;
	int size;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);
// 队尾入队列 
void QueuePush(Queue* q, QDataType data);
// 队头出队列 
void QueuePop(Queue* q);
// 获取队列头部元素 
QDataType QueueFront(Queue* q);
// 获取队列队尾元素 
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数 
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);
// 初始化队列 
void QueueInit(Queue* q)
{
	q->_front = NULL;
	q->_rear = NULL;
	q->size = 0;
}

//交换两变量地址
void Swap(Queue* q1,Queue* q2)
{
    Queue tmp =*q1;
    *q1 = *q2;
    *q2 = tmp; 
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* tmp = (QNode*)malloc(sizeof(QNode));
	if (tmp == NULL)
	{
		perror("malloc");
		return;
	}
	tmp->_data = data;
	tmp->_next = NULL;

	//判断是否为空
	if (q->_front == NULL)
	{
		q->_front = tmp;
		q->_rear = tmp;
	}
	else
	{
		q->_rear->_next = tmp;
		q->_rear = q->_rear->_next;
	}
	q->size++;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	QNode* tmp = q->_front;
	q->_front = q->_front->_next;
	free(tmp);
	tmp = NULL;
	q->size--;
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_front->_data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_rear->_data;
}

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	return q->size;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	if (q->_front == NULL)
		return 1;
	else
		return 0;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	Queue* cur = q;
	while (cur->_front)
	{
		QNode* tmp = cur->_front;
		cur->_front = cur->_front->_next;
		free(tmp);
	}
	q->_front = NULL;
	q->_rear = NULL;
	
}








//默认que1不为空指针
typedef struct {
    Queue que1;
    Queue que2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* tmp = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&tmp->que1);
    QueueInit(&tmp->que2);
    return tmp;
}

void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(QueueEmpty(&obj->que1))
    {
        Swap(&obj->que1,&obj->que2);
    }

    QueuePush(&obj->que1,x);
}

int myStackPop(MyStack* obj) {
    assert(obj);
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);

    int n = QueueSize(&obj->que1);
    int i = 0;
    while(QueueSize(&obj->que1)>1) 
    {
        QueuePush(&obj->que2,QueueFront(&obj->que1));
        QueuePop(&obj->que1);
    }
    
    int n1 = QueueFront(&obj->que1);
    QueuePop(&obj->que1);

    Swap(&obj->que1,&obj->que2);
    return n1;
}

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);

    int n = QueueBack(&obj->que1);
    return n;
}

bool myStackEmpty(MyStack* obj) {
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);

    return QueueEmpty(&obj->que1);
}

void myStackFree(MyStack* obj) {
    if(QueueEmpty(&obj->que1))
        Swap(&obj->que1,&obj->que2);
    QueueDestroy(&obj->que1);
    free(obj);
}

代码提交通过截图