---

栈

什么是栈？

栈也是顺序表的一种，栈的逻辑实现是先进后出（后进先出）就跟子弹夹一样。
具体逻辑就是它只允许在固定的一端进行数据的插入与删除，在数据插入与删除的一端称为
栈顶，另一端称为栈低
压栈：插入数据的名称，在栈顶插入数据
出栈：删除数据的名称,   在栈顶删除数据

如图：

栈的具体实现

我们可以用双链表，单链表，数组来实现栈，
本文采用数组来实现栈，因为双链表的指针太多，浪费，单链表每次创建节点都需要去用操作系统
也是比较浪费资源。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdlib.h> //用于引用动态内存函数
#include<stdbool.h>//用于使用布尔类型
#include<assert.h>
typedef int Datatype;
typedef struct Stack {Datatype* arr;   //定义数组来实现栈。那么进栈与出栈的操作用尾插与尾删实现int capacity;   //已经申请的空间int top;       //用top的数值代表栈顶指针,指向第几个元素
}ST;
//栈的初始化
void StackInitialize(ST* p);
//判断空间是否足够，不够则扩容
void Deter(ST* p);
//进栈
void StackInsert(ST* p, Datatype x);
//出栈
void StackDelete(ST* p);
//返回栈顶的元素
Datatype StackTop(ST* p);
//求栈中元素的个数
int StackSize(ST* p);
//判断栈是否为空
bool StackEmpty(ST* p);
//栈的销毁
void StackDestory(ST* p);

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
//栈的初始化
void StackInitialize(ST*p) {//将栈的空间初始置为4个元素的大小p->arr = (Datatype *)malloc(4 * sizeof(Datatype));//栈的初始元素个数为0p->top = 0; //top的初始值为0代表，表示栈顶指针指向栈顶元素的下一个元素//这个栈顶指针的理解可以从p->size元素个数的角度理解//p-size-1就相当于栈顶指针指向的元素位置，p->size即元素的总个数//因为top代表栈顶指针指向栈顶的下一个元素，所以可以使用top-1来表示栈顶元素// 但是top为0时，则代表栈中没有元素，top-1也不能使用！                        p->capacity = 4;//初始化的空间为4个数据类型大小的空间
}
//判断空间是否足够，不够则扩容
void Deter(ST* p) {//判断空间是否足够，要看元素个数与空间个数是否相同//如果相同，则空间不足assert(p);if (p->top == p->capacity) {Datatype* p1 = realloc(p->arr, 2 * p->capacity * sizeof(Datatype));//如果扩展空间失败if (p1 == NULL) {printf("扩展空间失败\n");}//如果扩展空间成功，else {p->arr = p1;p->capacity = 2 * p->capacity;//记录增长二倍}}
}
//进栈
void StackInsert(ST*p,Datatype x) {assert(p);//先判断空间是否足够,如果不足，则扩容Deter(p);//从数组的尾部插入数据实现进栈p->arr[p->top++] = x;}
//出栈
void StackDelete(ST*p) {assert(p);//如果栈已经为空，还删除栈中内容则报错！assert(p->top > 0);p->top--;
}
//返回栈顶的元素
Datatype StackTop(ST *p) {assert(p);assert(p->top > 0);//栈不能为空，否则报错return p->arr[p->top - 1];
}
//求栈中元素的个数
int StackSize(ST*p) {assert(p);return p->top;
}
//判断栈是否为空
bool StackEmpty(ST*p) {assert(p);//查询栈中元素的个数即可if (p->top == 0) {//false表示为空return false;}else {return true;}
}
//栈的销毁
void StackDestory(ST *p) {assert(p);//栈的销毁需要先释放掉申请的空间free(p->arr);p->arr = NULL;p->top = p->capacity = 0;
}

队列

什么是队列？

队列也是线性表的一种，它的规则是只能在队列的一端插入数据，在另一端删除数   据，简称为：先进先出
出队列：进入数据删除的一端称为队头
入队列：进行数据插入的一端称为队尾

队列的实现

队列可以由数组，单链表，与双链表实现，
数组实现时，如果删除数据后，还需再挪动整个队列中的数据移动
双链表的指针太多，
所以我采用单链表:
进行尾插与头删

#pragma once  //用于避免头文件被重复引用
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
//定义存储的数据类型
typedef int Datatype; //用单链表来实现队列
typedef struct QueueNode {Datatype data;struct QueueNode* Next;
}QN;
//初始化队列：
//因为要改变头指针，所以需要用二级指针
void QueueInitialize(QN** pphead);
//队尾入
//采用尾插法来实现
void QueueInsert(QN* phead, Datatype x);
//队头出
//出队列的实现用头删法
//因为头指针需要改变，所以用二级指针作为形参
void QueueDelete(QN** pphead);
//获取队头的数据
Datatype QueueFront(QN* phead);
//获取队尾的数据
Datatype QueueTail(QN* phead);
//获取队列中元素的个数
int QueueSize(QN* phead);
//判断队列是否为空
bool QueueEmpty(QN* phead);
//销毁队列
void QueueDestory(QN** phead);

#include"Queue.h"
//初始化队列：
//因为要改变头指针，所以需要用二级指针
void QueueInitialize(QN**pphead) {*pphead = NULL;
}
//队尾入
//采用尾插法来实现
void QueueInsert(QN*phead,Datatype x) {//先找到队尾QN* temp = phead;while (temp!= NULL) {temp = temp->Next;}temp = (QN*) malloc (sizeof(QN)); //创建一个新节点temp->data = x; //赋值temp->Next = NULL;}
//队头出
//出队列的实现用头删法
//因为头指针需要改变，所以用二级指针作为形参
void QueueDelete(QN**pphead) {//头删时，首节点不能为空assert(*pphead&&pphead);QN* tem = *pphead;*pphead = (*pphead)->Next;//将头指针指向第二个节点free(tem); //释放掉tem中指针指向的空间
}
//获取队头的数据
Datatype QueueFront(QN *phead) {assert(phead); //phead不能为空。return phead->data;
}
//获取队尾的数据
Datatype QueueTail(QN* phead) {assert(phead);QN* tem = phead;while (tem->Next!=NULL) {tem = tem->Next;}//找到尾节点后return tem->data;
}
//获取队列中元素的个数
int QueueSize(QN*phead) {int size = 0;QN* tem = phead;while (tem != NULL) {tem = tem->Next;size++;}return size;
}
//判断队列是否为空
bool QueueEmpty(QN*phead) {//如果队列为空，返回trueif (phead == NULL)return true;//如果队列不为空,返回falseelsereturn false;
}
//销毁队列
void QueueDestory(QN **phead) {assert(*phead&&phead);//销毁队列从头节点开始释放QN* tem = *phead;//当前节点不为空，就一直执行while (tem != NULL) {//先将现在节点的下一个节点地址放在cur变量中QN* cur = tem->Next;free(tem);tem = cur;}*phead = NULL;
}