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

代码如下：

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;
}