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

树的层序遍历 突然想到写这个的原因是在四月份的每日一题里面有一个n叉树的层序遍历,然后自己做的其实不熟练。又想到之前又写过二叉树的层序遍历,所以就想着将几个题目一起总结起来。也算是加深一下印象了。 树的遍历方法一共四种: 先序遍历、中序遍历、后序遍历、层序遍历。 前三种方法中的序是指根节点的遍历顺序,一般使用递归(深度优先遍历)的方法实现。 层序遍历是指从最上层开始,一层一层的从左到右遍历,而不再是先左后右或先右后左。 层序遍历和广度优先搜索的思路比较像,维护一个队列,先将根结点放入队列中,当该结点出队列是,他的孩子结点 阅读详情

嵌入式入门学习笔记,遇到的问题以及心得体会!
DAY22

笔记:

一.链式栈的实现:

1.stack.h ----------------------------------------------------- 如下

#ifndef _STACK_H_
#define _STACK_H_

typedef int data_t;

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

typedef struct Stack
{
	StackNode *pHead;
	int count;
}Stack;

enum STACK_OP
{
	STACK_ERROR = -1,
	STACK_EMPTY,
	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;
}

三.链式队列的实现

在这里插入图片描述
定义结构体:

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>链表的查找效率低,需要遍历


一、树–二叉树

1、基本概念

(1)节点的度数:一个节点的子树的个数
(2)树的度数:一棵树的度数是指该树中节点的最大度数。
(3)叶子节点:度数为0的节点
(4)分支节点:度数不为0的节点
(5)根节点没有前驱节点,叶子节点没有后继节点

2、二叉树

(1)概念:一个节点最多只有两个节点,而且是严格区分左右的,哪怕只有只有一个子节点,也要区分左右,所以二叉树是有序树
(2)二叉树的性质
<1>二叉树第i(i≥1)层上的节点最多为2^(i-1)个。
<2>深度为k(k≥1)的二叉树最多有2^k-1个节点。
<3>在任意一棵二叉树中,树叶的数目比度数为2的节点的数目多一。
n0:度数为0的节点的个数
N1:度数为1的节点的个数
N2:度数为2的节点的个数
总节点数为各类节点之和:n = n0 + n1 + n2
总节点数为所有子节点数加一:n = n1 + 2*n2 + 1
故得:n0 = n2 + 1 ;
<4>满二叉树 :深度为k(k≥1)时有2^k-1个节点的二叉树。
<5>完全二叉树 :只有最下面两层有度数小于2的节点,且最下面一层的叶节点集中在最左边的若干位置上。
具有n个节点的完全二叉树的深度为
(log2n)+1或『log2(n+1)˥。
》k-1 <= log2n < k =>k <= log2n+1 < k+1=> log2n < k <= log2n+1 k是整数===》k = log2n+1

3、二叉树的存储

二叉树逻辑结构:一对多
存储结构:顺序存储和链式存储

链式存储中节点的描述方法:

Struct TreeNode
{
Data_t data;
Struct TreeNode *lChild;
Struct TreeNode *rChild;
};

4、二叉树的遍历

二叉树的遍历是指按某条搜索路径访问树中每个结点,使得每个结点均被访问一次,而且仅被访问一次。由于二叉树是一种非线性结构,每个结点都可能有两棵子树,因而需要寻找一种规律,以便使二叉树.上的结点能排列在一一个线性队列上,进而便于遍历。
由二叉树的递归定义可知,遍历一棵二叉树便要决定对根结点N、左子树L和右子树R的访问顺序。按照先遍历左子树再遍历有子树的原则,常见的遍历次序有先序(NLR)、 中序(LNR)和后序(LRN)三种遍历算法,其中“序”指的是根结点在何时被访问。

<递归遍历:>
(1)先根遍历(先序遍历):先访问树根,再访问左子树,最后访问右子树

void PreOrder (TreeNode *pRoot) 
{
	if (NULL == pRoot)
	{
		visit (pRoot) ; //访间根结点
		// printf("%c ", pRoot->data);
		
		PreOrder (pRoot->lchild) ;//递归遍历左子树

		PreOrder (pRoot->rchild) ;//递归遍历右子树
	}
}

中根遍历(中序遍历):先访问左子树,再访问树根,最后访问右子树

vold InOrder(TreeNode *pRoot)
 {
	if (NULL == pRoot) 
	{
		InOrder (pRoot->lchild); //递归遍历左子树
		visit(pRoot) ; //访问根结点
		// printf("%c ", pRoot->data);
		InOrder (pRoot->rchild) ;//递归遍历右子树
	}
}

后根遍历(后序遍历):先访问左子树,再访问右子树,最后访问树根

void PostOrder (TreeNode *pRoot) 
{
	If(NULL == pRoot) 
	{
		Postorder (pRoot->lchild); //递归遍历左子树
		Postorder (pRoot->rchild); //递归遍历右子树
		visit(pRoot);//访问根结点
		// printf("%c ", pRoot->data);
	}
}

<层次遍历:>

二叉树的层次遍历
二叉树的层次遍历
如图所示为二叉树的层次遍历,即按照箭头所指方向,按照1,2, 3,4的层次顺序,对二叉树中的各个结点进行访问。

要进行层次遍历,需要借助一个队列。先将二叉树根结点入队,然
后出队,访问出队结点,若它有左子树,则将左子树根结点入队:若它有右子树,则将右子树根结点入队。然后出队,访问出队结果…如此反复,直至队列为空。

二叉树的层次遍历算法如下:

void Levelorder (BiTree T) 
{
	InitQueue(Q) ;//初始化辅助队列
	BiTree Pi
	EnQueue(Q,T) ;//将根结点入队
	while ( IsEmpty(Q)) //队列不空则循环
	{
		DeQueue(O,p)//队头结点出队
		visit(p) ;//访问出队结点
		if (p->1child! =NULL)
		EnQueue (Q,p->lch11d); //左子树不空, 则左子树根结点入队
		if (p->rchild!=NULL)
		EnQueue (Q,p->rchild); //右子树不空, 则右子树根结点入队
	}
}

|
|
|
|

二.代码实现

1.tree.h----------------------------------------------------- 如下

#ifndef _TREE_H_
#define _TREE_H_

typedef char data_tree;

typedef struct TreeNode
{
	data_tree data;
	struct TreeNode *lChild, *rChild;
}TreeNode;



void createTree(TreeNode **ppRoot);
void preOrder(TreeNode *pRoot);
void inOrder(TreeNode *pRoot);
void postOrder(TreeNode *pRoot);
void destroyTree(TreeNode **ppRoot);
void levelOrder(TreeNode *pRoot);
#endif

2.tree.c----------------------------------------------------- 如下

#include<stdio.h>
#include "tree.h"
#include <stdlib.h>
#include <string.h>
#include "queue.h"

void createTree(TreeNode **ppRoot)
{
	data_tree data;
	printf("input:");
	scanf("%c", &data);
	getchar();
	if('#' == data)
	{
		//此时没有左子树或者右子树
		*ppRoot = NULL;
		return;
	}
	else
	{
		//先创建节点
		*ppRoot = (TreeNode *)malloc(sizeof(TreeNode));
		if(NULL == *ppRoot)
		{
			return;
		}
		(*ppRoot)->data = data;

		createTree(&((*ppRoot)->lChild));
		createTree(&((*ppRoot)->rChild));
	}
}
void preOrder(TreeNode *pRoot)
{
	if(NULL == pRoot)
	{
		return;
	}

    printf("%c ", pRoot->data);
	preOrder(pRoot->lChild);
	preOrder(pRoot->rChild);
}
void inOrder(TreeNode *pRoot)
{
	if(NULL == pRoot)
	{
		return;
	}
	inOrder(pRoot->lChild);
	printf("%c ", pRoot->data);
	inOrder(pRoot->rChild);
}
void postOrder(TreeNode *pRoot)
{
	if(NULL == pRoot)
	{
		return;
	}
	postOrder(pRoot->lChild);
	postOrder(pRoot->rChild);
	printf("%c ", pRoot->data);
}

void destroyTree(TreeNode **ppRoot)
{
	if(NULL == ppRoot || NULL == *ppRoot)
	{
		return;
	}
    destroyTree(&((*ppRoot)->lChild));
    destroyTree(&((*ppRoot)->rChild));
	free(*ppRoot);
	*ppRoot = NULL;
}

void levelOrder(TreeNode *pRoot)
{
	if(NULL == pRoot)
	{
		return;
	}

	//创建队列
	Queue *pQueue = createQueue();

	//根节点入队
	enQueue(pQueue, pRoot);

	//只要队列不为空,就出队
	//并且判断出队的节点有无左右子树
	//如果有就入队
	while(QUEUE_EMPTY != isEmpty(pQueue))
	{
		TreeNode *pNode;
		deQueue(pQueue, &pNode);
		printf("%c ", pNode->data);
		if(pNode->lChild != NULL)
		{
			enQueue(pQueue, pNode->lChild);
		}
		if(pNode->rChild != NULL)
		{
			enQueue(pQueue, pNode->rChild);
		}
	}
	printf("\n");
}

3.main.c----------------------------------------------------- 如下

#include<stdio.h>
#include "tree.h"


int main()
{
	TreeNode *pRoot = NULL;
	createTree(&pRoot);

	levelOrder(pRoot);

	destroyTree(&pRoot);
	return 0;
}

【信息科学与工程学】【数据科学】数据科学领域 第六篇 算法设计 07 堆、栈、表、矩阵、集合、队列、数组、字符串、树、图、动态规划、结构体、元组的算法01 当前段必须包含所有字符的最后出现位置。1. 字符串分割成最多片段2. 基因序列功能域划分3. 文本段落划分4. 音频声道分离5. 图像色彩分区6. 社交网络社群划分7. 蛋白质结构域8. 音乐乐章分段9. 代码模块划分10. 章节划分特征:一次扫描,贪心确定边界。 阅读详情

相关推荐

【信息科学与工程学】【通信工程】第一百九十一篇 路由器体系结构03

编号类型领域问题详细的数学分析(逐步推理)参数列表(表达式 / 数值范围 / 边界 / 测量)关联知识839DCI演进 · 收敛DCI 2030 年三大技术收敛方向步骤1:方向一:IPoDWDM 成为绝对主流(Omdia 2027 59% → 2030 80%+),OTN 退化为 OLS 纯光层。步骤2:方向二:800ZR+ 取代 400ZR 成为主力速率,PCS 使 800G 达 600–1000km。步骤3:方向三:AI 集群 DCI 催生 1.6T/3.2T 超短距(<10km)相干模块(OSFP-X

weixin_49199313的博客 870

嵌入式C语言入门——二叉树

数据结构之树结构树的定义树的操作二叉树的定义特殊的二叉树定义性质性质1性质2性质3性质4性质5 树的定义 树结构是非线性结构组织数据 树结构组织起来的数据应当具有层次关系 树是由 n ( n ≥0 ) 个结点组成的有限集合 如果 n = 0,称为空树 如果 n &gt; 0,则: 有一个特定的称之为根(root)的结点,它只有直接后继,但没有直接前驱 除根以外的其它结点划分为 m (m ≥0...

qq_35599308的博客 605

【信息科学与工程学】计算机科学与技术——第七十七篇 系统架构设计02

编号类型模型配方企业资本运作的方法/规则/条件/依据及所有的步骤(​风险处理/异常处理/危机应对关联知识法律法规和裁决依据​​由发起人(通常是知名投资人、投行或产业资本)先设立一个只有现金、无实际业务的特殊目的收购公司(SPAC),通过IPO募集资金并在交易所上市。然后在规定时间内(通常24个月)寻找一家非上市公司进行合并(De-SPAC),使目标公司迅速实现上市,规避传统IPO的复杂流程和不确定性。1.:在开曼或特拉华注册空壳公司,注入少量种子资金。2.

weixin_49199313的博客 319

嵌入式学习软件篇------数据结构:二叉树

特点:有且只有一个根节点,其余节点可以分为n个互不相交的有限集合。

qq_38813765的博客 485

Cursor概述及环境配置

Cursor 是一款基于 AI 的代码编辑器,支持 VS Code 配置迁移和 Java 开发环境配置。主要功能分为 Cursor Settings(AI 相关设置)和 Editor Settings(基础编辑器设置)。用户可通过一键导入或手动方式迁移 VS Code 配置,配置包括主题、扩展和快捷键等。对于 Java 开发,需配置 JDK 和 Maven 路径,并安装 Java 扩展插件以获得完整开发体验,如代码补全、调试和 Maven 项目管理。此外,Cursor 支持汉化配置,用户可安装中文语言包切换

Knight 3560

团队管理中最棘手的6个问题

研发团队的管理棘手问题,大多集中在。

xiaolyuh的专栏 755

【嵌入式学习历程11】数据结构之二叉树

树的概念 树(Tree)是n(n>=0)个结点的有限集。n=0的时候称为空树,在任意一颗非空树中:(1)有且仅有一个特定的称为根(root)的结点;(2)当n>1时,其余结点可以分为m(m>0)个互不相交的有限集T1、T2、T3…..Tm,其中,每一个集合本身又是一棵树,并且称为跟的子树。 * 结点 树的结点包含一个数据元素及若干个指向其子树的分支。 *度 结点拥有的子树称为结点的度。

華仔的博客 563

【雷达成像实战】RD、CS、RMA算法对比与Matlab实现:从信号处理到高清成像

本文深入对比了雷达成像中三种核心算法:经典的距离多普勒算法(RD)、基于稀疏重建的压缩感知算法(CS)以及高精度的快速多通道获取算法(RMA)。通过详细的Matlab实战代码,从原理拆解到实现步骤,分析了各自在计算效率、成像精度、数据需求和适用场景上的优劣,为工程选型与算法实践提供了清晰指南。

weixin_29095587的博客 452

算法通关村——树的层次遍历

本文介绍了树的层次遍历方法,已经基于树的层次遍历拓展的几个遍历问题

moqi997752的博客 5371

偏最小二乘结构方程(PLS-SEM)_TomatoSCI分析日记

①模型整体拟合指标(Goodness-of-Fit, GOF),这个可以看做整体的R方了,上限是1;②指标载荷的具体值;然而,当数据中包含潜变量(即由多个观测指标组合而成的综合概念)时,贝叶斯结构方程不太适用。指标过少(1-2 个)会削弱潜变量的解释力,而指标过多可能增加噪声,影响模型稳定性。如果指标较多,可考虑进一步划分潜变量,但应确保每个指标有意义。掌握这两类方法后,在处理多变量、因果或路径分析研究时,可以根据数据特点与研究需求灵活选择。对于一般的多变量研究,这两类结构方程均为常用且有效的分析方案。

qq_44684643的博客 2012

安装anaconda3时出现错误:Failed to link extracted packages to D:\anaconda!...如何解决?

🏆本文收录于 《全栈 Bug 调优(实战版)》 专栏。专栏聚焦真实项目中的各类疑难 Bug,从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解,形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者,还是负责复杂项目的资深工程师,都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论,助你稳步进阶、放大技术价值 。

**My Coding Family** 1483

树的层次遍历

二叉树的前序、中序、后序遍历我想大家应该都很熟悉了,那我们今天就来讲一下二叉树的层次遍历。 二叉树的前序、中序、后序遍历需要用到栈(递归的过程也就是一个栈),层次遍历需要借助队列这个数据结构。 层次遍历的思路 我们给出一个二叉树: 这棵二叉树的层次遍历次序为:A、B、C、D、F、G 以人的思维来看层次遍历貌似比前、中、后序遍历更加简单易懂,但是程序到底如何实现这样的效果呢...

听得到微笑的博客 4万+

复现基于混频因子模型的GDP即时预测方法

基于混频因子模型的GDP即时预测方法复现 本文复现了混频因子模型(MIDAS)在GDP即时预测中的应用。该方法整合7个月度宏观经济变量(工业增加值、CPI、PMI等)与季度GDP数据,通过状态空间模型实现高频预测。技术实现包括:1)使用PCA提取潜在共同因子;2)构建状态空间模型处理混频数据;3)通过卡尔曼滤波进行参数估计。实证结果显示模型预测效果良好(测试集R²=0.82),其中工业增加值对因子1贡献最大(0.82),CPI对因子2贡献显著(0.78)。该方法为决策者提供了更及时的季度GDP估算。

huanghm88的专栏 606

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

后根遍历(后序遍历):先访问左子树,再访问右子树,最后访问树根。//先将原来的值保存起来。

2401_85014997的博客 975

WQ7033开发指南(应用篇)之2.1 主函数详解(1)

整个系列文章查看: ​​​​​​WQ7033开发指南汇总 目录 1.函数模块位置 2.函数main_chip_init()解析 2.1 cal_data_ana_load() 2.2 函数iot_cache_restore_register()解析 3.函数iot_soc_chip_init()解析 3.1 soc芯片初始化的低功耗使能 3.2 分支预设功能使能 3.3 数据异常中止使能 3.4 外围低速总线访问路径使能 3.5 1.8V DCDC功能配置 3.6 ADC配..

心跳包的博客 807

69、SAP数据库归档重做日志备份策略与工具详解

本文详细解析了SAP数据库归档重做日志备份的重要性及策略,介绍了SAP提供的备份工具brarchive及其配置和使用方法,探讨了BRBACKUP与BRARCHIVE的联合运行、一致在线备份、备用数据库备份场景以及备份策略的综合应用与优化。此外,还分析了备份过程中常见问题的解决方法、备份监控与评估流程、与第三方备份解决方案的集成方式,以及未来备份技术的发展趋势和应对策略。通过合理运用这些策略和工具,可以有效保障SAP数据库的安全性和可恢复性。

peace的博客 139

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

/先将原来的值保存起来。

2401_85014985的博客 771

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

嵌入式学习DAY22 --- 链式栈,队列,二叉树的存储、递归遍历、层次遍历(数据结构)_嵌入式编程 二叉树应用

/左子树不空, 则左子树根结点入队。//右子树不空, 则右子树根结点入队。while ( IsEmpty(Q)) //队列不空则循环。DeQueue(O,p)//队头结点出队。//先将原来的值保存起来。

2401_87555332的博客 506

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

嵌入式学习DAY22 --- 链式栈,队列,二叉树的存储、递归遍历、层次遍历(数据结构)_嵌入式编程 二叉树应用(1)

/左子树不空, 则左子树根结点入队。//右子树不空, 则右子树根结点入队。while ( IsEmpty(Q)) //队列不空则循环。DeQueue(O,p)//队头结点出队。//先将原来的值保存起来。

2401_87555332的博客 784

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

嵌入式学习day22

本文系统介绍了树与二叉树的数据结构。树是n个结点的有限集合,包含根结点和互不相交的子树,涉及度、层次等重要术语。二叉树作为特殊树结构,具有最多两棵子树且严格区分左右的特点,包括斜树、满二叉树和完全二叉树三种特殊形态。文章详细阐述了二叉树的4条核心性质、4种遍历方式(前序、中序、后序、层序)及其应用场景,并提供了C语言存储结构代码示例。重点强调了完全二叉树的实用价值、遍历算法的重要性,以及n₀=n₂+1这一关键性质。建议通过画图和编码实践来巩固理解。

m0_75187645的博客 351

算法篇:树之树的层次遍历

算法:树的层次遍历是树的基本操作之一,包括二叉树的层次遍历,多叉树的层次遍历,以及二叉树层次遍历的变形题目,层次遍历+每一层的节点的翻转等操作。对于这类题目,典型算法就是先将树按照层次存...

zhghost的专栏 5312

树的遍历(四种全)|C++

一.树的遍历 树的遍历也叫树的搜索,是指按照某种规则对树的节点进行一遍不重复的访问。按照不同的方式可以分为树的前序遍历、中序遍历、后序遍历和层序遍历。 二.前序遍历 1)树的前序遍历指的是对树按照根、左、右的规律进行访问。 遍历结果为:F, B, A, D, C, E, G, I, H 2)递归代码实现(对于前序、中序、后序遍历的递归实现非常的相似,只是改变输出数组语句的位置) //存储遍历结果的数组 vector<int> v; //前序遍历函数 vector<int

taoxing 3万+

二叉树的遍历非递归算法实现之先序遍历_超详细保姆级别手撕代码看了就会_链式栈(C++)

二叉树先序非递归算法实现详细教程

smart_jackli的博客 580

非递归中序,后序,先序遍历二叉树完整代码(用链式栈实现)

后序遍历: #include <iostream> #include <bits/stdc++.h> using namespace std; typedef struct BiNode { char ch; struct BiNode *lchild,*rchild; int tag; }BiNode,*BiTree; typedef struct Stack { BiTree stack; struct Stack *next; }Stac

qq_46132949的博客 740
上一篇: 嵌入式学习DAY21 --- 数据结构(双向链表、栈、队列)
下一篇: 嵌入式学习DAY23 --- 排序、查找,哈希表,用哈希表编写一个 <学生信息管理系统>
南窗的雨
博客等级 码龄6年 687粉丝 97原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值