【C】用队列实现栈（力扣225）和用栈实现队列（力扣232）

先搞面包再谈爱

已于 2024-02-24 11:11:31 修改

阅读量91

点赞数 1

分类专栏：基本数据结构文章标签： c语言 leetcode 算法

于 2023-04-09 21:02:21 首次发布

本文链接：https://blog.csdn.net/m0_62782700/article/details/130047096

版权

基本数据结构专栏收录该内容

13 篇文章 0 订阅

订阅专栏

栈和队列的相互实现

本篇博客由CSDN@先搞面包再谈爱原创，转载请标注清楚，请勿抄袭。

用队列实现栈

首先，栈的基本功能有，入栈，出栈，判空，获得栈顶元素。

基本思想

用两个队列实现一个栈。

初始化时，只需要将两个队列初始化。
判断栈是否为空，当两个队列都为空栈就为空。
入栈的时候，将元素往不为空的队列中入（如果两个都为空，就随便入一个）。
出栈的时候，将不为空的队列中的元素导出到空队列中，不为空的队列中只留一个元素，最后将这个元素pop掉。（如果栈为空就返回false）
获得栈顶元素，只需要返回不为空的队列的队尾元素。（如果栈为空就返回false）
释放时，只需要将两个队列释放。

图解

入栈：
在这里插入图片描述
出栈：

这里队列的话，如果是刚学数据结构，就需要先自己实现一下队列，然后才能实现上面的步骤。这里我就先将队列的代码给上去：

队列的实现：

// 链式结构：表示队列 

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

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

// 初始化队列 
void QueueInit(Queue* q)
{
	q->_front = NULL;
	q->_rear = NULL;
}

QNode* BuyNode(QDataType x)
{
	QNode* node = (QNode*)malloc(sizeof(QNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	node->_data = x;
	node->_next = NULL;

	return node;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* node = BuyNode(data);

	if (q->_front == q->_rear && q->_front == NULL)
	{
		q->_front = q->_rear = node;
	}
	else
	{
		q->_rear->_next = node;
		q->_rear = node;
	}

}
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	QNode* next = q->_front->_next;
	if (q->_front == q->_rear)
		q->_rear = NULL;
	free(q->_front);
	q->_front = next;
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_front->_data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->_rear->_data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	if (QueueEmpty(q))
		return 0;
	int count = 0;
	QNode* cur = q->_front;
	while (cur != q->_rear)
	{
		count++;
		cur = cur->_next;
	}
	count++;

	return count;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	return q->_front == NULL;
}
// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);

	if (q->_front == NULL)
		return;

	QNode* cur = q->_front;
	QNode* next = cur->_next;

	while (cur && cur != q->_rear)
	{
		free(cur);
		cur = next;
		next = cur->_next;
	}
	free(cur);
}

本题代码实现：

//如果是用C语言的话，前面要加上队列的代码
//如果是C++的话，直接用库就行
typedef struct 
{
    Queue q1;
    Queue q2;
} MyStack;

bool myStackEmpty(MyStack* obj);

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

    return s;
}

void myStackPush(MyStack* obj, int x)
{   
    if(myStackEmpty(obj))
    {
        QueuePush(&obj->q1, x);
    }
    else
    {
        if(QueueEmpty(&obj->q1))
            QueuePush(&obj->q2, x);
        else
            QueuePush(&obj->q1, x);
    }
}

int myStackPop(MyStack* obj)
{
    if(myStackEmpty(obj))
        return -1;

    Queue* EmptyQueue = &obj->q1;
    Queue* NotEmptyQueue = &obj->q2;

    if(QueueEmpty(&obj->q2))
    {
        EmptyQueue = &obj->q2;
        NotEmptyQueue = &obj->q1;
    }

    while(QueueSize(NotEmptyQueue) > 1)
    {
        QDataType tmp = QueueFront(NotEmptyQueue);
        QueuePop(NotEmptyQueue);
        QueuePush(EmptyQueue, tmp);
    }
    
    QDataType tmp = QueueFront(NotEmptyQueue);
    QueuePop(NotEmptyQueue);

    return tmp;
}

int myStackTop(MyStack* obj)
{
    if(myStackEmpty(obj))
        return -1;
    
    Queue* EmptyQueue = &obj->q1;
    Queue* NotEmptyQueue = &obj->q2;

    if(QueueEmpty(&obj->q2))
    {
        EmptyQueue = &obj->q2;
        NotEmptyQueue = &obj->q1;
    }

    return QueueBack(NotEmptyQueue);
}

bool myStackEmpty(MyStack* obj)
{
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj)
{
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

用栈实现队列

队列的基本功能也是，入队，出队，判空，队头

基本思想

也是用两个栈实现队列。
但是一个栈是专门用来push（pushStack），一个栈是专门用来pop（popStack）。

初始化时，只需要将两个栈初始化。
入队的时候，直接入push的栈。
判断队列是否为空，当两个栈都为空队列就为空。
出队的时候，先判断整个队列是否为空，若为空，则返回false，若不为空，则先判断pop栈是否为空，若为空则先将push栈的元素全部导入pop栈中，然后再出pop栈的栈顶。
获得队头元素，先判断整个队列是否为空，若为空，则返回false，若不为空，则先判断pop栈是否为空，若pop栈为空则先将push栈的元素全部导入pop栈中，然后返回pop栈的栈顶元素，若pop栈不为空则直接返回pop栈顶元素。
释放时，只需要将两个队列释放。

图解

入队：

出队：
以下两种情况也适用于返回队头元素

popStack为空的情况

popStack不为空的情况

同样，如果是数据结构初学者，也要先实现一下栈。
栈的一些基本功能的实现：

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);

	ps->_a = NULL;
	ps->_capacity = ps->_top =0;
}

void checkCapacity(Stack* ps)
{
	assert(ps);
	if (ps->_capacity == ps->_top)
	{
		int newCapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->_a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("malloc fail\n");
			exit(-1);
		}

		ps->_capacity = newCapacity;
		ps->_a = tmp;
	}
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	checkCapacity(ps);

	ps->_a[(ps->_top)++] = data;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->_top);

	ps->_top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));

	return ps->_a[ps->_top - 1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->_top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	return ps->_top == 0;
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->_a);
	ps->_capacity = ps->_top = 0;
}

本题代码实现

typedef struct
{
    Stack PushStack;
    Stack PopStack;
} MyQueue;

bool myQueueEmpty(MyQueue* obj);


void MoveStack(Stack* pushStack, Stack* popStack)
{
    while(!StackEmpty(pushStack))
    {
        STDataType tmp = StackTop(pushStack);
        StackPop(pushStack);
        StackPush(popStack, tmp);
    }
}

MyQueue* myQueueCreate()
{
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->PushStack);
    StackInit(&q->PopStack);

    return q;
}

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

int myQueuePop(MyQueue* obj) 
{
    if(myQueueEmpty(obj))
    {
        return -1;
    }


    if(StackEmpty(&obj->PopStack))
    {
        MoveStack(&obj->PushStack, &obj->PopStack);
    }
    
    STDataType tmp = StackTop(&obj->PopStack);
    StackPop(&obj->PopStack);
    return tmp;


}

int myQueuePeek(MyQueue* obj) 
{
    if(myQueueEmpty(obj))
    {
        return -1;
    }

    if(StackEmpty(&obj->PopStack))
    {
        MoveStack(&obj->PushStack, &obj->PopStack);
    }

    STDataType tmp = StackTop(&obj->PopStack);
    return tmp;

}

bool myQueueEmpty(MyQueue* obj) 
{
    return StackEmpty(&obj->PushStack) && StackEmpty(&obj->PopStack);
}

void myQueueFree(MyQueue* obj)
{
    StackDestroy(&obj->PushStack);
    StackDestroy(&obj->PopStack);
}