用栈实现队列---用两个栈模拟实现一个队列

 入队列：直接将元素放进s1（s1栈顶为模拟队列的队尾）;

出队列：如果s2非空，直接让s2出栈（s2栈顶为模拟队列的队头）；

             如果s2为空，将s1中所有元素导入s2中，然后让s2出栈。

获取队头元素：找s2；

判空：s1&&s2都是空；

typedef int DataType;
typedef struct stack{
    DataType* array;
    int capacity;
    int top;
}stack;

//栈初始化
void initStack(stack* mystack)
{
    mystack->capacity=3;
    assert(mystack);
    mystack->array=(DataType*)malloc(sizeof(DataType)*mystack->capacity);
    if(mystack->array==NULL)
    {
        return;
    }
    mystack->top=0;
}

//栈判空
bool emptyStack(stack* mystack)
{
    assert(mystack);
    return mystack->top==0;
}

//检查栈是否满
void StackCheckCapacity(stack* ps)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = (ps->capacity << 1);

		// 1. 开辟新空间
		DataType* temp = (DataType*)malloc(sizeof(DataType)* newCapacity);
		if (NULL == temp)
			assert(0);

		// 2. 拷贝元素
		memcpy(temp, ps->array, sizeof(DataType)*ps->capacity);

		// 3. 释放旧空间,使用新空间
		free(ps->array);
		ps->array = temp;
		ps->capacity = newCapacity;
	}
}

//入栈
void pushStack(stack* mystack,DataType data)
{
    StackCheckCapacity(mystack);
    assert(mystack);
    mystack->array[mystack->top]=data;
    mystack->top++;

}

//出栈
void popStack(stack* mystack)
{
   assert(mystack);
   mystack->top-=1;

}

//获取栈顶元素
DataType  topStack(stack* mystack)
{
    assert(mystack);
    return mystack->array[mystack->top-1];
}

//销毁栈
void destoryStack(stack* mystack)
{

    assert(mystack);
    if(mystack->array)
    {
        free(mystack->array);
    }
    mystack->top=0;
    mystack->capacity=0;


}


typedef struct {
    stack s1;
    stack s2;

} MyQueue;


//模拟队列初始化
MyQueue* myQueueCreate() {
   MyQueue* mq=(MyQueue*)malloc(sizeof(MyQueue));
    if(mq==NULL)
    {
        assert(0);
        return NULL;
    }
    assert(mq);
    initStack(&mq->s1);
    initStack(&mq->s2);
    return mq;

}

//队列入队
void myQueuePush(MyQueue* obj, int x) {
    assert(obj);
    pushStack(&obj->s1,x);

}

//队列出队
int myQueuePop(MyQueue* obj) {
    assert(obj);
    if(emptyStack(&obj->s2))
    {
      while(!(emptyStack(&obj->s1)))
      {
          pushStack(&obj->s2,topStack(&obj->s1));
          popStack(&obj->s1);
      }

    }
     DataType ele= topStack(&obj->s2);
    popStack(&obj->s2);
    return ele;

}

//获取队头元素
int myQueuePeek(MyQueue* obj) {

    assert(obj);
    if(emptyStack(&obj->s2))
    {
        while(!(emptyStack(&obj->s1)))
      {
          pushStack(&obj->s2,topStack(&obj->s1));
          popStack(&obj->s1);
      }

    }
    return topStack(&obj->s2);


}

//队列判空
bool myQueueEmpty(MyQueue* obj) {
    assert(obj);
    return emptyStack(&obj->s1)&&emptyStack(&obj->s2);

}

//模拟队列的销毁
void myQueueFree(MyQueue* obj) {
    assert(obj);
    destoryStack(&obj->s1);
    destoryStack(&obj->s2);
    free(obj);
}