目录

一、栈和队列的特点：（这里使用的均为动态）

二、栈和队列的实现（基础功能）：

栈的实现：（数组实现的）

Stack.h（头文件）

Stack.c（函数文件）

用栈实现队列（双栈实现一个队列）：

思维图：

TwoStacksImplementationQueue.h（头文件）

TwoStacksImplementationQueue.c（函数文件）

队列的实现：（链表结构）

Queue.h（头文件）

Queue.c（函数文件）

用队列实现栈（双队列实现一个栈）：

思维图：

QueueImplementationStack.h（头文件）

QueueImplementationStack.c（函数文件）

---

一、栈和队列的特点：（这里使用的均为动态）

栈：

        后进先出，即只能对最晚的元素进行操作。

        通常使用一个指针来指示栈顶的位置。

队列：

        先进先出，即只能对最早的元素进行操作。

        通常使用队头和队尾两个指针。

二、栈和队列的实现（基础功能）：

废话不多说，直接上代码。

栈的实现：（数组实现的）

Stack.h（头文件）

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;  //数组指针
	int top;	   // 栈顶
	int capacity;  // 容量 
}Stack;

void StackInit(Stack* ps);// 初始化栈 

void StackResize(Stack* ps);   //用于动态扩容，防止空间不够

void StackPush(Stack* ps, STDataType data);// 入栈 

void StackPop(Stack* ps);// 出栈 

STDataType StackTop(Stack* ps);// 获取栈顶元素 
 
int StackSize(Stack* ps);// 获取栈中有效元素个数 
 
int StackFull(Stack* ps);// 检测栈是否为满，如果为满返回非零结果，如果不为满返回0  

int StackEmpty(Stack* ps);// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 

void StackDestroy(Stack* ps);// 销毁栈 

Stack.c（函数文件）

#include"Stack.h"

void StackInit(Stack* ps)    //初始化栈
{
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 10);
	if (ps->a == NULL)
	{
		printf("fail malloc\n");
		exit(-1);
	}
	ps->top = -1;
	ps->capacity = 10;
}

void StackResize(Stack* ps)   //用于动态扩容，防止空间不够
{
	ps->capacity *= 2;
	ps->a = (STDataType*)malloc(sizeof(STDataType) * ps->capacity);
	if (ps->a == NULL)
	{
		printf("fail malloc\n");
		exit(-1);
	}
}

void StackPush(Stack* ps, STDataType data)    //入栈操作
{
	if (StackFull(ps))
	{
		StackResize(ps);
	}
	ps->a[++ps->top] = data;
}

void StackPop(Stack* ps)     //出栈操作
{
	if (StackEmpty(ps))
	{
		printf("Stack is empty.\n");
		exit(-1);
	}
	printf("%d ", ps->a[ps->top]);
	ps->top--;
}

STDataType StackTop(Stack* ps)    //获取栈顶元素，但不出栈
{
	if (StackFull(ps))
	{
		printf("Stack is stackfull.\n");
		exit(-1);
	}
	return ps->a[ps->top];
}

int StackSize(Stack* ps)        //获取栈里有效元素个数
{
	return ps->top + 1;
}

int StackFull(Stack* ps)    //检查栈是否为满
{
	return ps->top == ps->capacity - 1;
}

int StackEmpty(Stack* ps)    //检查栈是否为空
{
	return ps->top == -1;
}

void StackDestroy(Stack* ps)    //销毁栈
{
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = -1;
}

用栈实现队列（双栈实现一个队列）：

思维图：

TwoStacksImplementationQueue.h（头文件）

#include"Stack.h"    //不要忘了保函以及实现好了的栈

typedef struct {
	Stack pushst;    //该栈用来实现插入队列元素
	Stack popst;     //该栈用来实现出队列元素
} MyQueue;

MyQueue* myQueueCreate();    //得先初始化一下MyQueue里的两个栈

void myQueuePush(MyQueue* obj, int x);    //入队列

int myQueuePeek(MyQueue* obj);    //返回队列开头的元素

int myQueuePop(MyQueue* obj);    //出队列
bool myQueueEmpty(MyQueue* obj);    //判断队列是否为空

void myQueueFree(MyQueue* obj);//销毁栈

TwoStacksImplementationQueue.c（函数文件）

#include"TwoStacksImplementationQueue.h"    //不要忘了包含头文件

MyQueue* myQueueCreate()    //得先初始化一下MyQueue里的两个栈
{
	MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
	StackInit(&obj->pushst);
	StackInit(&obj->popst);
	return obj;
}

void myQueuePush(MyQueue* obj, int x)
{
    //这里的入队列功能就由一个栈来实现，所以只需要调用栈的入栈功能来驱动其中一个栈
	StackPush(&obj->pushst, x);
}

int myQueuePeek(MyQueue* obj)    //返回队列开头的元素，但删除该元素
{
	if (StackEmpty(&obj->popst))    //如果负责出元素的栈不为空，则直接出元素
	{
		while (!StackEmpty(&obj->pushst))
        //如果负责出元素的栈为空,则就把负责入元素的栈里的元素转移到出元素的栈里这样栈里元素就实现了整体反转
		{
			StackPush(&obj->popst, StackTop(&obj->pushst));
			StackPop(&obj->pushst);
		}
	}
	return StackTop(&obj->popst);
}

int myQueuePop(MyQueue* obj)//出队列头元素
{
	int front = myQueuePeek(obj);//利用myQueuePeek函数使队列头元素位于只负责出队列功能的栈里，并读取保存
	StackPop(&obj->popst);//在利用栈的出栈功能把队列头元素删除。
	return front;
}

bool myQueueEmpty(MyQueue* obj)//判断队列是否为空
{
	return StackEmpty(&obj->popst) && StackEmpty(&obj->pushst);
    //判断队列是否为空的条件就是，负责出队列功能和入队列功能的两个栈都要是空的才可以。
}

void myQueueFree(MyQueue* obj)//销毁栈
{
	StackDestroy(&obj->popst);
	StackDestroy(&obj->pushst);
	free(obj);
}

队列的实现：（链表结构）

Queue.h（头文件）

#include<stdio.h>
#include<stdlib.h>
// 链式结构：表示队列 

typedef int QDataType;

typedef struct QListNode  //队列的元素结构体
{
	struct QListNode* next;
	QDataType data;
}QNode;

typedef struct Queue      //队列的头指针和尾指针
{
	QNode* front;
	QNode* rear;
}Queue;

void QueueInit(Queue* q);// 初始化队列 

void QueuePush(Queue* q, QDataType data);// 队尾入队列 

void QueuePop(Queue* q);// 队头出队列

QDataType QueueFront(Queue* q);// 获取队列头部元素 

QDataType QueueBack(Queue* q);// 获取队列队尾元素 

int QueueSize(Queue* q);// 获取队列中有效元素个数 

int QueueEmpty(Queue* q);// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 

void QueueDestroy(Queue* q);// 销毁队列 

Queue.c（函数文件）

#include "Queue.h"

void QueueInit(Queue* q)// 初始化队列 
{
	q->front = q->rear = NULL;
}

void QueuePush(Queue* q, QDataType data)//入队列
{
	QNode* newQNode = (QNode*)malloc(sizeof(QNode));//扩容，防止空间不够
	if (newQNode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newQNode->data = data;
	newQNode->next = NULL;
	if (q->rear == NULL)//用来判断一个队列里是否有没有元素
	{
		q->front = q->rear = newQNode;
	}
	else
	{
		q->rear->next = newQNode;
		q->rear = newQNode;
	}
}

void QueuePop(Queue* q)//出队列
{
	if (q->front == NULL)
	{
		printf("front is isfull");
		exit(-1);
	}
	printf("Pop->%d ", q->front->data);
	QNode* next = q->front->next;
	free(q->front);
	q->front = next;
}

QDataType QueueFront(Queue* q)//访问队列头元素
{
	return q->front->data;
}

QDataType QueueBack(Queue* q)//访问队列尾元素
{
	return q->rear->data;
}

int QueueSize(Queue* q)    // 获取队列中有效元素个数 
{
	int i = 0;
	QNode* count = q->front;
	while (count)
	{
		count = count->next;
		++i;
	}
	return i;
}

int QueueEmpty(Queue* q)// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
{
	return q->front == NULL;
}

void QueueDestroy(Queue* q)// 销毁队列 
{
	QNode* next = q->front;
	QNode* cur = NULL;
	while (next)
	{
		cur = next->next;
		free(next);
		next = cur;
	}
	q->front = q->rear = NULL;
}

用队列实现栈（双队列实现一个栈）：

思维图：

QueueImplementationStack.h（头文件）

#include"Queue.h"
#include<stdbool.h>

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

MyStack* myStackCreate();//初始化
void myStackPush(MyStack* obj, int x);//入栈
int myStackPop(MyStack* obj);//出栈
int myStackTop(MyStack* obj);//访问栈顶元素
bool myStackEmpty(MyStack* obj);//检查队列是否为空
void myStackFree(MyStack* obj);//销毁队列

QueueImplementationStack.c（函数文件）

#include"QueueImplementationStack.h"

MyStack* myStackCreate() //初始化用来实现栈功能的两个队列
{
	MyStack* pry = (MyStack*)malloc(sizeof(MyStack));
	QueueInit(&pry->q1);
	QueueInit(&pry->q2);
	return pry;
}

void myStackPush(MyStack* obj, int x) //入栈操作，哪个不为空入哪个
{
	if (!QueueEmpty(&obj->q1))
	{
		QueuePush(&obj->q1, x);
	}
	else
	{
		QueuePush(&obj->q2, x);
	}
}

int myStackPop(MyStack* obj)
//出栈操作，把一个队列的元素留一个，其余的全部转义至另一个队列，留下的那一个元素就是最后进入栈的元素
{
	Queue* empty = &obj->q1;
	Queue* noempty = &obj->q2;
	if (!QueueEmpty(&obj->q1))
	{
		noempty = &obj->q1;
		empty = &obj->q2;
	}
	while (QueueSize(noempty) > 1)
	{
		QueuePush(empty, QueueFront(noempty));
		QueuePop(noempty);
	}
	int top = QueueFront(noempty);
	QueuePop(noempty);

	return top;
}

int myStackTop(MyStack* obj) //访问栈顶元素
{
	if (!QueueEmpty(&obj->q1))
	{
		return QueueBack(&obj->q1);
	}
	else
	{
		return QueueBack(&obj->q2);
	}
}

bool myStackEmpty(MyStack* obj) //判断栈是否为空
{
    //判断栈是否为空的条件就是，负责出栈功能和入栈功能的两个队列都要是空的才可以。
	return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) //销毁用来实现栈的两个队列
{
	QueueDestroy(&obj->q1);
	QueueDestroy(&obj->q2);

	free(obj);
}