栈
栈的概念
栈的定义
栈(Stack):是只允许在一端进行插入或删除的线性表。首先栈是一种线性表,但限定这种线性表只能在某一端进行插入和删除操作。
栈顶(Top):线性表允许进行插入删除的那一端。
栈底(Bottom):固定的,不允许进行插入和删除的另一端。
空栈:不含任何元素的空表。
栈又称为后进先出(Last In First Out)的线性表,简称LIFO结构
栈的存储结构
栈的顺序存储
代码如下,后进先出原则。
#define MAXSIZE 10 //定义栈中元素的最大个数
typedef int ElemType;
typedef struct{
ElemType data[MAXSIZE];
int top; //用于栈顶指针 栈空可以设置top=-1
int len; //统计栈的大小
}SqStack;
void InitStack(SqStack *S){
S->len=0;
S->top = -1; //初始化栈顶指针
}
/*插入元素e为新的栈顶元素*/
bool Push(SqStack *S, ElemType e){
//满栈
if(S->top == MAXSIZE-1){
return false;
}
S->top++; //栈顶指针增加一
S->data[S->top] = e; //将新插入元素赋值给栈顶空间
S->len++; //插入一个元素栈长度加1
return true;
}
/*若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR*/
bool Pop(SqStack *S, ElemType *e){
if(S->top == -1){
return false;
}
*e = S->data[S->top]; //将要删除的栈顶元素赋值给e
S->top--; //栈顶指针减一
S->len--; //出栈时长度减1
return true;
}
/*读栈顶元素*/
bool GetTop(SqStack S, ElemType *e){
if(S->top == -1){ //栈空
return false;
}
*e = S->data[S->top]; //记录栈顶元素
return true;
}
bool StackEmpty(SqStack S){
if(S.top == -1){
return true; //栈空
}else{
return false; //不空
}
}
//遍历栈
void StackPrint(SqStack *S) {
SqStack *x = (SqStack *)malloc(sizeof(SqStack));
*x = *S;
for (int i = 0; i < x->len; i++) {
printf("%d->", S->data[x->top--]);
}
printf("\n");
}
int main(){
SqStack *s = (SqStack *)malloc(sizeof(SqStack));
int e = 0;
InitStack(s);
printf("创建的栈由栈顶->栈底:");
Push(s, 1);
Push(s, 2);
Push(s, 3);
Push(s, 4);
Push(s, 5);
Push(s, 6);
StackPrint(s);
//出栈
Pop(s, e);
StackPrint(s);
//获取栈顶元素
GetTop(s, e);
return 0;
}
栈的链式存储结构
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10 //定义栈中元素的最大个数
typedef int ElemType;
#define TRUE 1
#define FALSE 0
typedef struct StackList {
ElemType data;
struct StackList *next, *top; //用于栈顶指针 栈空可以设置top=null
int len;
} StackList;
void InitStack(StackList *S) {
S->next = NULL;
S->len = 0;
S->top = NULL; //初始化栈顶指针
}
/*插入元素e为新的栈顶元素 前插法*/
bool Push(StackList *S, ElemType e) {
StackList *p = (StackList *)malloc(sizeof(StackList));
p->data = e;
p->next = S->top;
S->next = p;
S->top = p;
S->len++;
return true;
}
/*若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR*/
bool Pop(StackList *S, ElemType e) {
StackList *p = (StackList *)malloc(sizeof(StackList));
if (S->top == NULL)
return false;
e = S->top->data;
p = S->top; //顶点赋值给p
S->next = p->next; //栈指针后移动
S->top = S->top->next; //顶点指针后移动
free(p); //释放结点p
S->len--;
return true;
}
/*读栈顶元素*/
bool GetTop(StackList *S, ElemType e) {
if (S->top == NULL) { //栈空
return false;
}
e = S->top->data; //记录栈顶元素
printf("栈顶=%d\n", e);
return true;
}
bool StackEmpty(StackList *S) {
if (S->top == NULL) {
return true; //栈空
} else {
return false; //不空
}
}
void StackPrint(StackList *S) {
StackList *x = (StackList *)malloc(sizeof(StackList));
x = S;
for (int i = 0; i < S->len; i++) {
printf("%d->", x->next->data);
x = x->next;
}
printf("\n");
}
int main() {
StackList *s = (StackList *)malloc(sizeof(StackList));
int e = 0;
InitStack(s);
printf("创建的栈由栈顶->栈底:");
Push(s, 1);
Push(s, 2);
Push(s, 3);
Push(s, 4);
Push(s, 5);
Push(s, 6);
StackPrint(s);
GetTop(s, e);
//出栈
printf("出栈\n");
Pop(s, e);
StackPrint(s);
//获取栈顶元素
GetTop(s, e);
return 0;
}
队
队的基本概念
队的定义
队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。
队列是一种先进先出(First In First Out)的线性表,简称FIFO。允许插入的一端称为队尾,允许删除的一端称为队头。
队头(Front):允许删除的一端,又称队首。
队尾(Rear):允许插入的一端。
空队列:不包含任何元素的空表
队的存储结构
队的顺序存储
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10 //定义栈中元素的最大个数
typedef int ElemType;
typedef struct { //定义一个队列
int data[MAXSIZE];//定义一个数组
int front, rear;//定义队头指针和队尾指针
} SqQueue;
void InitQueue(SqQueue &Q) { //初始化队列
Q.front = Q.rear = -1;
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) { //入队
if (Q.rear == MAXSIZE - 1) { //判断队列是否满了,如果队列满了就无法进行入队操作,直接返回return false。
printf("队满,无法进行入队\n");
return false;
}
Q.rear = Q.rear + 1;//队尾指针往前移动一格
Q.data[Q.rear] = x;//把元素x放入此时队尾指针指向的队列位置
return true;
}
//出队
bool DeQueue(SqQueue &Q) { //出队
if (Q.rear == Q.front)//判断队列是否为空,如果队列为空就无法进行出队操作,直接返回return false。
return false;
printf("出队成功,出队的元素是:%d\n", Q.data [Q.front + 1]);
Q.front = Q.front + 1;//队头指针往前移动一格
return true;
}
bool Print(SqQueue &Q) { //输出队列元素
if (Q.rear == Q.front)
return false;
printf("队列的元素是:");
for (int i = Q.front + 1; i <= Q.rear; i++) {
printf("%d ", Q.data[i]);
}
printf("\n");
return true;
}
bool GetHead(SqQueue &Q) { //读取队头元素
if (Q.rear == Q.front)
return false;
printf("队头元素是:%d\n", Q.data [Q.front + 1]);
return true;
}
int main() {
SqQueue(Q);
InitQueue(Q);//初始化队列
EnQueue(Q, 1); //入队
EnQueue(Q, 2); //入队
EnQueue(Q, 3); //入队
EnQueue(Q, 4); //入队
EnQueue(Q, 5); //入队
EnQueue(Q, 6); //入队
Print(Q);//输出队列元素
GetHead(Q);//读取队头元素
DeQueue(Q);//出队
GetHead(Q);//读取队头元素
Print(Q);//输出队列元素
return 0;
}
循环队列(有空位置)
留一个空位置存放对头。省的判断队满和队空有冲突。
/*
可以通过设置计数器或设置一个判断数来判断队满和队空是否冲突。
计数器:可通过设置一变量size=0,入队时size++,出队时size–,队满:size==MAXSIZE(定义栈中元素的最大个数),队空:size==0。
判断数:设一个判断数s,入队s=1,出队s=0,队满:front == rear && s == 1,队空:front == rear && s == 0。
*/
队满条件:队尾指针的下一个位置是队头,即(Q.rear+1)%MAXSIZE == Q.front。
队空条件:Q.rear ==Q.front
![在这里插入图片描述](https://img-blog.csdnimg.cn/c176133cebd04b22a9d476ecfc19d9dd.png
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10 //定义栈中元素的最大个数
typedef int ElemType;
typedef struct { //定义一个队列
int data[MAXSIZE];//定义一个数组
int front, rear;//定义队头指针和队尾指针
} SqQueue;
void InitQueue(SqQueue &Q) { //初始化队列
Q.front = Q.rear = 0;
}
//入队
bool EnQueue(SqQueue &Q, ElemType x) { //入队
if ((Q.rear + 1) % MAXSIZE == Q.front) {
printf("队满,无法进行入队\n");
return false;
}
Q.rear = (Q.rear + 1) % MAXSIZE;//队尾指针往前移动一格
Q.data[Q.rear] = x;//把元素x放入此时队尾指针指向的队列位置
printf("入队成功,入队的元素是%d\n", x);
return true;
}
//出队
bool DeQueue(SqQueue &Q) { //出队操作(删除一个队头元素)
if (Q.front == Q.rear)
return false; //判空
int x = Q.data[(Q.front + 1) % MAXSIZE];
Q.front = (Q.front + 1) % MAXSIZE;
printf("出队的元素是:%d\n", x);
return true;
}
bool Print(SqQueue &Q) { //输出队列元素
if (Q.front == Q.rear)
return false;
printf("队列的元素是:");
if (Q.rear > Q.front) { //尾指针下标大于头指针下标
for (int i = (Q.front + 1) % MAXSIZE; i <= Q.rear; i++) {
printf("%d ", Q.data[i]);
}
}
if (Q.rear < Q.front) { //尾指针下标小于于头指针下标
for (int i = (Q.front + 1) % MAXSIZE; i < MAXSIZE; i++ ) { //先输出尾下标大于头下标的元素
printf("%d ", Q.data[i]);
}
for (int i = 0; i < Q.front ; i++) { //再输出小于头下标的元素
printf("%d ", Q.data[i]);
}
}
printf("\n");
return true;
}
bool GetHead(SqQueue &Q) { //获取队头元素
if (Q.front == Q.rear)
return false;
printf("队头元素是:%d\n", Q.data[(Q.front + 1) % MAXSIZE]);
return true;
}
int main() {
SqQueue(Q);
InitQueue(Q);//初始化队列
EnQueue(Q, 1); //入队
EnQueue(Q, 2); //入队
EnQueue(Q, 3); //入队
EnQueue(Q, 4); //入队
EnQueue(Q, 5); //入队
EnQueue(Q, 6); //入队
EnQueue(Q, 7); //入队
EnQueue(Q, 8); //入队
EnQueue(Q, 9); //入队
Print(Q);//输出队列元素
GetHead(Q);//读取队头元素
DeQueue(Q);//出队
DeQueue(Q);//出队
EnQueue(Q, 1); //入队
EnQueue(Q, 2); //入队
GetHead(Q);//读取队头元素
Print(Q);//输出队列元素
return 0;
}
链式队列(带头节点)
队列以链表的形式存储,并且规定只能从链表尾添加元素,链表头删除元素。
#include<stdio.h>
#include<stdlib.h>
typedef struct LinkNode//链式队列节点
{
int 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;//让节点指向空指针
}
//入队
bool EnQueue(LinkQueue &Q)
{
int b;
printf("请输入要入队的元素个数:");
scanf("%d", &b);
for (int i = 0; i < b;i++)//用循环进行多次入队操作
{
int x;
printf("请输入要入队的元素(一次输入一个数字):");
scanf("%d", &x);
LinkNode *s = (LinkNode*)malloc(sizeof(LinkNode));//用malloc函数申请空间给新的节点s
if (s == NULL)
{
printf("入队失败\n");
return false;
}
s->data = x;//把输入的数放进新节点
s->next = NULL;//让新节点指向空指针
Q.rear->next = s;//新节点插入到rear后
Q.rear = s;//修改表尾指针
printf("入队成功,入队的元素是:%d\n", x);
}
return true;
}
//出队
bool DeQueue(LinkQueue &Q)
{
if (Q.rear == Q.front)//判断是否空队
return false;
LinkNode *p = Q.front->next;//新建一个指针指向出队元素所在的那个节点
int x = p->data;//把队首元素的值放入x中
printf("出队的元素是:%d\n", x);
Q.front->next = p->next;//修改头节点的next指针
if (Q.rear == p)//此次是最后一个节点出队
Q.rear = Q.front;//修改rear指针
free(p);//释放指针p指向的元素所在的节点空间
return true;
}
//判空
bool EmptQueue(LinkQueue &Q)
{
if (Q.rear == Q.front)
{
printf("空队列\n");
return true;
}
else
printf("不是空队列\n");
return false;
}
//取队头元素
bool FrontQueue(LinkQueue &Q)
{
if (Q.rear == Q.front)
{
printf("空队,无队头元素\n");
return false;
}
printf("队头元素是:%d\n", Q.front->next->data);//打印队头指针指向的下一个节点的元素值
return true;
}
//输出队列元素
bool Print(LinkQueue &Q)
{
if (Q.front == Q.rear)//判空
{
printf("队列为空\n");
return false;
}
LinkNode *p = Q.front->next;//新建一个指针指向队首元素所在的节点
printf("队列的元素是:");
while (1)
{
printf("%d ", p->data);
if (p == Q.rear)//判断p是否指向队尾节点
{
printf("\n");
return true;
}
p = p->next;//节点p指向下一个节点
}
}
int main()
{
LinkQueue Q;
InitQueue(Q);//初始化
EnQueue(Q);//入队
FrontQueue(Q);//取队头元素
Print(Q);//输出队列所有元素
DeQueue(Q);//出队
Print(Q);//输出队列所有元素
EnQueue(Q);//入队
FrontQueue(Q);//取队头元素
Print(Q);//输出队列所有元素
EmptQueue(Q);//判空
DeleQueue(Q);//销毁队列
Print(Q);//输出队列所有元素
return 0;
}