嵌入式学习DAY22 --- 链式栈，队列，二叉树的存储、递归遍历、层次遍历（数据结构(1)

最新推荐文章于 2024-07-10 11:55:30 发布
最新推荐文章于 2024-07-10 11:55:30 发布
阅读量682 收藏 11
点赞数 24
分类专栏： 程序员 文章标签： 物联网 嵌入式硬件 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85014985/article/details/138882622
版权

收集整理了一份《2024年最新物联网嵌入式全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升的朋友。
img
img

如果你需要这些资料，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

STACK_OK

};
//创建
Stack *createStack();
//入栈
int pushStack(Stack *pStack,data_t tData);
//出栈
int popStack(Stack *pStack,data_t *pData);
//销毁
void destroyStack(Stack **ppStack);
//判断是否为空
int isEmpty(Stack *pStack);
#endif



> 
> ***2.stack.c ----------------------------------------------------- 如下***
> 
> 
>

#include <stdio.h>
#include “stack.h”
#include <stdlib.h>
#include <string.h>

//创建
Stack *createStack()
{
Stack *pStack = (Stack *)malloc(sizeof(Stack));
if(NULL == pStack)
{

	return NULL;
}
pStack->pHead = NULL;
pStack->count = 0;
return pStack;

}
//入栈
int pushStack(Stack *pStack,data_t tData)
{
if(NULL == pStack)
{
return STACK_ERROR;
}
StackNode *pNode = (StackNode*)malloc(sizeof(StackNode));
memset(pNode,0,sizeof(StackNode));
pNode->data = tData;

if(NULL == pStack->pHead)
{
	pStack->pHead = pNode;
	pStack->count++;
	return STACK_OK;
}
pNode->pNext = pStack->pHead;
pStack->pHead = pNode;
pStack->count++;
return STACK_OK;

}
//出栈
int popStack(Stack *pStack,data_t *pData)
{
if(NULL == pStack || NULL == pStack->pHead || NULL == pData)
{
return STACK_ERROR;
}
*pData = pStack->pHead->data;
if(1 == pStack->count)
{
free(pStack->pHead);
pStack->pHead = NULL;
pStack->count–;
return STACK_OK;
}
StackNode *pTemp = pStack->pHead;
pStack->pHead = pStack->pHead->pNext;
free(pTemp);
pTemp = NULL;
pStack->count–;

}
//销毁
void destroyStack(Stack **ppStack)
{
if(NULL == ppStack || NULL ==*ppStack || (*ppStack)->pHead)
{
return;
}
StackNode *pTemp = NULL;
while((*ppStack)->pHead != NULL)
{
pTemp = (*ppStack)->pHead;
(*ppStack)->pHead = (*ppStack)->pHead->pNext;
free(pTemp);
}
pTemp = NULL;
free(*ppStack);
*ppStack = NULL;

}
//判断是否为空栈
int isEmpty(Stack *pStack)
{
if(NULL == pStack)
{
return STACK_ERROR;
}
if(NULL == pStack->pHead)
{
return STACK_EMPTY;
}
return STACK_OK;
}



> 
> ***3.main.c ----------------------------------------------------- 如下***
> 
> 
>

#include <stdio.h>
#include “stack.h”
#include <string.h>
#include <stdlib.h>

int main(int argc, const char *argv[])
{
Stack *pStack = createStack();
if(NULL == pStack)
{
return -1;
}
data_t data;
int i;
for(i=0;i<5;i++)
{
pushStack(pStack,i);
}
while(STACK_EMPTY != isEmpty(pStack))
{
popStack(pStack,&data);
printf(“%d “,data);
}
printf(”\n”);
destroyStack(&pStack);
return 0;
}


### ***二.顺序队列的实现***



> 
> ***1.seqqueue.h ----------------------------------------------------- 如下***
> 
> 
>

#ifndef _QUEUE_H_
#define _QUEUE_H_
#define SIZE 5
typedef int data_t;

typedef struct Queue
{
data_t data[SIZE];
int iFront;
int iRear;
int count;
}Queue;

enum QUEUE_OP
{
QUEUE_ERR = -1,
QUEUE_OK,
QUEUE_EMPTY,
QUEUE_FULL
};

Queue *CreateQueue();
int enQueue(Queue *pQueue, data_t tData);
int deQueue(Queue *pQueue, data_t *pData);
int isEmpty(Queue *pQueue);
int isFull(Queue *pQueue);
void destroyQueue(Queue **ppQueue);

#endif



> 
> ***2.seqqueue.c ----------------------------------------------------- 如下***
> 
> 
>

#include<stdio.h>
#include “seqqueue.h”
#include <stdlib.h>
#include <string.h>

Queue *CreateQueue()
{
Queue *pQueue = (Queue *)malloc(sizeof(Queue));
if(NULL == pQueue)
{
return NULL;
}
memset(pQueue, 0, sizeof(Queue));
return pQueue;
}
int enQueue(Queue *pQueue, data_t tData)
{
if(NULL == pQueue)
{
return QUEUE_ERR;
}

pQueue->data[pQueue->iRear] = tData;
pQueue->iRear++;
pQueue->count++;
return QUEUE_OK;

}
int deQueue(Queue *pQueue, data_t *pData)
{
if(NULL == pQueue || NULL == pData)
{
return QUEUE_ERR;
}
//先将原来的值保存起来
//再移动队头
*pData = pQueue->data[pQueue->iFront];
pQueue->iFront++;
pQueue->count–;
return QUEUE_OK;
}
int isEmpty(Queue *pQueue)
{
if(NULL == pQueue)
{
return QUEUE_ERR;
}
if(0 == pQueue->count)
{
return QUEUE_EMPTY;
}
return QUEUE_OK;
}
int isFull(Queue *pQueue)
{
if(NULL == pQueue)
{
return QUEUE_ERR;
}
if(SIZE == pQueue->count)
{
return QUEUE_FULL;
}
return QUEUE_OK;
}

void destroyQueue(Queue **ppQueue)
{
if(NULL == ppQueue || NULL == *ppQueue)
{
return;
}
free(*ppQueue);
*ppQueue = NULL;
}



> 
> ***3.main.c ----------------------------------------------------- 如下***
> 
> 
>

#include<stdio.h>
#include “seqqueue.h”

int main()
{
Queue *pQueue = CreateQueue();

data_t data;
while(QUEUE_FULL != isFull(pQueue))
{
	scanf("%d", &data);
	enQueue(pQueue, data);
}


printf("出队的结果为：");
while(QUEUE_EMPTY != isEmpty(pQueue))
{
	deQueue(pQueue, &data);
	printf("%d ", data);
}
printf("\n");
destroyQueue(&pQueue);
return 0;

}


### ***三.链式队列的实现***


![在这里插入图片描述](https://img-blog.csdnimg.cn/20210323192509648.png)  
 定义结构体：

Struct QueueNode
{
Data_t data;
Struct QueueNode *pNext;
};

Struct Queue
{
Struct QueueNode *pHead;
Struct QueueNode *pTail;
Int count;
};


代码实现:



> 
> ***1.queue.h ----------------------------------------------------- 如下***
> 
> 
>

#ifndef _QUEUE_H_
#define _QUEUE_H_

typedef int data_t;

typedef struct QueueNode
{
data_t data;
struct QueueNode *pNext;
}QueueNode;

typedef struct Queue
{
QueueNode *pHead;
QueueNode *pTail;
int count;
}Queue;

enum QUEUE_OP
{
QUEUE_ERR = -1,
QUEUE_OK,
QUEUE_EMPTY
};

Queue *createQueue();
int enQueue(Queue *pQueue, data_t tData);
int deQueue(Queue *pQueue, data_t *pData);
int isEmpty(Queue *pQueue);
void destroyQueue(Queue **ppQueue);

#endif



> 
> *2.**queue.c ----------------------------------------------------- 如下***
> 
> 
>

#include<stdio.h>
#include “queue.h”
#include <stdlib.h>
#include <string.h>

Queue *createQueue()
{
Queue *pQueue = (Queue *)malloc(sizeof(Queue));
if(NULL == pQueue)
{
return NULL;
}
memset(pQueue, 0, sizeof(Queue));
return pQueue;
}

int enQueue(Queue *pQueue, data_t tData)
{
if(NULL == pQueue)
{
return QUEUE_ERR;
}

QueueNode \*pNode = (QueueNode \*)malloc(sizeof(QueueNode));
if(NULL == pNode)
{
	return QUEUE_ERR;
}
memset(pNode, 0, sizeof(QueueNode));
pNode->data = tData;
//当为空队列时，需要单独处理
if(0 == pQueue->count)
{
	pQueue->pHead = pNode;
	pQueue->pTail = pNode;
	pQueue->count++;
	return QUEUE_OK;
}
pQueue->pTail->pNext = pNode;
//更新pTail
pQueue->pTail = pNode;
pQueue->count++;
return QUEUE_OK;

}

int deQueue(Queue *pQueue, data_t *pData)
{
if(NULL == pQueue)
{
return QUEUE_ERR;
}
QueueNode *pDel = pQueue->pHead;
*pData = pDel->data;

pQueue->pHead = pDel->pNext;
free(pDel);
pDel = NULL;
pQueue->count--;
return QUEUE_OK;

}
int isEmpty(Queue *pQueue)
{
if(NULL == pQueue)
{
return QUEUE_ERR;
}
if(0 == pQueue->count)
{
return QUEUE_EMPTY;
}
return QUEUE_OK;
}
void destroyQueue(Queue **ppQueue)
{
if(NULL == ppQueue || NULL == *ppQueue || NULL == (*ppQueue)->pHead)
{
return;
}

QueueNode \*pDel = (\*ppQueue)->pHead;
while(pDel != NULL)
{
	(\*ppQueue)->pHead = pDel->pNext;
	free(pDel);
	pDel = (\*ppQueue)->pHead;
}

free(\*ppQueue);
\*ppQueue = NULL;

}



> 
> ***3.main.c ----------------------------------------------------- 如下***
> 
> 
>

#include<stdio.h>
#include “queue.h”

int main()
{
Queue *pQueue = createQueue();
data_t data;

while(1)
{
	printf("请入队：");
	scanf("%d", &data);
	if(0 == data)
	{
		break;
	}
	enQueue(pQueue, data);
}

printf("出队结果为：");
while(QUEUE_EMPTY != isEmpty(pQueue))
{
	deQueue(pQueue, &data);
	printf("%d ", data);
}
printf("\n");


destroyQueue(&pQueue);
return 0;

}


### **总结：**



> 
> 1、线性表的特点  
>  逻辑结构是一对一  
>  存储结构有顺序存储和链式存储
> 
> 
> 



> 
> 2、我们学过了哪些线性表  
>  顺序表 单链表 双向链表 栈 队列
> 
> 
> 



> 
> 3、栈和队列与顺序表和链表的联系和区别是什么  
>  栈和队列属于顺序表和链表，栈和队列只是在他们的基础上进行了限制
> 
> 
> 



> 
> 4、顺序表和链表的区别  
>  <1>顺序表是连续存储，链表是不连续的  
>  <2>顺序表插入和删除需要数据搬移，效率低  
>  <3>顺序表的查找效率非常高，只需要知道下标就可以找到  
>  <4>链表的插入和删除效率比顺序表高，不需要数据搬移  
>  <5>链表的查找效率低，需要遍历
> 
> 
> 






![img](https://img-blog.csdnimg.cn/img_convert/112385ce0e535e5c96a99909cc5b53e1.png)
![img](https://img-blog.csdnimg.cn/img_convert/61cb10efad167158b51dcd66cb887dd1.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**

过了哪些线性表  
>  顺序表 单链表 双向链表 栈 队列
> 
> 
> 



> 
> 3、栈和队列与顺序表和链表的联系和区别是什么  
>  栈和队列属于顺序表和链表，栈和队列只是在他们的基础上进行了限制
> 
> 
> 



> 
> 4、顺序表和链表的区别  
>  <1>顺序表是连续存储，链表是不连续的  
>  <2>顺序表插入和删除需要数据搬移，效率低  
>  <3>顺序表的查找效率非常高，只需要知道下标就可以找到  
>  <4>链表的插入和删除效率比顺序表高，不需要数据搬移  
>  <5>链表的查找效率低，需要遍历
> 
> 
> 






[外链图片转存中...(img-x5UOaqPp-1715716356325)]
[外链图片转存中...(img-bjnO4dTP-1715716356326)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618679757)**
2401_85014985
关注
  • 24
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构之二叉树的非递归后序遍历算法
01-01
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一种，先定义栈结点的数据结构 typedef struct{Node *...
数据结构-二叉树的创建与遍历（链式存储结构）
11-13
总之，二叉树的链式存储结构提供了灵活的数据组织方式，而创建和遍历二叉树是掌握数据结构和算法的基础。通过深入理解和实践这些概念，可以为解决更复杂的问题打下坚实的基础。在学习过程中，通过编写代码实现二叉树...
嵌入式学习DAY22 --- 链式栈，队列，二叉树的存储、递归遍历、层次遍历（数据结构）
SpringWJN的博客
03-23 329
嵌入式入门学习笔记，遇到的问题以及心得体会！ DAY21 笔记： 一.链式栈的实现： 1.stack.h ----------------------------------------------------- 如下 #ifndef _STACK_H_ #define _STACK_H_ typedef int data_t; typedef struct StackNode { data_t data; struct StackNode *pNext; }StackNode
嵌入式学习DAY22 --- 链式栈，队列，二叉树的存储、递归遍历、层次遍历（数据结构
2401_85014997的博客
05-15 893
后根遍历（后序遍历）：先访问左子树，再访问右子树，最后访问树根。//先将原来的值保存起来。
嵌入式学习——数据结构（队列、二叉树）——day49
qq_47798402的博客
06-21 213
高速设备和低速设备利用缓冲区进行协调匹配。8. 树——一对多（与线性一对一不同）（二叉树的思想是递归）8.4 完全二叉树（从满二叉树中从左至右、从前置后插入）3. 串口数据的通信利用队列进行协调。2. 缓冲区——先进先出的队列。节点的度：该节点后继节点的个数。8.1 深度和（广）度（数的度（广度））7. 队列和栈的区别——队列应用更广泛。4. 顺序队列——循环队列（非重点）8.3 满二叉树（树都是饱满的）8.2 二叉树（（广）度为2）1. 满二叉树第k层节点个数。叶子节点：没有后继节点。
《学习笔记一阶段 Day--01》方向2学习 2021-05-25
叶蓝枫起的博客
05-25 115
方向2学习：学习剑指Offer 小技巧：如何回答跳槽原因：不能有负面情绪和对前公司或同事的抱怨，最好不要谈工资低。问及工资，最好如实讲。对期望工资讲出相应的原因并表明能担起相应的责任。 小技巧：面试者提问：不要问面试情况，不要问面试官不负责部分，比如不问技术面试的工资，不问HR技术。与对应的面试官可以了解项目情况，可能的工作安排，福利待遇。 面试者需要具备的要素： 基础知识之技术面试三要点：语言、数据结构、算法。 比如1.对指针的使用和各种指针做详细了解。2.熟练掌握链表、树、栈、队列和哈希表。重点学
二叉树的莫瑞斯遍历------一种方法解决前,中,后序遍历
2301_79125431的博客
03-03 970
本期推荐岗位：【游戏测试开发】2024年刚开始，新出了很多岗位，简历筛的特别迅速，最近甚至都有秒处理的！赶快搞简历，内推走起来！赶快搞简历，内推走起来！赶快搞简历，内推走起来！本期岗位：【云计算虚拟化开发工程师】2024年刚开始，新出了很多岗位，简历筛的特别迅速，最近甚至都有秒处理的！本期岗位：【游戏客户端开发】2024年刚开始，新出了很多岗位，简历筛的特别迅速，最近甚至都有秒处理的！本期岗位：【云计算网络开发工程师】2024年刚开始，新出了很多岗位，简历筛的特别迅速，最近甚至都有秒处理的！
嵌入式开发——数据结构
耶多✌
08-02 340
该文为学习笔记，仅作学习参考，如有错误，望指正！ 第一章. 绪论 数据结构在学什么？答案：如何用程序代码把现实世界的问题信息化。 本章内容索引： 1. 数据结构的基本概念 相关概念： 数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。数据是计算机程序加工的原料。 数据元素（Data Element）、数据项：数据元素是数据的基本单位，又称之为记录（Record），通常作为一个整体进行考虑和处理。一个数据元素是由若干个数据项组成的，数据项是构成
软件设计师-22年上半年-上午答案
https://www.ruankao.org.cn/
02-04 1376
软件设计师-22年上半年-上午答案 软设22年05月上午答案
KNN算法-学习笔记整理
码python的Vinsmoke
05-30 2252
机器学习算法 机器学习算法是一类从数据中自动分析获得规律（模型），并利用规律对未知数据进行预测的算法 开发机器学习应用程序的步骤 收集数据 可以使用很多方法收集样本数据，如：制作网络爬虫从网站上抽取数据、从RSS反馈或者API中得到信息、设备发送过来的实测数据。 准备输入数据 得到数据之后，还必须确保数据格式符合要求。 分析输入数据 这一步的主要作用是确保数据集中没有垃圾数据。如果是使用信任的数据来源，那么可以直接跳过这个步骤 训练算法 机器学习算法从这一步才真正开始学习。如果使用无监督学习算法，由于不存
嵌入式day18
我的blog
08-24 119
队列的链式存储 typedef int datatype; //定义链队列中数据元素的数据类型 typedef struct node{ datatype data; //数据域 struct node *next; //链接指针域 }linklist;　　　　　　　//链表元素类型定义 typedef...
数据结构-二叉树的建立及遍历操作
05-23
数据结构-二叉树的建立及遍历操作
数据结构从入门到精通-二叉树的实现和遍历
03-18
二叉树是数据结构中的重要概念，它是每个节点最多有两个子节点的树形结构，通常分为左子节点和右子节点。在计算机科学中，二叉树被广泛应用于搜索、排序、表达式求值等场景。本教程将带你从基础到深入地了解二叉树的...
中国星坤X1224系列线对板连接器：小巧稳定，助力物联网终端高效运行
weixin_50506145的博客
07-07 300
在物联网终端中，它能够确保设备与传感器之间的稳定连接，实现数据的实时传输和监控。X1224系列线对板连接器凭借其独特的设计和卓越的性能，在物联网等领域展现出了巨大的潜力和价值。未来，我们将继续致力于连接器的研发和创新，为终端设备的稳定运行提供更加可靠、高效的解决方案。同时，其热塑性较好，能够在一定范围内适应温度的变化，确保连接器的稳定性和可靠性。星坤X1224系列线对板连接器以其小巧轻便、抗震动带锁、耐高温等特性，成为了物联网终端、电器终端和消防终端等领域中不可或缺的一部分。二、抗震动带锁，确保对插稳定。
ESP32——物联网小项目汇总
Irving.Gao的博客
07-06 529
商品级ESP32智能手表 [文章链接] 用ESP32，做了个siri？！开源了！ [文章链接]
物联网应用，了解一点 WWAN全球网络标准
最新发布
老条码新物联的专栏
07-10 213
WWAN/蜂窝无线电认证，对跨地区应用场景，特别重要。跟随全球业务的脚步，我们像大唐先辈一样走遍全球业务的时候，了解一点全球化的 知识信息，就显得有那么点意义。下行 MIMO 4*4 (5G): n1、n2、n3、n7、n38、n40、n41、n66、n77、n78、n79。下行 4*4 MIMO (5G)：n2、n7、n25、n38、n41、n48、n66、n77、n78。下行 4*4 MIMO（4G）：LTE B2、B4、B7、B25、B38、B41、B48、B66。NA （北美）：美国和加拿大。
智能物联网鱼缸
li2642530979的博客
07-03 720
继电器、开发板、物联网os、云平台。
MQTT是什么，物联网
在职可交流前端开发，包括：web端、uniapp等，欢迎指教。
07-10 585
以下从几个方面介绍MQTT，包括：MQTT是什么，MQTT和webSocket的结合，以及使用场景。
北邮数据结构实验报告.doc
12-16
总的来说，本次实验让我更加深入地了解了数据结构中栈和队列的具体实现，同时也加深了对二叉树的理解。通过实际编程和测试，我对数据结构的应用有了更直观的认识，并提高了自己的编程能力。我相信在今后的学习和工作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值