栈(Stack)和队列(Queue)

什么是栈（栈存储结构）
顺序栈及基本操作（包含入栈和出栈）
什么是队列（队列存储结构）
链式队列及基本操作（C语言实现）
用C语言实现栈及各个功能（数组）
用C语言实现队列及各个功能（链表）
栈和队列的主要区别

1. 什么是栈（栈存储结构）

同顺序表和链表一样，栈也是用来存储逻辑关系为 "一对一" 数据的线性存储结构

队列存储结构的实现有以下两种方式：

顺序栈：在顺序表的基础上实现的栈结构；
链栈：在链表的基础上实现的栈结构；

基于栈结构的特点，在实际应用中，通常只会对栈执行以下两种操作：

向栈中添加元素，此过程被称为"进栈"（入栈或压栈）；
从栈中提取出指定元素，此过程被称为"出栈"（或弹栈）；

栈特点：栈是一种只能从表的一端存取数据且遵循 "先进后出" 原则的线性存储结构。

2.顺序栈及基本操作（包含入栈和出栈）

顺序栈，即用顺序表实现栈存储结构。使用栈存储结构操作数据元素必须遵守 "先进后出" 的原则。

用栈存储结构存储 {1,2,3,4}，其存储状态如图所示：

入栈：1，2，3，4

出栈：4，3，2，1

3. 什么是队列（队列存储结构）

队列，和栈一样，也是一种对数据的"存"和"取"有严格要求的线性存储结构。
与栈结构不同的是，队列的两端都"开口"，要求数据只能从一端进，从另一端出。

通常，称进数据的一端为 "队尾"，出数据的一端为 "队头"，数据元素进队列的过程称为 "入队"，出队列的过程称为 "出队"。如图所示：

队列存储结构的实现有以下两种方式：

顺序队列：在顺序表的基础上实现的队列结构；
链队列：在链表的基础上实现的队列结构；

4.链式队列及其操作

链式队列，简称"链队列"，即使用链表实现的队列存储结构。

需创建两个指针（命名为 top 和 rear）分别指向链表中队列的队头元素和队尾元素，如图所示:

入列如图所示·：

入列：1，2，3，4

出列：1，2，3，4

4.用C语言实现栈及各个功能（数组）

//动态栈(数组）（可动态增容）
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int  top;//栈顶下标
	int  capacity;
}Stack;
//栈的初始化
void StackInit(Stack* ps)
{
	ps->a = malloc(sizeof(STDataType) * 4);
	ps->top = 0;
	ps->capacity = 4;
}
//入栈
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	ps->a[ps->top] = data;
	ps->top++;
	if (ps->top == ps->capacity) {
		ps->capacity *= 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * ps->capacity);
		if (tmp == NULL) {
			printf("Apply error!");
			exit(-1);
		}
		else
			ps->a = tmp;
	}
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//获取栈中个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	if (ps->top == 0)
		return 1;
	else
		return 0;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

6.用C语言实现队列及各个功能（链表）

//队列的链表结构
typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;
//初始化队列
void QueueInit(Queue* ps)
{
	assert(ps);
	ps->head =ps->tail = NULL;
}
//销毁队列
void QueueDestroy(Queue* ps)
{
	QueueNode* cur = ps->head;
	while (cur) {
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	ps->head = ps->tail = NULL;
}
// 队尾入队列 
void QueuePush(Queue* ps, QDataType data)
{
	QueueNode* NewNode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NewNode == NULL) {
		printf("apply erroe!");
		exit(-1);
	}
	else
		NewNode->data = data;
	    NewNode->next = NULL;
	if (ps->head == NULL) {
			ps->head = ps->tail = NewNode;
	 }
	else {
		ps->tail->next = NewNode;
		ps->tail = NewNode;
	}

}
// 队头出队列
void QueuePop(Queue* ps)
{
	assert(ps);
	assert(ps->head);
	QueueNode* next = ps->head->next;
	free(ps->head);
	ps->head = next;
	if (ps->head == NULL) {
		ps->tail = NULL;
	}
}
// 获取队列头部元素 
QDataType QueueFront(Queue* ps)
{
	assert(ps);
	assert(ps->head);
	return ps->head->data;
}
// 获取队列队尾元素 
QDataType QueueBack(Queue* ps)
{
	assert(ps);
	assert(ps->head);
	return ps->tail->data;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* ps)
{
	assert(ps);
	if (ps->head == NULL)
		return 1;
	else
		return 0;
}
// 获取队列中有效元素个数
int QueueSize(Queue* ps)
{
	assert(ps);
	QueueNode* cur = ps->head;
	QDataType size = 0;
	while (cur) {
		size++;
		cur = cur->next;
	}
	return size;
}

7.栈和队列的主要区别

队列（Queue）：是限定只能在表的一端进行插入和在另一端进行删除操作的线性表；
栈（Stack）：是限定只能在表的一端进行插入和删除操作的线性表。
一、规则不同
1. 队列：先进先出（First In First Out）FIFO
2. 栈：先进后出（First In Last Out ）FILO
二、对插入和删除操作的限定不同
1. 队列：只能在表的一端进行插入，并在表的另一端进行删除；
2. 栈：只能在表的一端插入和删除。
三、遍历数据速度不同
1. 队列：基于地址指针进行遍历，而且可以从头部或者尾部进行遍历，但不能同时遍历，无需开辟空间，因为在遍历的过程中不影响数据结构，所以遍历速度要快；
2. 栈：只能从顶部取数据，也就是说最先进入栈底的，需要遍历整个栈才能取出来，而且在遍历数据的同时需要为数据开辟临时空间，保持数据在遍历前的一致性。