232.用栈实现队列（C实现 和 C++实现）

题目

题目链接：232.用栈实现队列

---

思路

用栈模拟实现队列的意思是：栈是后进先出，而队列是先进后出，要用栈完成先进后出的功能！
很明显，一个栈是不可能完成的，因为一个栈只有后进先出，所以我们需要两个栈！

---

1 设一个栈为push，表示为入数据的栈；设一个栈为pop表示出数据的栈！
2 要完成入队的功能！只需要把数据往push栈放即可，也就是栈的尾插操作！
3 要完成出队的功能！只要把push栈的数据出栈到pop栈中，然后pop栈再出栈即可！
4 获取对头元素，也是只要获取pop栈的栈顶元素即可！
5 判空队列，只需要保证两个栈都为空，即可说明队列为空！

---

入队模拟：

---

出队模拟：

---

代码实现–C实现

由于C语言没有栈的数据结构，所以需要自己实现一个栈的数据结构，才可以编写这道题！
假如用C++ 写那么就很方便，方便在于不用自己实现一个栈结构，C++ 本身就提供栈结构给你！

---

typedef int STDataType;
//栈初始化top = 0；入栈元素后，top指向元素的下一个位置

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

void StackInit(ST* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	if (ps->capacity == ps->top)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* temp = (STDataType*)realloc(ps->a, sizeof(STDataType)*newCapacity);
		if (temp == NULL)
		{
			printf("增容失败！程序退出");
			exit(-1);
		}
		//增容成功！
		ps->capacity = newCapacity;
		ps->a = temp;
	}

	ps->a[ps->top++] = x;

}
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);

	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

bool StackIsEmpty(ST* ps)
{
	assert(ps);
	//if (ps->top == 0)
	//	return true;
	//else
	//	return false;
	//下面这种方式比if判断代码更少
	return ps->top == 0;
}



void StackDestroy(ST* ps)
{
	assert(ps);

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

}

typedef struct {
    ST pushST;
    ST popST;
} MyQueue; //用两个栈两模拟队列

//创建队列也就是给两个栈做初始化！
MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));

    StackInit(&q->pushST);
    StackInit(&q->popST);
    return q;
}
//给pushST栈入栈就是模拟队列的入队了
void myQueuePush(MyQueue* obj, int x) {

    StackPush(&obj->pushST,x);
}
//把pushST的数据都出栈到popST中，然后popST再出栈，即模拟成功出队
int myQueuePop(MyQueue* obj) {
    
    //当popST为空时候，才把pushST的数据出栈到popST中
    if(StackIsEmpty(&obj->popST))
    {
        //在pushST不为空的时候，把pushST的数据导入到popST中
        while(!StackIsEmpty(&obj->pushST))
        {            
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }       
    }
    //假如popST本身不为空，即还有数据，直接出栈，表示出队
    int front = StackTop(&obj->popST);
    StackPop(&obj->popST);
    return front;
}
//获取对头元素直接从popST获取，前提popST不为空，假如为空
//把pushST的数据倒入到popST，再获取popST的栈顶
int myQueuePeek(MyQueue* obj) {
    //当popST为空时候，才把pushST的数据出栈到popST中
    if(StackIsEmpty(&obj->popST))
    {
        //在pushST不为空的时候，把pushST的数据导入到popST中
        while(!StackIsEmpty(&obj->pushST))
        {            
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }       
    }
     return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
    return StackIsEmpty(&obj->pushST) &&  StackIsEmpty(&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);
*/

---

实现代码–C++实现

class MyQueue {
public:
    MyQueue() {
       
    }
     stack<int> A; //用来入队
     stack<int> B; //用来出队
    
    void push(int x) {
        A.push(x);
    }
    
    int pop() {
        
        if(B.empty())
        {
            while(!A.empty())
            {
                B.push(A.top());
                A.pop();
            }            
        }
        //B栈不空，直接出栈，表示出队
        int top = B.top();
        B.pop();
        return top;
    }
    
    int peek() {
         if(B.empty())
        {
            while(!A.empty())
            {
                B.push(A.top());
                A.pop();
            }            
        }
        return B.top();
    }
    
    bool empty() {
        return A.empty() && B.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */