数据结构队列

栈（Stack）

只允许在一端进行插入或删除操作的线性表
（栈顶）（先进后出）

顺序表实现栈代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int top;
}SqStack;
//初始化
void InitStack(SqStack& S) {
	S.top = -1;//代表栈为空
}
//判断栈是否为空
bool StackEmpty(SqStack S) {
	if (S.top == -1) {
		return true;
	}
	return false;
}
//入栈
bool Push(SqStack& S, ElemType x) {
	if (S.top == MaxSize - 1) {
		return false;//栈满
	}
	S.data[++S.top] = x;
	return true;//入栈成功
}
//获取栈顶元素
bool GetTap(SqStack S, ElemType &x) {
	if (StackEmpty(S))
		return false;
	x = S.data[S.top];
	return true;
}
//出栈
bool Pop(SqStack& S, ElemType &x) {
	if (StackEmpty(S))//出栈
		return false;
	x = S.data[S.top--];
	return true;
}
int main() {
	SqStack S;
	bool flag;
	ElemType m;

	InitStack(S);//初始化
	flag = StackEmpty(S);
	if (flag) {
		printf("栈是空的\n");
	}

	//入栈
	Push(S, 3);
	Push(S, 4);
	Push(S, 5);

	//获取栈顶元素
	flag = GetTap(S, m);
	if (flag) {
		printf("获取栈顶元素为%d\n", m);
	}

	//出栈
	flag = Pop(S, m); //弹出栈顶元素
	if (flag) {
		printf("弹出元素为%d\n", m);
	}
 	return 0;
}

链式存储实现栈（链栈）
头部插入法
头部删除法

队列

队列简称队，也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。

循环队列

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 5  //只能存四个元素
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize]; //数组 存储MaxSize - 1个元素
	int front, rear;//队列头，队列尾
}SqQueue;
//初始化
void InitQueue(SqQueue& Q) {
	Q.front = 0;
	Q.rear = 0;
}
//判断是否为空
bool isEmpty(SqQueue Q) {
	if (Q.front == Q.rear) {
		return true;
	}
	return false;
}
//入队
bool EnQueue(SqQueue& Q,ElemType x) {
	if ((Q.rear+1)%MaxSize==Q.front) 
		return false;//队列满了
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;//往后移一格
	return true;
}
//出队
bool DeQueue(SqQueue& Q, ElemType &x) {
	if (Q.rear == Q.front)
		return false;//队列为空
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;
	return true;
}
int main() {
	SqQueue Q;
	bool ret;//存储返回值
	ElemType e;//存储出队元素
	InitQueue(Q);//初始化循环队列
	ret = isEmpty(Q);
	if (ret) {
		printf("队列为空\n");
	}
	else {
		printf("队列不为空\n");
	}
	//入队
	EnQueue(Q, 3);
	EnQueue(Q, 4);
	EnQueue(Q, 5);
	ret = EnQueue(Q, 6);
	ret = EnQueue(Q, 7);
	if (ret) {
		printf("入队成功\n");
	}
	else {
		printf("入队失败\n");
	}
	//出队
	ret = DeQueue(Q, e);
	if (ret) {
		printf("出队成功，元素值为%d\n",e);
	}
	else {
		printf("出队失败\n");
	}
	//出队
	ret = DeQueue(Q, e);
	if (ret) {
		printf("出队成功，元素值为%d\n", e);
	}
	else {
		printf("出队失败\n");
	}
	return 0;
}

队列的链式存储

队列的链式存储称为链队列，它实际上是一个同时带有头指针和队尾指针的单链表。头指针指向队头结点，尾指针指向队尾结点，即单链表的最后一个结点。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct LinkNode {
	ElemType data;
	struct LinkNode* next;//链表结点的结构体
}LinkNode;
typedef struct {
	LinkNode* front, * rear;//链表头 链表尾
}LinkQueue;//先进先出

void InitQueue(LinkQueue& Q) {
	Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode));//头和尾指向同一个结点
	Q.front->next = NULL;//头结点的next指针为NULL
}
//入队 尾部插入法
void EnQueue(LinkQueue& Q, ElemType e) {
	LinkNode *s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = e;
	s->next = NULL;
	Q.rear->next = s;
	Q.rear = s;
}

//出队 头部删除法
bool DeQueue(LinkQueue& Q, ElemType &x) {
	if (Q.front == Q.rear)
		return false;//队列为空
	LinkNode* p = Q.front->next;//头结点什么都没有存，所以结点的下一个结点才有数据
	x = p->data;
	Q.front->next = p->next;//断链
	if (Q.rear == p)//删除的是最后一个元素
		Q.rear = Q.front;//队列置为空
	free(p);
	return true;
}
int main() {
	LinkQueue Q;
	bool ret;
	ElemType element;
	InitQueue(Q);//初始化队列
	EnQueue(Q, 3);
	EnQueue(Q, 4);
	EnQueue(Q, 5);
	EnQueue(Q, 6);
	EnQueue(Q, 7);

	ret = DeQueue(Q, element);

	if (ret) {
		printf("出队成功，元素值为%d", element);
	}
	else {
		printf("出队失败\n");
	}
	system("pause");

	//ret = DeQueue(Q, element);

	//if (ret) {
	//	printf("出队成功，元素值为%d", element);
	//}
	//else {
	//	printf("出队失败\n");
	//}
	//system("pause");
	return 0;
}