用队列实现栈--栈和队列

用队列实现栈的分析

代码

完整代码

//队列的代码----------------首
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;
typedef struct Queue
{
	QueueNode* phead;
	QueueNode* ptail;
}Queue;
void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);  // 只在队尾入数据
void QueuePop(Queue* pq);                // 只在队头出数据
int QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);

void QueueInit(Queue* pq)
{
	assert(pq);

	pq->phead = pq->ptail = NULL;
}
void QueueDestory(Queue* pq)
{
	assert(pq);

	QueueNode* cur = pq->phead;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);

		cur = next;
	}
	pq->phead = pq->ptail = NULL;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->phead->next == NULL)//第一个节点的next为空
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
}
int QueueSize(Queue* pq)
{
	assert(pq);
	// 如果频繁调用这个接口函数，可以在Queue中给一个size记录数据个数
	int n = 0;
	QueueNode* cur = pq->phead;
	while (cur)
	{
		n++;
		cur = cur->next;
	}

	return n;
}
//取头的数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->phead->data;
}
//取尾的数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->ptail->data;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->ptail == NULL && pq->phead == NULL;
}
//队列的代码---------------------------------尾

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;

/** Initialize your data structure here. */

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

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
       QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
 
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* emptyQ=&obj->q1;//假设q1为空
    Queue* noneemptyQ=&obj->q2;//假设q2为空
    if(!QueueEmpty(&obj->q1))
    {
        emptyQ=&obj->q2;
        noneemptyQ=&obj->q1;
    }
    while(QueueSize(noneemptyQ)>1)//剩余1个来删除
    {
        //取和插
        QueuePush(emptyQ,QueueFront(noneemptyQ));//非空的头导入到空队列当中
        QueuePop(noneemptyQ);//让非空的队列出队
    }
    int top=QueueFront(noneemptyQ);
    QueuePop(noneemptyQ);//删除留下来的那一个
    return top;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
  assert(obj);
  if(!(QueueEmpty(&obj->q1)))
  {
    return   QueueBack(&obj->q1);
  }
  else
  {
    return   QueueBack(&obj->q2);
  }
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
   assert(obj);
   QueueDestory(&obj->q1);
   QueueDestory(&obj->q2);
   free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/