数据结构：栈和队列

最新推荐文章于 2024-08-18 19:23:29 发布

卖报的artist

最新推荐文章于 2024-08-18 19:23:29 发布

阅读量43

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_47356451/article/details/131635610

版权

本文介绍了栈和队列这两种基本数据结构。栈是一种后进先出（LIFO）的数据结构，支持在栈顶进行插入和删除操作。文章提供了栈的顺序存储和链式存储的C语言实现。队列则是先进先出（FIFO）的数据结构，支持在队尾插入元素，在队头删除元素。文中同样展示了循环队列和链式队列的实现方式。

摘要由CSDN通过智能技术生成

栈

栈的概念

栈的定义

栈（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。
判断数：设一个判断数ｓ，入队ｓ＝１，出队ｓ＝０，队满：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;
}