【LeetCode】《动图演示》 225. 用队列实现栈和232. 用栈实现队列

用队列实现栈题目链接
用栈实现队列题目链接

1. 用队列实现栈

题目链接
思路：
一个队列放数据，一个队列为空（为了导队列数据），每次删除的时候交换两个队列的功能。
入栈功能：只往非空队列入数据，第一次入数据，随便入哪个队列，因为都是空队列

出栈功能：有数据的队列持续导入到空队列（取队头数据导入，出队删除本身的数据），直到最后一个数据，再将其输出后删除，这样实现了后进先出，此时就完成了刚才交换两个列队功能

取栈顶数据：有数据的队列最后一个数据就是栈顶，通过队列的特性，直接返回队尾数据即可

栈是否为空：两个队列为空，就返回true，不是就返回false

销毁：除了防止内存泄漏，我们需要把开辟了空间的地方都还回内存中，先free里层结构，在free外层结构

这里说明代码这个部分

修改结构体成员，需要传地址，运算符的优先级是先->，后&
所以是先找到结构体里面的成员变量，在取里面它的地址，就可以通过函数修改

2. 用栈实现队列

题目链接
思路：
一个栈用来入数据（pushST），一个栈用来出数据（popST），popST为空，就让pushST导数据进来。

入队：往专门用来入数据的栈（pushST），插入数据

出栈：popST没有数据就让pushST把数据导出来（出栈），所以先进去的数据会在pushST栈的栈顶，直接出栈就实现了先进先出

获取队头数据：popST的栈顶就是队头数据

销毁：和上一题一样，先销毁里层结构，在销毁外层结构，否则内存泄漏

注意只有在popST为空时候才能导数据，插入数据也只能在pushST，不然顺序就会被打乱

3. 队列实现栈源代码：

typedef int QDataType;

// 定义队列的单个节点
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;

// 定义队列
// 队列里面有头和尾结点，头和尾结点的类型是单个节点的结构
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

// 初始化
void QueueInit(Queue* pq);

// 判断队列是否为空
bool QueueEmpty(Queue* pq);

// 入队
void QueuePush(Queue* pq, QDataType x);

// 出队
void QueuePop(Queue* pq);

// 获取队头数据
QDataType QueueFront(Queue* pq);

// 获取队尾数据
QDataType QueueBack(Queue* pq);

// 获取队列数据个数
int QueueSize(Queue* pq);

// 销毁
void QueueDestroy(Queue* pq);


// 初始化
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
}

// 判断队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

// 入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	// 创建新节点
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	assert(newNode);
	newNode->data = x;
	newNode->next = NULL;

	// 插入数据分两种情况
	// 1. 队列为空：头和尾赋值为新节点
	// 2. 队列不为空：直接尾插，在更新尾结点
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newNode;
	}
	else
	{	
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
}

// 出队
void QueuePop(Queue* pq)
{
	assert(pq);
	// 空队列不能删除
	assert(!QueueEmpty(pq));
	
	// 头删
	QueueNode* headNext = pq->head->next;
	free(pq->head);
	pq->head = headNext;
	
	// 头为空表示队列空了，因为上面的步骤只把头给置空，尾没有，tail就是野指针了
	if (pq->head == NULL)
		pq->tail = NULL;
	
}


// 获取队头数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	// 空队列不能获取数据
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

// 获取队尾数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	// 空队列不能获取数据
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

// 获取队列数据个数
int QueueSize(Queue* pq)
{
	assert(pq);
	
	int size = 0;
	QueueNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

// 销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

	
MyStack* myStackCreate() {
	// 通过申请空间或全局、静态变量就不会野指针
	// 经典野指针：
	// MyStack* st;
	// return &st;
    MyStack* st = (MyStack*)malloc(sizeof(MyStack));
	// 修改结构体成员，需要传地址，运算符的优先级是先->，在&
	// 所以是先找到结构体里面的成员变量，在取里面它的地址，就可以通过函数修改
    QueueInit(&st->q1);
    QueueInit(&st->q2);

    return st;
}

void myStackPush(MyStack* obj, int x) {
    // 向非空的队列插入数据
	if (!QueueEmpty(&obj->q1))
        QueuePush(&obj->q1, x);
	else
		QueuePush(&obj->q2, x);
}

int myStackPop(MyStack* obj) {
	// 确定空队列和非空队列
    MyStack* emptyQ = &obj->q1;
    MyStack* noemptyQ = &obj->q2;
    if (QueueEmpty(noemptyQ))
    {
        emptyQ = &obj->q2;
        noemptyQ = &obj->q1;
    }

    // 非空队列除最后一个数据以外，其他数据全部导到空队列
    while (QueueSize(noemptyQ) > 1)
    {
        QueuePush(emptyQ, QueueFront(noemptyQ));
        QueuePop(noemptyQ);
    }

    // 非空队列的最后一个数据就是栈顶，所以就出栈
    int top = QueueFront(noemptyQ);
    QueuePop(noemptyQ);
    return top;



		
}

int myStackTop(MyStack* obj) {
    // 非空队列的最后一个数据就是栈顶，取最后一个数据就是top
	if (!QueueEmpty(&obj->q1))
		return QueueBack(&obj->q1);
	else
		return QueueBack(&obj->q2);
 
}

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

void myStackFree(MyStack* obj) {
    // 先销毁里层
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    
    // 后销毁外层
    free(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);
*/

4. 队列实现栈源代码：

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;	// 数组地址
	int top;		// 数据个数
	int capacity;	// 容量
}Stack;

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

// 栈为空判断
bool StackEmpty(Stack* ps);

// 入栈
void StackPush(Stack* ps, STDataType x);

// 出栈
void StackPop(Stack* ps);

// 取栈顶元素
STDataType StackTop(Stack* ps);

// 栈的大小
int StackSize(Stack* ps);

// 销毁
void StackDestroy(Stack* ps);

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

	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

// 栈为空判断
bool StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

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

	// 栈容量检查
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newCapacity * sizeof(STDataType));
		assert(tmp);
		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	// 插入数据
	ps->a[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	// 空栈不能出
	assert(!StackEmpty(ps));

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

// 销毁
void StackDestroy(Stack* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}




typedef struct {
    Stack pushST;
    Stack popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&q->pushST);
    StackInit(&q->popST);
    
    return q;
}

void myQueuePush(MyQueue* obj, int x) {
    // 只往pushST插入数据
    StackPush(&obj->pushST, x);
}


// 把pushST的数据导入popST
void StackDataMove(MyQueue* obj)
{
    while (StackSize(&obj->pushST))
    {
        StackPush(&obj->popST, StackTop(&obj->pushST));
        StackPop(&obj->pushST);
    }  
}

int myQueuePop(MyQueue* obj) {
    // popST为空，就把pushST数据全部导入进来
    if (StackEmpty(&obj->popST))
        StackDataMove(obj);

    // 出队
    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
        return front;
    
}

int myQueuePeek(MyQueue* obj) {
    // popST为空，就把pushST数据全部导入进来
    if (StackEmpty(&obj->popST))
        StackDataMove(obj);

    int front = StackTop(&obj->popST);
    return front;
}

bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    // 先销毁里层
    StackDestroy(&obj->pushST);
    StackDestroy(&obj->popST);

    // 后销毁外层
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/