数据结构学习

最新推荐文章于 2024-08-06 10:44:34 发布
最新推荐文章于 2024-08-06 10:44:34 发布
阅读量31 收藏
点赞数
文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71637218/article/details/132002323
版权

顺序栈

定义

顺序栈（Sequential Stack），也称为数组栈，是一种使用数组实现的栈数据结构。栈是一种遵循后进先出（Last-In-First-Out，LIFO）原则的数据结构，即最后入栈的元素最先出栈。

特点

使用数组来存储栈元素，通过数组的下标来实现栈的操作。

栈有一个指针（通常称为栈顶指针），指向当前栈顶元素在数组中的位置。

栈顶指针初始化为-1表示栈为空，当有元素入栈时，栈顶指针增加；当元素出栈时，栈顶指针减少。

代码实现

定义

typedef struct MyStack {
	int* element_top;//栈顶指针
	int* element_base; //栈底指针
	int capacity; ///栈容量
}MyStack;

初始化

void InitStack(MyStack* ps) {
	ps->element_top = NULL;
	ps->element_base = (int*)malloc(sizeof(int) * INITCAPACITY);
	if (ps->element_base == NULL) {
		printf("内存分配失败\n");
		exit(OUTMEMORY);
	}
	ps->capacity = INITCAPACITY;
}

判空

bool IsEmpty(MyStack* ps) {
	return ps->element_top == ps->element_base;
}

判满

bool IsFull(MyStack* ps) {
	return ps->element_base + ps->capacity == ps->element_top;
}

入栈

int Push(MyStack* ps, int val) {
	if (IsFull(ps) && Grow(ps)) {
		return OUTMEMORY;
	}
	else {
		*ps->element_top++ = val;
		return OK;
	}
}

栈满扩容

bool Grow(MyStack* ps) {
	int newlen = ps->capacity * INC_NUM;
	int* p = (int*)realloc(ps->element_base, newlen);
	if (p != NULL) {
		return false;
	}
	else {
		ps->element_base = p;
		ps->element_top = ps->element_base + ps->capacity;
		ps->capacity = newlen;
	}
}

出栈

int Pop(MyStack* ps) {
	if (IsEmpty(ps)) {
		return ERROR;
	}
	else {
		ps->element_top--;
		return OK;
	}
}

获取栈顶元素

int GetTop(MyStack* ps, int* val) {
	if (IsEmpty(ps)) {
		*val = 0;
		return ERROR;
	}
	else
	{
		*val = *(ps->element_top-1);
		return OK;
	}
}

获取栈中有效元素个数

int GetSize(MyStack* ps) {
	return ps->element_top - ps->element_base;
}

清空栈

void ClearStack(MyStack* ps) {
	memset(ps->element_base, 0,sizeof(int) * ps->capacity);
	ps->element_top = ps->element_base;
}

销毁栈

void DestoryStack(MyStack* ps) {
	free(ps->element_base);
	ps->element_base = NULL;
	ps->element_top = NULL;
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
//顺序栈  顺序表模拟栈  --> 尾插尾删O(1)
#define OK				1
#define ERROR		2
#define OUTMEMORY		3 //内存不足
#define INITCAPACITY	10  //栈初始容量
#define INC_NUM			1.5   //扩容大小


typedef struct MyStack {
	int* element_top;//栈顶指针
	int* element_base; //栈底指针
	int capacity; ///栈容量
}MyStack;

//初始化
void InitStack(MyStack* ps) {
	ps->element_base = ps->element_top=(int*)malloc(sizeof(int) * INITCAPACITY);
	assert(ps->element_top != NULL);
	ps->capacity = INITCAPACITY;
}
bool IsEmpty(MyStack* ps) {
	return ps->element_top == ps->element_base;
}
bool IsFull(MyStack* ps) {
	return ps->element_base + ps->capacity == ps->element_top;
}
//入栈操作
bool Grow(MyStack* ps) {
	int newlen = ps->capacity * INC_NUM;
	int* p = (int*)realloc(ps->element_base, newlen);
	if (p != NULL) {
		return false;
	}
	else {
		ps->element_base = p;
		ps->element_top = ps->element_base + ps->capacity;
		ps->capacity = newlen;
	}
}
int Push(MyStack* ps, int val) {
	if (IsFull(ps) && Grow(ps)) {
		return OUTMEMORY;
	}
	else {
		*ps->element_top++ = val;
		return OK;
	}
}
//出栈操作
int Pop(MyStack* ps) {
	if (IsEmpty(ps)) {
		return ERROR;
	}
	else {
		ps->element_top--;
		return OK;
	}
}
//获取栈顶元素
int GetTop(MyStack* ps, int* val) {
	if (IsEmpty(ps)) {
		*val = 0;
		return ERROR;
	}
	else
	{
		*val = *(ps->element_top-1);
		return OK;
	}
}
//获取栈有效数据个数
int GetSize(MyStack* ps) {
	return ps->element_top - ps->element_base;
}
//清空栈
void ClearStack(MyStack* ps) {
	memset(ps->element_base, 0,sizeof(int) * ps->capacity);
	ps->element_top = ps->element_base;
}
//销毁栈
void DestoryStack(MyStack* ps) {
	free(ps->element_base);
	ps->element_base = NULL;
	ps->element_top = NULL;
}

顺序队列

定义

顺序栈（Sequential Stack）是一种使用数组实现的栈数据结构。栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构，意味着最后入栈的元素将首先被弹出

特点

  1. 基于数组实现：顺序栈的底层使用数组来存储栈中的元素，这使得对栈的访问速度很快，因为数组的元素是连续存储的。

  2. 固定大小：顺序栈的大小在创建时就被确定了，它的容量是固定的。当栈满时，无法再添加新的元素，除非进行扩容操作。

  3. 高效的入栈和出栈操作：由于栈是一种LIFO数据结构，顺序栈的入栈（push）和出栈（pop）操作都非常高效，时间复杂度为O(1)。

代码实现

定义

typedef struct MyQueue {
	int* queue_head;
	int* queue_tail;
	int capacity;
}MyQueue;

初始化

void InitQueue(MyQueue* pq) {
	pq->queue_head = pq->queue_tail = (int*)malloc(sizeof(int) * INITCAPACITY);
	pq->capacity = INITCAPACITY;
}

判空

bool IsEmpty(MyQueue* pq) {
	return pq->queue_tail == pq->queue_head;
}

判满

bool IsFull(MyQueue* pq) {
	return pq->queue_head + pq->capacity == pq->queue_tail;
}

队列满扩容

bool Grow(MyQueue* pq) {
	int newlen = pq->capacity * INC_NUM;
	int* p = (int*)realloc(pq->queue_head, sizeof(int) * newlen);
	if (p!=NULL)
	{
		pq->queue_head = p;
		pq->queue_tail = pq->queue_head +pq->capacity;
		pq->capacity = newlen;
	}
}

入队

int PushQueue(MyQueue* pq, int val) {
	if (IsFull(pq) && Grow(pq)) {
		return ERROR;
	}
	else {
		*pq->queue_tail++ = val;
		return OK;
	}
}

出队

int PopQueue(MyQueue* pq, int* val) {
	if (IsEmpty(pq)) {
		*val = 0;
		return ERROR;
	}
	else {
		*val = *pq->queue_tail;
		int* p = pq->queue_head;
		while (p != pq->queue_tail) {
			*p = *(p + 1);
		}
		pq->queue_tail--;
		return OK;
	}
}

获取队头元素

int GetTop(MyQueue* pq, int* pval) {
	if (IsEmpty(pq)) {
		*pval = 0;
		return OK;
	}
	else {
		*pval = *(pq->queue_head-1);
		return OK;
	}
}

获取队列有效元素个数

int GetSize(MyQueue* pq) {
	return pq->queue_tail - pq->queue_head;
}

清空队列

void ClearQueue(MyQueue* pq) {
	memset(pq->queue_head, 0, sizeof(int)*pq->capacity);
	pq->queue_tail = pq->queue_head;
}

销毁队列

void DestoryQueue(MyQueue* pq) {
	free(pq);
	pq->queue_head = NULL;
	pq->queue_tail = NULL;
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>
//顺序栈  顺序表模拟栈  --> 尾插尾删O(1)
#define OK				1
#define ERROR		2
#define OUTMEMORY		3 //内存不足
#define INITCAPACITY	10  //栈初始容量
#define INC_NUM			1.5   //扩容大小
typedef struct MyQueue {
	int* queue_head;
	int* queue_tail;
	int capacity;
}MyQueue;
void InitQueue(MyQueue* pq) {
	pq->queue_head = pq->queue_tail = (int*)malloc(sizeof(int) * INITCAPACITY);
	pq->capacity = INITCAPACITY;
}
bool IsEmpty(MyQueue* pq) {
	return pq->queue_tail == pq->queue_head;
}
bool IsFull(MyQueue* pq) {
	return pq->queue_head + pq->capacity == pq->queue_tail;
}
bool Grow(MyQueue* pq) {
	int newlen = pq->capacity * INC_NUM;
	int* p = (int*)realloc(pq->queue_head, sizeof(int) * newlen);
	if (p!=NULL)
	{
		pq->queue_head = p;
		pq->queue_tail = pq->queue_head +pq->capacity;
		pq->capacity = newlen;
	}
}
int PushQueue(MyQueue* pq, int val) {
	if (IsFull(pq) && Grow(pq)) {
		return ERROR;
	}
	else {
		*pq->queue_tail++ = val;
		return OK;
	}
}
int PopQueue(MyQueue* pq, int* val) {
	if (IsEmpty(pq)) {
		*val = 0;
		return ERROR;
	}
	else {
		*val = *pq->queue_tail;
		int* p = pq->queue_head;
		while (p != pq->queue_tail) {
			*p = *(p + 1);
		}
		pq->queue_tail--;
		return OK;
	}
}
int GetTop(MyQueue* pq, int* pval) {
	if (IsEmpty(pq)) {
		*pval = 0;
		return OK;
	}
	else {
		*pval = *(pq->queue_head-1);
		return OK;
	}
}
int GetSize(MyQueue* pq) {
	return pq->queue_tail - pq->queue_head;
}
void ClearQueue(MyQueue* pq) {
	memset(pq->queue_head, 0, sizeof(int)*pq->capacity);
	pq->queue_tail = pq->queue_head;
}
void DestoryQueue(MyQueue* pq) {
	free(pq);
	pq->queue_head = NULL;
	pq->queue_tail = NULL;
}

z53545556
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构学习笔记（王道）
qq_55593227的博客
03-19 4万+
数据结构学习笔记（王道） PS：本文章部分内容参考自王道考研数据结构笔记 文章目录数据结构学习笔记（王道）一、绪论1.1. 数据结构1.2. 算法1.2.1. 算法的基本概念1.2.2. 算法的时间复杂度1.2.3. 算法的空间复杂度二、线性表2.1. 线性表的定义和操作2.1.1. 线性表的基本概念2.1.2. 线性表的基本操作2.2. 顺序表2.2.1. 顺序表的基本概念2.2.2. 顺序表的实现2.2.3. 顺序表的基本操作2.3. 链表2.3.1. 单链表的基本概念2.3.2. 单链表的实现2.3.
数据结构学习指导·实验指导·课程设计.pdf
02-28
数据结构学习指导，何洁，陈媛版本，高清，供大家下载
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 41万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构学习心得
12-31 1万+
来源：我是码农，转载请保留出处和链接！ 本文链接：数据结构学习心得 山不在高，有仙则灵；水不在深，有龙则灵；要学好数据结构，有数据结构学习网才行！ 首先，恭喜您发现了这个网站：一个神奇的学习数据结构的网站！ 其次，感谢您打开这个网页阅读这篇文章，实在太感谢啦！ 再次，正在激动中......哽咽了。还是让我先来介绍一下我自己吧： 我就是江湖上人见人爱、花见花开、车见车载，人称上天入地...
数据结构学习——双向链表
weixin_62410421的博客
05-03 5033
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
从零起步：学习数据结构的完整路径
学IT，找陈寒
08-21 3361
数据结构是一个广泛的领域，需要持续的学习和实践。通过深入理解不同的数据结构和算法，你将能够更有效地解决问题、提升代码效率，并在编程领域中更具竞争力。无论你是初学者还是有一定经验的开发者，始终记得这条学习路径，它将帮助你逐步掌握数据结构的精髓。🧸结尾😊🙏。
数据结构学习总结
haiziccc的专栏
12-27 2483
数据结构学习心得——单链表
Xiaowei's Blog
08-17 1万+
一、线性表的存储结构 顺序表（顺序表操作见上一篇博客） 链表 在链表存储中，每个结点不仅包含所有的元素的信息，还包含元素之间逻辑关系的信息，如单链表中前驱结点包含后继结点的地址信息，这样就可以通过前驱结点中的地址信息找到后继结点的位置。 （2）单列表 在每个节点中除了包含数据域外，还包含一个指针域，用以指向其后继结点。下图所示为带头结点的单链表。 a.带头结点的单链表中，头指针head指
数据结构入门学习之数据结构学些什么？
maojiaoliang的博客
04-17 6551
首先在学习之前，我们先要了解通常计算机在解决一个问题具体有哪些步骤，见下图 而第一步将具体问题抽象为数学模型的实质是: 而这一步正是我们数据结构所学习的内容。 早期计算机只能做一些 ...
数据结构学习书籍
拾荒者
03-28 1万+
1.《大话数据结构》 2.《数据结构与算法分析--Java语言描述》 3.《数据结构和抽象问题求解--Java语言描述》 4.《算法导论》
数据结构学习指南资源整理
01-04
# 数据结构学习指南：如何利用网络资源掌握数据结构的知识和技能 数据结构是计算机科学的基础课程，它研究数据的逻辑结构和物理结构，以及数据之间的关系和操作。数据结构的选择和设计直接影响到算法的效率和程序的...
数据结构学习笔记1
01-07
数据结构数据结构 数据结构 基本概念和术语 数据：是客观事物的符号表示，能够输入到计算机中并能被计算机程序处理的符号的总称 数据元素：是数据的基本单位，用于完整地描述一个对象 数据对象：是性质相同的数据...
数据结构学习笔记.docx
12-02
数据结构学习笔记.docx
数据结构学习，数据结构学习
10-17
数据结构学习，数据结构学习
【数据结构】——堆的实现（赋源码）
最新发布
ZWW_zhangww的博客
08-06 298
堆(Heap)是中一类特殊的，是最高效的。堆通常是一个可以被看作一棵的数组对象。
数据结构系列文章目录
qq_31804097的博客
08-06 353
按章节顺序更新 望三连。
数据结构第九讲：二叉树
2301_79761834的博客
08-03 708
数据结构第九讲：二叉树
【数据结构】顺序表详解以及实现（C语言实现）
wheeldown的博客
08-06 264
存储密度高：顺序表的每一个节点都有对应的数据元素，没有额外开销，存储密度高访问性高：可以通过首地址然后i根据连续性找到后续相应的元素物理位置相邻：物理位置和逻辑位置一致，保持相邻，但这也意味着插入和删除操作可能涉及到大量元素的移动。顺序表分为静态顺序表和动态顺序表，静态顺序表在结构体中给的是定长数组，缺点很明显，所以我们主要讨论动态顺序表动态顺序表主要涉及的内存函数有malloc()和relloc()函数。动态顺序表主要有。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值