栈实现队列（继续细起来啊）

生命不是要等待风暴过去，而是要学会在风暴中跳舞。        ——卡莉尔·吉布朗
目录

🍁一.栈实现队列

🍀二.使用两个栈实现队列的功能

🌼1.在队列的结构体中创建两个栈

🚁2.创建一个队列的结构体指针

🌉3.myQueuePush入队列操作

🌏4.myQueuePeek返回队列头的元素

🍐5.myQueuePop删除队列头的元素并返回元素

🌳6.myQueueEmpty判断队列是否为空

🍅7.myQueueFree销毁队列

🏵️三.完整代码

---

题目描述：
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

注意这里的pop和peek函数同样是功能差不多的，都是返回队列头的元素，只是pop函数还要删除队列头的元素。
接口函数：

typedef struct {

} MyQueue;


MyQueue* myQueueCreate() {

}

void myQueuePush(MyQueue* obj, int x) {

}

int myQueuePop(MyQueue* obj) {

}

int myQueuePeek(MyQueue* obj) {

}

bool myQueueEmpty(MyQueue* obj) {

}

void myQueueFree(MyQueue* obj) {

}

做题链接：栈实现队列

🍁一.栈实现队列

🍀二.使用两个栈实现队列的功能

做题思路：同样和队列模拟实现栈一样，我们都是使用两个，但是两个栈来实现队列更加的容易，我们知道栈是先进后出，而队列是先进先出。我们使用两个栈，一个栈只入元素，而另一个栈只出元素，如何理解呢？这个入数据的的栈把元素往出数据的栈里面倒元素，那么这些元素就反过来了，头就变成了尾，为就变成了头，这样出元素的那个栈就变成队列的功能了。
画图理解：

然后我们就把1 2 3 4 5往入元素的栈依次入栈即可。
 

然后就是把入元素的栈的元素往出元素的栈里面给倒元素，依次往里面入元素。

 此时出元素的栈依次出元素，出的顺序就变成了 1 2 3 4 5，而入的顺序也是1 2 3 4 5，这恰恰就是队列的功能啊，先进先出。

思路是有了，最主要还是看如何写代码。 

🌼1.在队列的结构体中创建两个栈

typedef struct {
    Stack pushst;//入元素的栈
    Stack popst;//出元素的栈
} MyQueue;

🚁2.创建一个队列的结构体指针

同样这里不是传参，而是以返回值的方式返回结构体的指针。

MyQueue* myQueueCreate() {
   MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
   if(obj==NULL)
     return NULL;
    StackInit(&obj->pushst);//注意这里->的优先级高于&，obj先和pushst结合，再是&
    StackInit(&obj->popst);//和这样写是一样的&(obj->popst)
    return obj;
}

🌉3.myQueuePush入队列操作

入队列的方式就很简单了，因为只有一个栈是入栈操作的，直接把元素往里面入即可。

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

🌏4.myQueuePeek返回队列头的元素

这个就需要把入元素的栈的元素往出元素的栈里面给倒元素，然后返回这个栈顶的元素，就相当于队列头的元素。
这里注意要好好理解这个代码的意思。

int myQueuePeek(MyQueue* obj) 
{
    if(StackEmpty(&obj->popst))//出元素的栈为空，那么就需要倒数据，再返回栈顶的元素
    {
       while(!StackEmpty(&obj->pushst))//非空就继续倒元素
      {
        StackPush(&obj->popst,StackTop(&obj->pushst));
        StackPop(&obj->pushst);
      }
    }
    //出元素的栈不为空，直接返回栈顶的元素即可
   return StackTop(&obj->popst);//返回栈顶的元素，就相当于队列头的元素
}

🍐5.myQueuePop删除队列头的元素并返回元素

这个函数和myQueuePeek函数的功能是差不多的，只是这个函数需要删除队列头的元素，我们可以直接复用这个函数。

int myQueuePop(MyQueue* obj) 
{
   int top=myQueuePeek(obj);
   StackPop(&obj->popst);//删除元素
   return top;
}

🌳6.myQueueEmpty判断队列是否为空

bool myQueueEmpty(MyQueue* obj) {
   return StackEmpty(&obj->pushst)//同样需要两个栈都为空，队列才为空
    &&StackEmpty(&obj->popst);
}

🍅7.myQueueFree销毁队列

void myQueueFree(MyQueue* obj) {
      StackDestroy(&obj->pushst);//销毁入元素的栈
      StackDestroy(&obj->popst);//销毁出元素的栈
      free(obj);//释放结构体的指针
}

🏵️三.完整代码

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);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);//动态的开辟空间
	if (ps->a == NULL)
	{
		perror("malloc\n");
		return;
	}
	ps->top = 0;
	ps->Capacity = 4;
}

// 入栈 
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->Capacity)
	{
		STDataType* temp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->Capacity * 2);
		if (temp == NULL)
		{
			perror("realloc\n");
			return;
		}
		ps->Capacity *= 2;//每次增容尾上一次的二倍
		ps->a = temp;
	}
	ps->a[ps->top] = x;
	ps->top++;//栈内入一个数据，top就要往上面走一步
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top>0);
	ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	return ps->a[ps->top-1];
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->Capacity = 0;
}

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

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


typedef struct {
    Stack pushst;//入元素的栈
    Stack popst;//出元素的栈
} MyQueue;


MyQueue* myQueueCreate() {
   MyQueue*obj=(MyQueue*)malloc(sizeof(MyQueue));
   if(obj==NULL)
     return NULL;
    StackInit(&obj->pushst);//注意这里->的优先级高于&，obj先和pushst结合，再是&
    StackInit(&obj->popst);//和这样写是一样的&(obj->popst)
    return obj;
}

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

int myQueuePop(MyQueue* obj) 
{
   int top=myQueuePeek(obj);
   StackPop(&obj->popst);
   return top;
}

int myQueuePeek(MyQueue* obj) 
{
    if(StackEmpty(&obj->popst))//出元素的栈为空，那么就需要倒数据，再返回栈顶的元素
    {
       while(!StackEmpty(&obj->pushst))//非空就继续倒元素
      {
        StackPush(&obj->popst,StackTop(&obj->pushst));
        StackPop(&obj->pushst);
      }
    }
    //出元素的栈不为空，直接返回栈顶的元素即可
   return StackTop(&obj->popst);//返回栈顶的元素，就相当于队列头的元素
}

bool myQueueEmpty(MyQueue* obj) {
   return StackEmpty(&obj->pushst)
    &&StackEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
      StackDestroy(&obj->pushst);
      StackDestroy(&obj->popst);
      free(obj);
}