栈与队列的互相实现(C)

目录

一.用栈实现队列

1.实现一个（可动态增长）数组栈

2.LeetCode232：用栈实现队列

 二.用队列实现栈

1.实现队列

2.LeetCode225.用队列实现栈

---

一.用栈实现队列

1.实现一个（可动态增长）数组栈

数据的结构定义和结构操作：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stack {
	STDataType* a;
	int top;
	int capacity;
}Stack;
//初始化
void StackInit(Stack* ps);
//入棧
void StackPush(Stack* ps, STDataType x);
//出棧
void StackPop(Stack* ps);
//销毁
void StackDestroy(Stack* ps);
//查看栈顶元素
STDataType StackTop(Stack* ps);
//查看栈元素个数
int StackSize(Stack* ps);
//判空操作
bool StackEmpty(Stack* ps);

具体操作实现：
 

//初始化
void StackInit(Stack* ps) {
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
//入棧
void StackPush(Stack* ps, STDataType x) {
	assert(ps);
	if (ps->top == ps->capacity) {
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType*new= (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapcity);
		if (new == NULL) {
			printf("realloc failed!");
			exit(-1);
		}
		ps->a = new;
		ps->capacity = newcapcity;
	}
	ps->a[ps->top] = x;
	ps->top++;

}//出棧
void StackPop(Stack* ps) {
	assert(ps);
	ps->top--;
	return ;
}
//销毁
void StackDestroy(Stack* ps) {
	free(ps->a);
}
//查看栈顶元素
STDataType StackTop(Stack* ps) {
	assert(ps);
	if (ps->top == 0)return -1;
	return ps->a[ps->top - 1];
}
//查看栈元素个数
int StackSize(Stack* ps) {
	assert(ps);
	return ps->top;
}
//判空操作
bool StackEmpty(Stack* ps) {
	assert(ps);
	if (ps->top == 0)return true;
	return false;
}

2.LeetCode232：用栈实现队列

定义结构：队列由两个指针组成，一个指向入队栈，一个指向出队栈

结构操作：

1.创建队列，记得malloc一下两个栈，然后初始化两个栈

2.入队，直接入队到入队栈即可

3.出队，先判断出队栈是否为空，空就把入队栈全出栈到出队栈，这样出队栈栈顶就是队首了，直接出队栈出栈即是出队操作。

4.查看队首元素，同3，不用出队即可。

5.判空，两个栈都空才为空。

6.free操作，先free栈的指针域，再free栈，再free队列

代码如下：

----------
---省略以上实现栈的代码---
typedef struct {
Stack *PushQueue;
Stack *PopQueue;
} MyQueue;

MyQueue* myQueueCreate() {
	MyQueue* new = (MyQueue*)malloc(sizeof(MyQueue));
    if (new == NULL) {
		printf("malloc failed");
		exit(-1);
	}
    new->PushQueue = (Stack*)malloc(sizeof(Stack));
	new->PopQueue = (Stack*)malloc(sizeof(Stack));
	StackInit(new->PushQueue);
	StackInit(new->PopQueue);
	return new;
}

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

int myQueuePop(MyQueue* obj) {
	if (StackSize(obj->PopQueue) == 0) {
		while (StackSize(obj->PushQueue) != 0) {
			StackPush(obj->PopQueue, StackTop(obj->PushQueue));
			StackPop(obj->PushQueue);
		}
	}	
	int pop = StackTop(obj->PopQueue);
	StackPop(obj->PopQueue);
	return pop;
}

int myQueuePeek(MyQueue * obj) {
		if (StackSize(obj->PopQueue) == 0) {
			while (StackSize(obj->PushQueue) != 0) {
				StackPush(obj->PopQueue, StackTop(obj->PushQueue));
				StackPop(obj->PushQueue);
			}
		}
        return StackTop(obj->PopQueue);
}
bool myQueueEmpty(MyQueue * obj){
		return StackEmpty(obj->PopQueue)&&StackEmpty(obj->PushQueue);
}

void myQueueFree(MyQueue * obj) {
		while (myQueueEmpty(obj) == false) {
			myQueuePop(obj);
		}
		free(obj->PushQueue->a);
		free(obj->PopQueue->a);
		free(obj->PushQueue);
		free(obj->PopQueue);
		free(obj);
}

 

 二.用队列实现栈

1.实现队列

用单链表实现队列：

1.结构定义和操作定义：

// 链式结构：表示队列 
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;
}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);

2.具体操作实现

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 初始化队列 
void QueueInit(Queue* q) {
	assert(q);
	q->front = NULL;
	q->rear = NULL;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q) {
	assert(q);
	if (q->front==NULL)
		return 1;
	else
		return 0;
}
// 队尾入队列 
void QueuePush(Queue* q, QDataType data) {
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);
	newnode->data = data;
	newnode->next = NULL;
	if (QueueEmpty(q))
		q->front = q->rear = newnode;
	else 
	{
		q->rear->next = newnode;
		q->rear = newnode;
	}
}
// 队头出队列 
void QueuePop(Queue* q) {
	assert(q);
	if (QueueEmpty(q))return;
	else {
		if (q->front->next == NULL) {
			free(q->front);
			q->front = q->rear = NULL;
		}//一个元素出队
		else {
			QNode* next = q->front->next;
			free(q->front);
			q->front = next;
		}
	}
}
// 获取队列头部元素 
QDataType QueueFront(Queue* q) {
	assert(q);
	if (QueueEmpty(q))
		return -1;
	else
		return q->front->data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* q) {
	assert(q);
	if (QueueEmpty(q))
		return -1;
	else
		return q->rear->data;
}
// 获取队列中有效元素个数 
int QueueSize(Queue* q) {
	assert(q);
	if (QueueEmpty(q))
		return 0;
	else
	{
		int size = 0;
		QNode* cur = q->front;
		while (cur) {
			size++;
			cur = cur->next;
		}
		return size;
	}
}

// 销毁队列 
void QueueDestroy(Queue* q) {
	assert(q);
	while (q->front != NULL) {
		QueuePop(q);
	}
}

2.LeetCode225.用队列实现栈

解法：定义栈，为两个队列结构的指针，一个指向队列1，一个指向队列二

1.创建栈，malloc栈结构体，队列一，队列二，然后初始化两个队列

2.入栈，往非空队列入队，若都空随意。

3.出栈，将非空队列出队到另一个队列，直到剩一个元素。这个元素就是栈顶元素，然后出队列。

4.查看栈顶元素，直接查看非空队列的队尾元素即可。

5.判空，两个队列都为空则栈为空

6.销毁，先销毁两个队列，然后free了两个队列的指针，然后free栈的指针。

------
---以上省略队列结构定义和操作---
typedef struct {
Queue*q1;
Queue*q2;
} MyStack;


MyStack* myStackCreate() {
MyStack*new=(MyStack*)malloc(sizeof(MyStack));
new->q1=(Queue*)malloc(sizeof(Queue));
new->q2=(Queue*)malloc(sizeof(Queue));
QueueInit(new->q1);
QueueInit(new->q2);
return new;
}

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

int myStackPop(MyStack* obj) {
if(QueueEmpty(obj->q1)==0)
{
    while(QueueSize(obj->q1)!=1){
        QueuePush(obj->q2,QueueFront(obj->q1));
        QueuePop(obj->q1);
    }
    int top=QueueFront(obj->q1);
    QueuePop(obj->q1);
    return top;
}else{
    while(QueueSize(obj->q2)!=1){
    QueuePush(obj->q1,QueueFront(obj->q2));
    QueuePop(obj->q2);
    }
    int top=QueueFront(obj->q2);
    QueuePop(obj->q2);
    return top;
}
}

int myStackTop(MyStack* obj) {
if(QueueEmpty(obj->q1)==0)
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->q1);
free(obj->q2);
free(obj);
}