1.思路解析

由于C语言封装度不是很高，不像C++可以直接用现成的，所以我们要自己做一个“轮子”，即自己实现一个队列，这里直接放出代码，详解可以移步到我的另一篇关于队列的博客，点我移步，原题来源于leetcode里面的用队列实现栈。

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

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

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

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

		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

// 队尾插入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->val = x;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

// 队头删除
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);

	/*QNode* next = pq->phead->next;
	free(pq->phead);
	pq->phead = next;

	if (pq->phead == NULL)
		pq->ptail = NULL;*/

		// 一个节点
	if (pq->phead->next == NULL)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else // 多个节点
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);

	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);

	return pq->ptail->val;
}


int QueueSize(Queue* pq)
{
	assert(pq);

	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->size == 0;
}

注意：核心要点就是在操作时不管插入元素还是取出元素然后删除，都要判断空与非空队列，例如取元素就要将非空队列元素转移到空队列，然后将存留的栈顶元素删除即可；插入元素要插入到非空队列，始终保持一个空队列与一个非空队列。

2. 实现栈后的相关操作

2.1 初始化

初始化时要注意不能使用局部变量，因为局部变量出函数就会被销毁，所以要使用动态内存申请

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


MyStack* myStackCreate() 
{
    //局部变量出函数会被销毁，所以使用malloc不会被销毁
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack));
    //C语言中'->'优先级大于'&'，可以不加内部括号
    QueueInit(&(pst->q1));
    QueueInit(&(pst->q2));
    return pst;
}

---

 2.2 插入元素

前面我们知道了要向非空队列插入元素，所以要先判断空队列与非空队列再进行插入元素。

void myStackPush(MyStack* obj, int x) 
{
    //向不为空的队列插入
    if(!QueueEmpty(&(obj->q1)))
    {
        QueuePush(&(obj->q1),x);
    }
    else
    {
        QueuePush(&(obj->q2),x);
    }
}

---

2.3 删除元素

删除元素首先将非空队列中除栈顶元素转移到空队列中，然后对栈顶元素进行删除，这里判断空队列与非空队列使用了假设法，即先假设一种情况，假设成功直接进行下一步删除操作，反之将原来假设的情况置反，最后题目要求返回栈顶元素，所以使用QueueFront找到栈顶元素后返回。

int myStackPop(MyStack* obj) 
{
    //将不为空的队列前size-1个数据转移到另一个，删除留下来的栈顶数据
    //假设法
    Queue* empty = &(obj->q1);
    Queue* nonempty = &(obj->q2);
    if(!QueueEmpty(&(obj->q1)))
    {
        //假设错误
        empty = &(obj->q2);
        nonempty = &(obj->q1);
    }
    //转移数据
    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }

    int top = QueueFront(nonempty);
    QueuePop(nonempty);

    return top;
}

---

2.4 取出栈顶元素

同样需要判断空队列与非空队列，对非空队列进行取出栈顶元素的操作。

int myStackTop(MyStack* obj) 
{
    if(!QueueEmpty(&(obj->q1)))
    {
        return QueueBack(&(obj->q1));
    }    
    else
    {
        return QueueBack(&(obj->q2));
    }
}

---

2.5 判空与释放

这里不能直接使用free(obj)进行释放，因为obj的结构如图，只释放obj这个"大哥",那么他的"小弟"，p1和p2就会导致内存泄漏，所以要先销毁p1和p2然后对obj进行释放即可。

bool myStackEmpty(MyStack* obj) 
{
    //两个队列同时为空才为空
    return QueueEmpty(&(obj->q1)) && QueueEmpty(&(obj->q2)); 
}

void myStackFree(MyStack* obj) 
{
    QueueDestroy(&(obj->q1));
    QueueDestroy(&(obj->q1));

    free(obj);
}