LeetCode - 232.用栈实现队列 && 225.用队列模拟实现栈 （C语言，配图）

目录

232.用栈实现队列

225.用队列模拟实现栈  

---

    注：本文是基于C语言实现的代码，所以栈和队列是在力扣上制造实现的，如果你使用C++等语言，可以忽略前面相当大部分的代码。

    在栈模拟实现栈和队列之前，我们先来复习一下栈和队列的定义，你必须对栈和队列有详细的了解，并模拟实现过，否则，一下实现对你的理解可能较为困难。

        栈：只允许一端（栈顶）进行插入和删除操作。

        队列：只允许一端进行插入，令一端进行删除操作。

数据结构入门————栈和队列（C语言/零基础/小白/新手+模拟实现+例题讲解）-CSDN博客

232.用栈实现队列

232. 用栈实现队列 - 力扣（LeetCode）

        对于队列，我们使用链式结构，进行尾插和头插，如果我们只使用一个栈来说，这是非常困难的，那我们就转变一下思路，使用两个栈来实现。这里我们叫一个为emptys（空栈）,另一个叫nonemptys（非空栈）。

        当我们想要插入时直接尾插到nonemptys（如果是第一次插入，无所谓emptys，nonemptys）。

        想要删除时，就将nonemptys栈的第二个及以后的数据插入到emptys中，然后将nonemptys中第一个数据删除，最后再将emptysz栈数据导入nonemptys中。

        

注：因为C语言，并没有对顺序栈的实现，所以我们要自己定义一个顺序栈结构。

typedef int STDataType;

typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;

//初始化
void StackInit(ST* pst)
{
    assert(pst);
    pst->a = NULL;
    pst->top = 0;
    pst->capacity = 0;
}

//销毁
void StackDestroy(ST* pst)
{
    assert(pst);
    free(pst->a);
    pst->a = NULL;
    pst->top = 0;
    pst->capacity = 0;
}

//插入
void StackPush(ST* pst, STDataType x)
{
    assert(pst);
    if (pst->top == pst->capacity)
    {
        int newcapacity = (pst->capacity == 0) ? 4 : pst->capacity * 2;
        STDataType* temp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
        if (temp == NULL)
        {
            perror("realloc");
            return;
        }
        pst->a = temp;
        pst->capacity = newcapacity;
    }
    pst->a[pst->top] = x;
    pst->top++;
}

//删除
void StackPop(ST* pst)
{
    assert(pst);
    assert(pst->top > 0);
    pst->top--;
}

//返回top值
STDataType StackTop(ST* pst)
{
    assert(pst);
    assert(pst->top > 0);
    return pst->a[pst->top - 1];
}

//判断是否为空
bool StackEmpty(ST* pst)
{
    assert(pst);
    return pst->top == 0;
}

//元素个数
int StackSize(ST* pst)
{
    assert(pst);
    return pst->top;
}


typedef struct {
    ST st1;
    ST st2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pq = (MyQueue*)malloc(sizeof(MyQueue));
    if (pq == NULL)
    {
        perror("malloc");
        return NULL;
    }
    StackInit(&pq->st1);
    StackInit(&pq->st2);
    return pq;
}

void myQueuePush(MyQueue* obj, int x) {
    if (!StackEmpty(&obj->st1))
    {
        StackPush(&obj->st1, x);
    }
    else
    {
        StackPush(&obj->st2, x);
    }
}

int myQueuePop(MyQueue* obj) {
    ST* emptys = &obj->st1;
    ST* nonemptys = &obj->st2;
    if (!StackEmpty(&obj->st1))
    {
        emptys = &obj->st2;
        nonemptys = &obj->st1;
    }
    while (StackSize(nonemptys) > 1)
    {
        StackPush(emptys, StackTop(nonemptys));
        StackPop(nonemptys);
    }
    int first = StackTop(nonemptys);
    StackPop(nonemptys);
     while (StackSize(emptys) > 0)
    {
        StackPush(nonemptys, StackTop(emptys));
        StackPop(emptys);
    }
    return first;
}

int myQueuePeek(MyQueue* obj) {
    ST* emptys = &obj->st1;
    ST* nonemptys = &obj->st2;
    if (!StackEmpty(&obj->st1))
    {
        emptys = &obj->st2;
        nonemptys = &obj->st1;
    }
    while (StackSize(nonemptys) > 1)
    {
        StackPush(emptys, StackTop(nonemptys));
        StackPop(nonemptys);
    }
    int first = StackTop(nonemptys);
    StackPush(emptys, StackTop(nonemptys));
    StackPop(nonemptys);
    while (StackSize(emptys) > 0)
    {
        StackPush(nonemptys, StackTop(emptys));
        StackPop(emptys);
    }
    return first;
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->st1) && StackEmpty(&obj->st2);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->st1);
    StackDestroy(&obj->st2);
    free(obj);
}

225.用队列模拟实现栈  

225. 用队列实现栈 - 力扣（LeetCode）

        对于队列，我们也可以使用同样的思路，使用两个栈将数据来回导入导出，来实现队列的一端进行插入，另一端进行删除操作的定义。这里我们叫一个为emptyq（空队列）,另一个叫nonemptys（非空队列）。

        当我们想要插入时直接尾插到nonemptyq（如果是第一次插入，无所谓emptyq，nonemptyq）。

        当我们想要删除时，将nonemptyq中第二个及以上的数据导入emptyq中，再将nonemptyq中的第一个数据删除。

注：因为C语言，并没有对链式队列的实现，所以我们要自己定义一个链式队列。

typedef int QNDataType;

typedef struct QueueNode
{
	QNDataType data;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;


//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	pq->ptail = NULL;
	pq->size = 0;
}

//插入
void QueuePush(Queue* pq, QNDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("mallloc");
		return;
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

//删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	if (pq->phead->next == NULL)
	{
		pq->phead = pq->phead->next;
		pq->ptail = NULL;
	}
	else
	{
		QNode* del = pq->phead;
		pq->phead = pq->phead->next;
		free(del);
		del = NULL;
	}
	pq->size--;
}

//获取头部元素
QNDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->data;
}

//获取尾部元素
QNDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->ptail->data;
}

//元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	int size = 0;
	while (cur != NULL)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

//判断是否为空 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL;
}

//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	while(!QueueEmpty(pq))
	{
		QueuePop(pq);
	}
	pq->size = 0;
}
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


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

		return pst;
}

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->q1))
		{
			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 obj->q1.ptail->data;
		}
		else{
			return obj->q2.ptail->data;
		}
}

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

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

        如果你看到这里，如果对其中代码有疑问，或者有更好的实现，欢迎大家在评论区讨论交流，方便大家更好的学习。