用栈实现队列（C语言实现）

题目描述

 

思路

本题和用队列实现栈的方法相同，底层用栈实现，栈有一个出入口，队列有两个，因此需要有两个栈分别实现队头和队尾的功能。

解题方法

第一步：实现栈 第二步：创建两个栈 第三步：分别实现接口

 

 

 代码实现

//实现栈
typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* _next;
    QDataType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* _head;
	QueueNode* _tail;
	
}Queue;
//初始化和销毁数据
void QueueInit (Queue*pq);
void QueueDestory (Queue*pq);
//入队列
void QueuePush(Queue*pq,QDataType x);
//出队列
void QueuePop(Queue*pq);
//获取头和尾的数据
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);

//返回1是空，返回0是非空
int QueueEmpty(Queue* pq);
//获取队列数据个数
int QueueSize(Queue* pq);

//初始化和销毁数据
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->_head = NULL;
	pq->_tail = NULL;

}
void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->_head;

	while (cur)
	{
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}

	pq->_head = pq->_tail = NULL;
}
//入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("内存不足\n");
		exit(-1);
	}

	newnode->data = x;
	newnode->_next = NULL;

	if (pq->_head == NULL)
	{
		pq->_head = newnode;
		pq->_tail = newnode;
	}
	else
	{
		pq->_tail->_next = newnode;
		pq->_tail = newnode;
	}
}
//出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->_head);
	if (pq->_head == NULL);
	{
		pq->_tail = NULL;
	}

	QueueNode* next = pq->_head->_next;
	free(pq->_head);
	pq->_head = next;
}
//获取头和尾的数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->_head);

	return pq->_head->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->_tail);

	return pq->_tail->data;
}
//返回1是空，返回0是非空
int QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->_head == NULL ? 1 : 0;
}
//获取队列数据个数
int QueueSize(Queue* pq)
{
	assert(pq);

	QueueNode* cur = pq->_head;

	int size = 0;
	while (cur)
	{
		cur = cur->_next;
		size++;
	}

	return size;
}

//正式解题
typedef struct {
//定义两个队列
    Queue _q1;
    Queue _q2;
} MyStack;

//初始化数据
MyStack* myStackCreate() {
    MyStack* st=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&st->_q1);
    QueueInit(&st->_q2);

    return st;
}
//将元素 x 压入栈顶
void myStackPush(MyStack* obj, int x) {
    //数据可以进入任何一个队列
    if(!QueueEmpty(&obj->_q1))
    {
        QueuePush(&obj->_q1,x);
    }
    else
    {
        QueuePush(&obj->_q2,x);
    }
}
//移除并返回栈顶元素
int myStackPop(MyStack* 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 top=QueueFront(nonempty);
    QueuePop(nonempty);//弹出最后的元素

  return top;
}
//返回栈顶元素
int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->_q1))
    {
        return QueueBack(&obj->_q1);
    }
    else //if(!QueueEmpty(&obj->_q2))
    {
        return QueueBack(&obj->_q2);
    }

}
//如果栈是空的，返回 true ；否则，返回 false 
bool myStackEmpty(MyStack* obj) {
   return QueueEmpty(&obj->_q1)&&QueueEmpty(&obj->_q2);
}

void myStackFree(MyStack* obj) {
    

}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/