数据结构_栈和队列

最新推荐文章于 2024-07-12 17:39:03 发布
最新推荐文章于 2024-07-12 17:39:03 发布
阅读量124 收藏
点赞数
分类专栏： 数据结构（c语言版）严蔚敏 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44068234/article/details/118756091
版权

栈和队列

栈

栈是仅在表尾进行插入或删除的线性表，特性是LIFO（last in first out）。

数据结构中的栈属于线性表，是顺序表的操作子集。

顺序栈代码

在这里插入图片描述

ADT

///Sqstack.h
#pragma once

#include<stdbool.h>
#include<stdio.h>
#define MAX 100  //栈最大值

//栈数据元素（更改数据元素，修改基本元素结构体和接口的实现即可）
typedef struct item{
	//数据项
	int data;

	bool operator==(const item& a) {
		return data==a.data;
	}
}Item;

typedef struct {
	Item* top;
	Item* bottom;
	int max;
}Stack;

typedef Stack* Sqstack;

//栈初始化
bool Sqstackinit(Sqstack L);

//入栈
bool Push(Sqstack L, Item e);

//出栈
bool Pop(Sqstack L, Item &e);

//栈取值
bool GetItem(const Sqstack L, Item& e);

接口实现

#include<stdio.h>
#include<stdlib.h>
#include"Sqstack.h"

//栈初始化
bool Sqstackinit(Sqstack S) {
	S->bottom = new Item[MAX];
	if (!S->bottom)
		return false;
	S->top = S->bottom;
	S->max = MAX;
	return true;
}

//入栈
bool Push(Sqstack S, Item e) {
	if (S->top - S->bottom == S->max)
		return false;
	*S->top++ = e;
	return true;
}

//出栈
bool Pop(Sqstack S, Item& e) {
	if (S->top == S->bottom)
		return false;
	e = *--S->top;
	return true;
}

//栈取值
bool GetItem(const Sqstack S, Item& e) {
	if (!S->bottom)
		return false;
	e = *(S->top - 1);
	return true;
}

void Sqstackfree(Sqstack S) {
	if (!S->bottom);
	else {
		free(S->bottom);
		fputs("freed\n", stdout);
	}
}

测试

#include<stdio.h>
#include<stdlib.h>
#include"Sqstack.h"

int main(int agrc, char* argv[]) {
	extern void Sqstackfree(Sqstack S);

	Item a = { 10 };
	Item a1 = { 11 };
	Item a2 = { 12 };
	Item a3,a4;
	Stack s;
	Sqstackinit(&s);
	Push(&s, a);
	Push(&s, a1);
	Push(&s, a2);
	Pop(&s, a3);
	GetItem(&s, a4);
	printf("%d\n", a4.data);
	Sqstackfree(&s);
}
/*
*vs2019输出
11
freed

D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 4208)已退出，代码为 0。
按任意键关闭此窗口. . .

*/

链栈代码

在这里插入图片描述

ADT

///Lkstack.h
#pragma once

#include<stdbool.h>
#include<stdio.h>

//栈数据元素（更改数据元素，修改基本元素结构体和接口的实现即可）
typedef struct item {
	//数据项
	int data;

	bool operator==(const item& a) {
		return data == a.data;
	}
}Item;

typedef struct Stack{
	Item e;
	struct Stack* next;
}Stack, *Lkstack;

//栈初始化
bool Lkstackinit(Lkstack& L);

//入栈
bool Push(Lkstack& L, Item e);

//出栈
bool Pop(Lkstack& L, Item& e);

//栈取值
bool GetItem(const Lkstack L, Item& e);

接口实现

#include<stdio.h>
#include<stdlib.h>
#include"Lkstack.h"

//栈初始化
bool Lkstackinit(Lkstack& L) {
	L = NULL;
	return true;
}

//入栈
bool Push(Lkstack& L, Item e) {
	Lkstack p = new Stack;
	p->e = e;
	p->next = L;
	L = p;
	return true;
}

//出栈
bool Pop(Lkstack& L, Item& e) {
	if (!L)
		return false;
	e = L->e;
	Lkstack p = L;
	L = L->next;
	delete p;
	return true;
}

//栈取值
bool GetItem(const Lkstack L, Item& e) {
	if (!L)
		return false;
	e = L->e;
	return true;
}

void Lkstackfree(Lkstack& L) {
	Lkstack p = NULL;
	while (L) {
		p = L->next;
		delete L;
		L = p;
	}
	if(!p)
		printf("freed");
}

测试

#include<stdio.h>
#include<stdlib.h>
#include"Lkstack.h"

int main(int agrc, char* argv[]) {
	void Lkstackfree(Lkstack & L);
	Lkstack s;
	Lkstackinit(s);
	Item a = { 10 };
	Item a1 = { 11 };
	Item a2 = { 12 };
	Item a3,a4;
	Push(s, a);
	Push(s, a1);
	Push(s, a2);
	Pop(s, a3);
	GetItem(s, a4);
	printf("%d\n", a4.data);
	Lkstackfree(s);
}
/*
*vs2019输出
11
freed

D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 4208)已退出，代码为 0。
按任意键关闭此窗口. . .

*/

栈的实例(进制转换和括号匹配)

实现进制转换
（修改链栈测试的代码即可实现）

#include<stdio.h>
#include<stdlib.h>
#include"Lkstack.h"

int main(int agrc, char* argv[]) {
	void Lkstackfree(Lkstack & L);
	Lkstack s;
	Lkstackinit(s);
	
	int n = 15;
	while (n) {
		Item a = { n % 2 };
		Push(s, a);
		n /= 2;
	}
	while (s) {
		Item a;
		Pop(s, a);
		printf("%d", a.data);
	}
	printf("\n");
	Lkstackfree(s);
}
/*
1111
freed
D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 1308)已退出，代码为 0。
按任意键关闭此窗口. . .

*/

实现括号匹配
（修改链栈测试的代码即可实现）

#include<stdio.h>
#include<stdlib.h>
#include"Lkstack.h"

int main(int agrc, char* argv[]) {
	void Lkstackfree(Lkstack & L);
	Lkstack s;
	Lkstackinit(s);
	
	int flag = 1;        //匹配flag
	int flag1 = 1;		 //出错位数
	int flag2 = 0;       //无括号匹配成功情况
	printf("输入括号字符串，以#结尾\n");

	char ch;
    ch = getchar();
	while (ch != '#' && flag) {
		Item e = { ch };
		switch (ch) {
		case '{':
		case '[':
		case '(':
			Push(s, e);
			break;
		case ')':
			Item e1;
			GetItem(s, e1);
			if (s && e1.data == '(') {
				Pop(s, e1);
				++flag2;
			}
			else
				flag = 0;
			break;
		case ']':
			Item e2;
			GetItem(s, e2);
			if (s && e2.data == '[') {
				Pop(s, e2);
				++flag2;
			}
			else
				flag = 0;
			break;
		case '}':
			Item e3;
			GetItem(s, e3);
			if (s && e3.data == '{') {
				Pop(s, e3);
				++flag2;
			}
			else
				flag = 0;
			break;
		default:
			printf("the ch of %d input error\n",flag1);
			break;
		}
		ch = getchar();
		++flag1;

		if (ch == '\n') {
			ch = getchar();
			flag1 = 1;
		}
	}
	if (!s && flag && ((flag1)/2) == flag2) {
			printf("匹配成功\n");
	}
	else
		printf("匹配失败\n");

	Lkstackfree(s);
}
/*
输入括号字符串，以#结尾
safd
the ch of 1 input error
the ch of 2 input error
the ch of 3 input error
the ch of 4 input error
asdf{}
the ch of 1 input error
the ch of 2 input error
the ch of 3 input error
the ch of 4 input error
adsf{}#
the ch of 1 input error
the ch of 2 input error
the ch of 3 input error
the ch of 4 input error
匹配失败
freed
D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 1316)已退出，代码为 0。
按任意键关闭此窗口. . .


输入括号字符串，以#结尾
{{{{}(){[]}}}}()#
匹配成功
freed
D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 6760)已退出，代码为 0。
按任意键关闭此窗口. . .


*/

队列

队列是仅在一端插入一端删除的线性表，特性是FIFO（first in first out）。

数据结构中的队列属于线性表，是顺序表的操作子集。

顺序队列

如果使用如下操作表示的话，对于存储空间的利用率低，所以采用类似循环顺序表来实现循环队列。在这里插入图片描述
循环队列：采用取余的方式对于当前取值存储在队列位置的选择。前面说的选择顺序表的实现的话，大小为N的顺序表实现的是对N个数的队列实现，在rear结点达到最大值，而front结点也因为数据的出队列而后移，出现了从基地址开始到front结点之间空间的空闲，所以若到达rear的结点再接受数据时，考虑将这第N+1个数映射到存储空间大小为N的顺序表中，即(N+1)modN位置。这就实现了循环队列。

在这里插入图片描述

ADT

///Sqqueue.h
#pragma once

#include<stdbool.h>
#include<stdio.h>
#define MAX 100  //栈最大值

//栈数据元素（更改数据元素，修改基本元素结构体和接口的实现即可）
typedef struct item {
	//数据项
	int data;

	bool operator==(const item& a) {
		return data == a.data;
	}
}Item;

typedef struct {
	Item* base;
	int front;
	int rear;
}Queue;

//初始化
bool QueueInit(Queue& q);

//求队列长度
int Queuelen(const Queue q);

//入队
bool QueueEn(Queue& q,Item e);

//出队
bool QueueOut(Queue& q, Item &e);

//取头元素
bool GetItem(const Queue q, Item &e);

接口实现

#include<stdio.h>
#include<stdlib.h>
#include"Sqqueue.h"

//初始化
bool QueueInit(Queue& q) {
	q.base = new Item[MAX];
	if (!q.base)
		return false;
	q.front = q.rear = 0;
	return true;
}

//求队列长度
int Queuelen(const Queue q) {
	return (q.rear-q.front)%MAX;
}

//入队
bool QueueEn(Queue& q, Item e) {
	if ((q.rear + 1) % MAX == q.front)
		return false;
	q.base[q.rear] = e;
	q.rear = (q.rear + 1) % MAX;
	return true;
}

//出队
bool QueueOut(Queue& q, Item& e) {
	if (q.front==q.rear)
		return false;
	e=q.base[q.front];
	q.front = (q.front + 1) % MAX;
	return true;
}

//取头元素
bool GetItem(const Queue q, Item& e) {
	if (q.front == q.rear)
		return false;
	e = q.base[q.front];
	return true;
}

void Sqqueuefree(Queue& q) {
	if (q.base) {
		free(q.base);
		printf("freed");
	}
}

测试

#include<stdio.h>
#include<stdlib.h>
#include"Sqqueue.h"

int main(int agrc, char* argv[]) {
	extern void Sqqueuefree(Queue& q);

	Item a = { 10 };
	Item a1 = { 11 };
	Item a2 = { 12 };
	Item a3,a4;
	Queue q;
	
	QueueInit(q);
	QueueEn(q, a);
	QueueEn(q, a1);
	QueueEn(q, a2);

	
	QueueOut(q, a3);
	printf("%d\n", a3.data);
	GetItem(q, a4);
	printf("%d\n", a4.data);
	Sqqueuefree(q);
}
/*
*vs2019输出
10
11
freed
D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 1848)已退出，代码为 0。
按任意键关闭此窗口. . .


*/

链式队列

在这里插入图片描述

ADT

///Lkqueue.h
#pragma once

#include<stdbool.h>
#include<stdio.h>


//栈数据元素（更改数据元素，修改基本元素结构体和接口的实现即可）
typedef struct item {
	//数据项
	int data;

	bool operator==(const item& a) {
		return data == a.data;
	}
}Item;

typedef struct Queue{
	Item e;
	struct Queue* next;
}*Lqueue;

struct Lkqueue {
	Lqueue rear;
	Lqueue front;
};

//初始化
bool QueueInit(Lkqueue& q);

//入队
bool QueueEn(Lkqueue& q, Item e);

//出队
bool QueueOut(Lkqueue& q, Item& e);

//取头元素
bool GetItem(const Lkqueue q, Item& e);

接口实现

#include<stdio.h>
#include<stdlib.h>
#include"Lkqueue.h"

//初始化
bool QueueInit(Lkqueue& q) {
	q.front = q.rear = new Queue;
	q.front->next = NULL;
	return true;
}

//入队
bool QueueEn(Lkqueue& q, Item e) {
	q.rear->e = e;

	Lqueue p = new Queue;
	p->next = NULL;
	q.rear->next = p;
	q.rear = p;
	return true;
}

//出队
bool QueueOut(Lkqueue& q, Item& e) {
	if (q.front == q.rear) {
		printf("false\n");
		return false;
	}
		
	e = q.front->e;
	
	Lqueue q1 = q.front;
	q.front = q.front->next;
	delete q1;
}

//取头元素
bool GetItem(const Lkqueue q, Item& e) {
	if (q.front == q.rear)
		return false;
	e = q.front->e;
	return true;
}

//free
void Queuefree(Lkqueue& q) {
	while (q.front) {
		Lqueue q1 = q.front;
		q.front = q.front->next;
		delete q1;
	}
	if (!q.front)
		printf("freed");
}

测试

#include<stdio.h>
#include<stdlib.h>
#include"Lkqueue.h"

int main(int agrc, char* argv[]) {
	extern void Queuefree(Lkqueue & q);

	Item a = { 10 };
	Item a1 = { 11 };
	Item a2 = { 12 };
	Item a3,a4;
	Lkqueue q;
	
	QueueInit(q);
	QueueEn(q, a);
	QueueEn(q, a1);
	QueueEn(q, a2);

	
	QueueOut(q, a3);
	printf("%d\n", a3.data);
	GetItem(q, a4);
	printf("%d\n", a4.data);
	Queuefree(q);
}
/*
*vs2019输出
10
11
freed
D:\vs\Data_Struct\Debug\Data_Struct.exe (进程 11912)已退出，代码为 0。
按任意键关闭此窗口. . .


*/

总结区别

区别

二次异重构
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用数组实现堆栈 && 判断接收到的数据是否连续
zhandoushi的专栏
01-16 1850
<br />    用数组方法实现堆栈，栈顶在上，栈底在下。<br />struct _Stack{<br />     Item* elem;        //数组元素<br />     int top;               //栈顶<br />     int nMax;            //大小<br />};<br />typedef struct _Stack Stack;<br />typedef Stack*  pStack;<br /> <br />pStack Stack
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
【数据结构】栈和队列
最新发布
奋斗的小羊的博客
07-12 2223
栈超超超详解
数据结构_栈和队列(Stack & Queue)
QinMou
05-09 1015
栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则；队列具有先进先出FIFO(First In First Out)的原则。
数据结构___栈和队列的学习总结
而塞过的学习之旅
03-26 2536
概要 因为操作的需要现在重新学习了数据结构相关知识，故以此文来总结一下栈和队列的操作和基本知识  声明：因个人能力有限，本文仅是个人的学习记录笔记，有错误之处还望指出 栈和队列的基本概念和实现 1.栈的基本概念 栈的定义：栈是一种只能在一端进行插入和删除的线性表。其中允许进行插入和删除的一端称为栈顶 栈的特点：先进后出(FILO) 栈的存储结构：顺序栈和链式栈，实际上栈的本质是线性表，不过是加了操作限制 2.队列的基本概念 队列的定义：和栈类似都是操作受限制的线性表，只允许在一端进行插入(队尾：rea
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 1784
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
Java数据结构之栈和队列
fear_wolf的博客
10-24 1098
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 3712
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
C++数据结构：栈和队列的应用
攻城狮的博客
05-29 1944
C++ 是一种面向对象的编程语言，它提供了多种数据结构，前面文章已介绍过数组、链表、hash表，并用自己的方法实现。用于存储和操作数据的结构在STL中还有很多，其中两种常用的数据结构是栈和队列。本文将介绍栈和队列的概念，特点，实现方式和应用场景。
实验4栈和队列_栈_数据结构_creaturexqi_队列_
10-03
本实验主题为“实验4栈和队列”，由creaturexqi提供，旨在深入理解和实践两种基本的数据结构——栈和队列。我们将分别探讨这两种数据结构的概念、特点、操作以及在实际中的应用。 首先，让我们来看看栈（Stack）。...
JiSuanQi.rar_jisuanqi_栈和队列_计算器 数据结构
09-20
总的来说，这个项目提供了对数据结构栈和队列的实际应用案例，是学习和理解这些基础数据结构的好教材。通过阅读和分析源代码，可以深入了解如何在实际问题中运用这些抽象数据类型，并提高编程技能。同时，Visual C++...
数据结构_栈_队列_prim算法_
10-04
综上所述，这些代码示例涵盖了数据结构的基本操作和算法应用，对于学习和理解栈、队列、Prim算法以及链表和二叉树的处理技巧具有很高的价值。掌握这些基础知识对于提升编程能力和解决实际问题至关重要。
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构——排序（十种常用内排序算法）
qq_2210007943的博客
09-12 2728
数据结构——排序一级目录二级目录三级目录 一级目录 二级目录 三级目录
数据结构_特殊矩阵的压缩存储
qq_2210007943的博客
08-02 994
数据结构_特殊矩阵的压缩存储对称矩阵三角矩阵对角矩阵 压缩存储：对于一个矩阵之中的相同元素分配同一存储单元。 矩阵的压缩存储通常是将二维数据存储的矩阵映射到一维数组之中。 对称矩阵 若n阶矩阵满足a ij = a ji （1<=i,j<=n），称为n阶对称矩阵。 若n阶矩阵为对称矩阵，那么实现压缩存储，只需要对矩阵的含对角线的上三角进行存储。（如图的虚线框内）对于对称矩阵可以用上三角也可以用下三角，下三角的表达式容易推导，所以采用下三角，想用上三角的可以参考三角矩阵的内容。 我们需要把虚线框
数据结构_图的最短路径（Dijkstra和Folyd算法）
qq_2210007943的博客
08-13 779
图的最短路径Dijkstra 算法算法思想代码实现Folyd 算法二级目录三级目录 在平时开车的时候，去一个地方总是用的路线规划软件，对于路线的规划中，有行驶路程最短的，有经过收费站最少的。根据不同的需求，对于路径长度的度量做出改变，以经过收费站数目作为度量（图中将收费站表示为顶点），就是最简单的最短路径问题，用图的广度优先搜索就可以实现。而为了实际表达现实交通注重的行驶路程的代价或时间，常用有向连通网表示，习惯将路径上的第一个顶点称为源点，最后一个称为终点。 常见的最短路径问题： 从某个源点到其余顶
数据结构_查找—散列表
qq_2210007943的博客
09-06 577
数据结构——查找（散列表）
数据结构：栈和队列的判空操作
"判断链队列是否为空-数据结构 栈和队列" 在数据结构中，栈和队列是两种基本的线性数据结构，它们各有特定的操作规则和应用场景。本节主要聚焦于栈（Stack）和队列（Queue）的概念、表示以及它们在实际操作中的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值