程序员成长之旅——用栈实现队列

题目简介

使用栈实现队列的下列操作：

• push(x) – 将一个元素放入队列的尾部。
• pop() – 从队列首部移除元素。
• peek() – 返回队列首部的元素。
• empty() – 返回队列是否为空。

示例:

• MyQueue queue = new MyQueue();
  queue.push(1);
  queue.push(2);
  queue.peek(); // 返回 1
  queue.pop(); // 返回 1
  queue.empty(); // 返回 false

LeetCode

//支持动态增长的栈
typedef int STDataType;

typedef struct Stack
{
	STDataType* _a;//动态实现
	int _top;//有效的数据，栈顶
	int _capacity;//容量的大小
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = ps->_top = 0;
}
void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		int newcapacity  = ps->_capacity == 0 ? 5 : ps->_capacity * 2;
		STDataType* newstack = (STDataType*)realloc(ps->_a, newcapacity * sizeof(STDataType));
		if (NULL == newstack)
		{
			printf("realloc error!");
			exit(0);
		}
		ps->_capacity = newcapacity;
		ps->_a = newstack;
	}
	ps->_a[ps->_top] = x;
	ps->_top++;
}
void StackPop(Stack* ps)
{
	assert(ps);
	if (ps->_top == 0)
	{
		return;
	}
	ps->_top--;
}
STDataType StackTop(Stack* ps)
{
	assert(ps);
    if(ps->_top == 0)
        return 0;
	return ps->_a[ps->_top-1];
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->_a != NULL)
	{
		free(ps->_a);
		ps->_a = NULL;
		ps->_capacity = ps->_top = 0;
	}
}



typedef struct {
    Stack _push;
    Stack _pop;
    
} MyQueue;

/** Initialize your data structure here. */

MyQueue* myQueueCreate() {
    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&queue->_push);
    StackInit(&queue->_pop);
    return queue;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
  StackPush(&obj->_push, x);
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
 if(StackEmpty(&obj->_pop) != 0)
  {
       int st = StackTop(&obj->_pop);
        StackPop(&obj->_pop);
         return st;
  }
  else
  {
     if(StackEmpty(&obj->_push) == 0)
     {
          return 0;
     }
     else
     {
          while(StackEmpty(&obj->_push) != 0)
          {
                StackPush(&obj->_pop,StackTop(&obj->_push) );
                StackPop(&obj->_push);
          }
            int st = StackTop(&obj->_pop);
            StackPop(&obj->_pop);
            return st;
      }
  }
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
  if(StackEmpty(&obj->_pop) != 0)
  {
      return StackTop(&obj->_pop);
  }
  else
  {
     if(StackEmpty(&obj->_push) == 0)
     {
          return 0;
     }
     else
     {
          while(StackEmpty(&obj->_push) != 0)
          {
                StackPush(&obj->_pop,StackTop(&obj->_push) );
                StackPop(&obj->_push);
          }
          return StackTop(&obj->_pop);
      }
  }
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
  return StackEmpty(&obj->_pop) + StackEmpty(&obj->_push) == 0 ? true : false;
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->_pop);
    StackDestroy(&obj->_push);
    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);
*/