【数据结构】两个队列实现一个栈

代码如下：

QStcak.h

#pragma once

#include<stdio.h>

typedef char QueueType;

/*创建一个结点的结构体*/
typedef struct Node{
	QueueType data;
	struct node* _next;
}Node;


/*队列结构体，有头尾指针*/
typedef struct Queue{
	struct Node* head;
	struct Node* tail;
}Queue;

/*
*     两个队列实现一个栈
*	  两个队列q1，q2
*	  每次入队列q1，出队列时把q1中除尾结点外所有的元素都入队列q2
*	  然后出队列q1，模拟出栈成功，然后把q2中元素再入队列q1
*/


/*初始化队列*/
void QueueInit(Queue** queue);
/*入栈*/
Queue* StackPush(Queue** que1, QueueType value);
/*出栈*/
void StackPop(Queue** que1, Queue** que2);
/*取栈顶元素*/
QueueType StackGetTop(Queue* que1);
/*销毁栈*/
void StackDestory(Queue** que1, Queue** que2);
/*打印队列*/
void PrintChar2(Queue* queue, char* msg);
/*取队列队首元素结点*/
Node* QueueGetHeadNode(Queue** queue);

/*往队列里面插入一个结点*/
Queue* QueueInsertNode(Queue** queue, Node* node);

QStcak.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

/*创建一个新结点*/
Node* CreateNewNode(QueueType value) {

	Node* node = (Node*)malloc(sizeof(Node));

	/*注意，node可能申请内存失败*/
	if (node != NULL) {
		node->data = value;
		node->_next = NULL;

		return node;
	}
	else {
		return;
	}
}

/*初始化队列*/
void QueueInit(Queue** queue) {

	if (queue == NULL) {
		return;
	}
	*queue = (Queue*)malloc(sizeof(Queue));
	(*queue)->head = NULL;
	(*queue)->tail = NULL;
}
Queue* QueuePush(Queue** queue, QueueType value) {

	if (queue == NULL) {
		return;
	}
	/*队列为空*/
	if ((*queue)->head == NULL && (*queue)->tail == NULL) {
		Node* node = CreateNewNode(value);
		(*queue)->head = node;
		(*queue)->tail = node;
	}
	else {
		/*保存head的位置*/
		Node* next_node = (*queue)->head;
		Node* node = CreateNewNode(value);

		next_node->_next = node;
		(*queue)->head = node;
	}
}

/*入栈*/
Queue* StackPush(Queue** que1, QueueType value) {

	if (que1 == NULL) {
		return;
	}
	if (*que1 == NULL) {
		return;
	}
	if ((*que1)->head == NULL && (*que1)->tail == NULL) {
		/*队列q1为空*/
		Node* node = CreateNewNode(value);
		(*que1)->head = node;
		(*que1)->tail = node;
		return;
	}
	/*队列不为空*/
	Node* node = CreateNewNode(value);
	/*从尾部插入*/
	Node* old_last = (*que1)->tail;
	old_last->_next = node;

	/*让尾指针后移*/
	(*que1)->tail = node;
}

/*打印队列*/
void PrintChar2(Queue* queue, char* msg) {
	if (queue == NULL) {
		printf("队列不存在！");
		return;
	}
	if (queue->head == NULL && queue->tail == NULL) {
		printf("队列为空");
		return;
	}

	printf("%s\n\n", msg);
	printf("[head]->");
	Node* cur = queue->head;
	while (cur != queue->tail) {
		printf("[%c]->", cur->data);
		cur = cur->_next;
	}
	printf("[%c]", cur->data);
	printf("<-[tail]\n\n");
}

/*取队列队首元素结点*/
Node* QueueGetHeadNode(Queue** queue) {

	if (queue == NULL) {
		return;
	}
	if (*queue == NULL) {
		/*队列创建失败*/
		return;
	}
	/*队列判空*/
	if ((*queue)->head == NULL && (*queue)->tail == NULL) {
		printf("队列为空");
		return;
	}
	/*只有一个元素*/
	if ((*queue)->head == (*queue)->tail) {
		Node* node = (*queue)->head;
		/*只有一个元素，*/
		(*queue)->head = NULL;
		(*queue)->tail = NULL;
		return node;
	}
	else {
		/*不只一个元素，取元素，移动头指针，销毁结点*/
		Node* node = (*queue)->head;
		(*queue)->head = node->_next;
		return node;
	}
}

/*往队列里面插入一个结点*/
Queue* QueueInsertNode(Queue** queue, Node* node) {

	if (queue == NULL) {
		return;
	}
	if (*queue == NULL) {
		return;
	}
	/*队列为空的情况下*/
	if ((*queue)->head == NULL && (*queue)->tail == NULL) {
		(*queue)->head = node;
		(*queue)->tail = node;
	}
	else {
		Node* old_last = (*queue)->tail;
		old_last->_next = node;

		(*queue)->tail = node;
//		node->_next = NULL;
	}
}

/*出栈*/
void StackPop(Queue** que1, Queue** que2) {

	if (que1 == NULL) {
		return;
	}
	if (que2 == NULL) {
		return;
	}
	if (*que1 == NULL) {
		/*栈为空*/
		printf("栈为空");
		return;
	}
	/*
	*	出栈一个元素
	*	把q1中tail前的所有元素结点转移到q2中
	*/
	Node* cur = (*que1)->head;
	while (cur != (*que1)->tail) {
		/*用cur遍历队列q1，直到cur等于que1的tail指针*/
		cur = cur->_next;
		Node* in_node = QueueGetHeadNode(que1);

		/*每次取到一个队首结点,插入que2*/
		QueueInsertNode(que2, in_node);
	}
	/*cur等于que1的tail指针,模拟出栈，即删除该元素*/
	Node* del_node = cur;
	(*que1)->tail = NULL;
	(*que1)->head = NULL;
	DestoryNode(del_node);

	/*然后把q2中所有结点拆除然后入队列q1*/
	Node* cur2 = (*que2)->head;
	while (cur2 != (*que2)->tail) {
		cur2 = cur2->_next;
		Node* inser_node = QueueGetHeadNode(que2);

		/*每次取到队列q2的首结点，然后插入队列q1中*/
		QueueInsertNode(que1, inser_node);
	}
	/*如果只有一个元素了，那么删除q1中的最后一个结点，但是q2并没有结点，因此要判空*/
	if ((*que2)->head == NULL && (*que1)->tail == NULL) {
		return;
	}
	//取出最后一个元素然后插入到q1的末尾
	Node* last_node = QueueGetHeadNode(que2);
	QueueInsertNode(que1, last_node);

	/*把队列q2的头尾指针都值为空*/
	(*que2)->head = NULL;
	(*que2)->tail = NULL;
}

/*取栈顶元素*/
QueueType StackGetTop(Queue* que1) {

	if (que1 == NULL) {
		return;
	}
	/*对队列q1进行判空*/
	if (que1->head == NULL && que1->tail == NULL) {
		printf("队列为空");
		return;
	}
	return que1->tail->data;
}
/*销毁栈*/
void StackDestory(Queue** que1,Queue** que2) {

	if (que1 == NULL) {
		return;
	}
	if (*que1 == NULL && *que2 == NULL) {
		printf("栈不存在");
		return;
	}
	if (*que1 == NULL) {
		printf("队列q1不存在");
		return;
	}
	if (*que2 == NULL) {
		printf("队列q2不存在");
		return;
	}

	if ((*que1)->head != NULL && (*que1)->tail != NULL) {
		/*对队列进行判空*/
		Node* cur = (*que1)->head;
		while (cur != (*que1)->tail) {
			Node* delete = cur;
			cur = cur->_next;
			DestoryNode(delete);
		}
		DestoryNode(cur);
	}
	/*队列为空，或者结点已释放完成*/
	free(*que1);
	free(*que2);

	*que1 = NULL;
	*que2 = NULL;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include"Queue.h"

#define TESTHEAD  printf("---------------%s-----------------\n",__FUNCTION__);

void TestStack() {
	Queue* que1;
	Queue* que2;
	TESTHEAD;
	QueueInit(&que1);
	QueueInit(&que2);

	StackPush(&que1,'a');
	StackPush(&que1,'b');
	StackPush(&que1,'c');
	StackPush(&que1,'d');
	StackPush(&que1,'e');
	StackPush(&que1,'f');

	PrintChar2(que1, "入栈六个元素");

	StackPop(&que1, &que2);
	StackPop(&que1, &que2);
	StackPop(&que1, &que2);
	StackPop(&que1, &que2);
	StackPop(&que1, &que2);
	StackPop(&que1, &que2);

	PrintChar2(que1, "出栈一个元素");
}

void TestStackTopValue() {
	Queue* que1;
	Queue* que2;
	TESTHEAD;
	QueueInit(&que1);
	QueueInit(&que2);

	StackPush(&que1, 'a');
	StackPush(&que1, 'b');
	StackPush(&que1, 'c');
	StackPush(&que1, 'd');
	StackPush(&que1, 'e');

	PrintChar2(que1, "入栈六个元素");

	/*取栈顶元素*/
	QueueType value = StackGetTop(que1);
	printf("expect e, actual:%c", value);
}

void TestDesoryStack() {
	Queue* que1;
	Queue* que2;
	TESTHEAD;
	QueueInit(&que1);
	QueueInit(&que2);

	StackPush(&que1, 'a');
	StackPush(&que1, 'b');
	StackPush(&que1, 'c');
	StackPush(&que1, 'd');
	StackPush(&que1, 'e');

	PrintChar2(que1, "入栈六个元素");

	StackDestory(&que1, &que2);

	PrintChar2(que1, "栈是否为空");

	StackDestory(&que1, &que2);

}

int main() {
	TestStack();
	TestStackTopValue();
	TestDesoryStack();
	system("pause");
	return 0;
}