数据结构——二叉树的递归算法

943802606 943802606 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 3.4k累计阅读 3.5k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄6年
关注
原创 最新推荐文章于 2026-06-25 11:58:44 发布 3.4k 阅读 AI 写同款· GEO 优化 ›
【数据结构与算法】二叉树递归与非递归遍历（附完整源码） 二叉树是一种非常重要的数据结构，很多其他数据机构都是基于二叉树的基础演变过来的。二叉树有前、中、后三种遍历方式，因为树的本身就是用递归定义的，因此采用递归的方法实现三种遍历，不仅代码简洁且容易理解，但其开销也比较大，而若采用非递归方法实现三种遍历，则要用栈来模拟实现（递归也是用栈实现的）。下面先简要介绍三种遍历方式的递归实现，再详细介绍三种遍历方式的非递归实现。 一、三种遍历方式 阅读详情

二叉树的结构定义：

typedef struct BiNode
{
	TElemType data;
	struct BiNode *lchild;
	struct BiNode *rchild;
}BiNode,*BiTree;

这里包含的递归算法有：

  1. 二叉树的先序创建；
  2. 二叉树的先序中序后序遍历；
  3. 二叉树的销毁算法；
  4. 双序遍历；
  5. 求结点的个数；
  6. 求结点值的和；
  7. 求树的深度；
  8. 求叶子结点的个数；
  9. 求单分支结点的个数；
  10. 交换结点的左右子树；
  11. 寻找最小值结点；
  12. 判断是否是相同的二叉树；
  13. 判断是否是平衡二叉树；
  14. 判断是对称二叉树；
  15. 二叉树的最小深度算法
    查看之前的博文
    二叉树的最小深度
  16. 二叉树的层次遍历
    查看之前的博文
    二叉树的层次遍历
    二叉树的层次遍历进阶
  17. 二叉树的最长路径
    查看之前的博文
    二叉树的最长路径问题
  18. 从叶子结点到根节点的全部路径
    查看之前的博文
    从叶子结点到根节点的全部路径

最底面有全部代码的合集：
1 二叉树的先序创建
思路：
和先序递归遍历差不多，二叉树中每个结点的元素均为一个字符，按先序遍历的顺序建立二叉链表。（序列中元素为‘#’时，表示该结点为空）。

void CreateBiTree(BiTree &T)//二叉树的先序创建 
{
	TElemType ch;
	scanf("%c",&ch);
	if(ch=='#')
		T=NULL;
	else 
	{
		T=(BiNode*)malloc(sizeof(BiNode));
		if(!T)
			exit(-1);
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}

2二叉树的先序中序后序遍历
思路：
先序中序后序递归算法都类似


int  preorderTraverse(BiTree T)//二叉树的先序递归遍历算法 
{
	if(T==NULL)
		return 0;
	else 
		{
			printf("%c ",T->data);
			preorderTraverse(T->lchild);
			preorderTraverse(T->rchild);
		}
 } 
 
int  InorderTraverse(BiTree T)//二叉树的中序递归遍历算法 
{
	if(T==NULL)
		return 0;
	else 
		{
			InorderTraverse(T->lchild);
			printf("%c ",T->data);
			InorderTraverse(T->rchild);
		}
 }
 
int  PostorderTraverse(BiTree T)//二叉树的后序递归遍历算法 
{
	if(T==NULL)
		return 0;
	else 
		{
			PostorderTraverse(T->lchild);
			PostorderTraverse(T->rchild);
			printf("%c ",T->data);
		}
 }

3二叉树的销毁算法
思路：
和后序递归算法类似

void DestroyBiTree(BiTree &T)//二叉树的销毁算法 
{
	if(T==NULL)
		exit(-1);
	else
	{
		DestroyBiTree(T->lchild);
		DestroyBiTree(T->rchild);
		free(T);
	}
}

4双序遍历
思路：和普通前序中序遍历类似

void double_preorderTraverse(BiTree T)//双序遍历 
{
	if(T!=NULL)
	{
		printf("%c ",T->data);
		double_preorderTraverse(T->lchild);
		printf("%c ",T->data);
		double_preorderTraverse(T->rchild);
	}
}

5求结点的个数
思路：仅一个if else

int NodeCount(BiTree &T)//求节点的个数 
{
	if(T==NULL)
		return 0;
	else
		return 1+NodeCount(T->lchild)+NodeCount(T->rchild);
}

6求结点值的和
思路：
和求结点个数一样的算法

int Sum(BiTree &T)//求结点值的和 
{
	if(T==NULL)
		return 0;
	else
		return T->data+Sum(T->lchild)+Sum(T->rchild);
}

7求树的深度
思路：
树的深度是指树的最大深度（根节点到最远叶子结点的层次）
在这里插入图片描述

int max(int x,int y)//求两数的最大值 
{
	if(x>y)
		return x;
	else
		return y;	
}

int BiTree_height1(BiTree &T)//求树的深度算法1 
{
	if(T==NULL)
		return 0;
	else
		return 1+max(BiTree_height1(T->lchild),BiTree_height1(T->rchild));
	
} 


int BiTree_height2(BiTree &T)//求树的深度算法2 
{
	int l_height,r_height;
	if(T==NULL)
		return 0;
	else
	{
		l_height=BiTree_height2(T->lchild);
		r_height=BiTree_height2(T->rchild);
		return (l_height>r_height)?(l_height+1):(r_height+1);
	}

}

8求叶子结点的个数
思路：
若T为空，则返回0；
若T为叶子结点，则返回1；
若为非叶子结点，则返回（左子树叶子结点数+右子树叶子结点数）；

在这里插入图片描述

int leafCount(BiTree &T)//求叶子结点的个数 
{
	if(T==NULL)
		return 0;
	if(T->lchild==NULL&&T->rchild==NULL)
		return 1;
	else
	{
		return leafCount(T->lchild)+leafCount(T->rchild);
	}
 }

9求单分支结点的个数
思路：

int DegreeOne(BiTree T)
{
	if(NULL == T)
		return 0;
 
	if(NULL == T->lchild && NULL == T->rchild)//为叶子结点 
		return 0;
 
	if(NULL != T->lchild && NULL != T->rchild)//为双分支结点 
		return DegreeOne(T->lchild) + DegreeOne(T->rchild);
	//此时为单分支结点 
	return 1 + DegreeOne(T->lchild) + DegreeOne(T->rchild);
 

}
int DegreeOne1(BiTree &T)//求单分支节点的个数 算法2
{
    int lnum, rnum, n;
    if(T == NULL)
        return 0;
    else
    {
    	if((T->lchild == NULL && T->rchild != NULL) ||(T->lchild != NULL && T->rchild == NULL))
            n = 1; //为单分支结点
        else
            n = 0; //其他结点
	lnum = DegreeOne1(T->lchild); //递归求左子树中单分支结点数
    rnum = DegreeOne1(T->rchild); //递归求右子树中单分支结点数
    return (lnum + rnum + n);
	}
        
    
}

10交换结点的左右子树
另一个单独的问题的博文
数据结构——二叉树交换左右子树
代码：



void Exchange_lchild_rchild(BiTree &T)//½»»»×óÓÒº¢×Ó½áµã 
{
	if(T!=NULL)	
	if(T->lchild!=NULL||T->rchild!=NULL)
		{
			BiTree temp;
			temp=T->lchild;
			T->lchild=T->rchild;
			T->rchild=temp;
	Exchange_lchild_rchild(T->lchild);
	Exchange_lchild_rchild(T->rchild);
		}
	
 }

11寻找最小值结点
代码：

void Findminnode(BiTree &T,char &min)//Ñ°ÕÒ×îСֵ½áµã 
{
	
	if(T!=NULL)
 {
	if(T->data<min)
	{
		min=T->data;
	}
	Findminnode(T->lchild,min);
	Findminnode(T->rchild,min);
	
 }

12判断是否是相同的二叉树

思路：
1判断这两棵树是否都空，如果都空，则是相同的树，如果有一棵树不空另一棵树为空，则不是相同的树
2这两棵树都不空，判断这个节点对应的值相等吗？
3若这两个节点的值相等，递归同时判断这两棵树的左子树，右子树。

status BiTree_is_same(BiTree &T,BiTree &S)//ÊÇ·ñÊÇÏàͬµÄ¶þ²æÊ÷ 
{
	if(T==NULL&&S==NULL)
			return 1;
	if(T==NULL||S==NULL)
			return 0;
	if(T->data!=S->data)
			return 0;
	return(BiTree_is_same(T->lchild,S->lchild)&&BiTree_is_same(T->rchild,S->rchild));
}

13判断是否是平衡二叉树
思路：
1如果这颗树为空，则返回1
2此时（这棵树不为空），判断该节点的左右子树的高度差的绝对值|（左子树的高度—右子树的高度）|>1,如果大于1，则返回0
3此时（该节点的左右子树的高度差<1），递归遍历该节点的左右子树。


int BiTree_height1(BiTree &T)//ÇóÊ÷µÄÉî¶ÈËã·¨1 
{
	if(T==NULL)
		return 0;
	else
		return 1+max(BiTree_height1(T->lchild),BiTree_height1(T->rchild));
	
} 



status BiTree_is_Balanced(BiTree T)//ÅжÏÊÇ·ñÊÇƽºâ¶þ²æÊ÷ 
{
	if(T==NULL)
		return 1;
	if(abs(BiTree_height1(T->lchild)-BiTree_height1(T->rchild))>1)
		return 0;
	return BiTree_is_Balanced(T->lchild)&&BiTree_is_Balanced(T->rchild);
}

14判断是对称二叉树
思路：
1用BiTree_symmetry(BiTree T)函数调用T的左右子树
2调用 BiTree_check(BiTree root1,BiTree root2)函数核实他的左右子树是否满足左右对称，镜像：如果左右子树都空则返回1，若果仅有一棵树为空,则返回0，若两棵树都不空，则返回（判断左右子树对应根节点的值是否相等，递归调用BiTree_check(BiTree root1,BiTree root2)判断该节点的左右子树）BiTree_check(root1->lchild,root2->rchild)&&BiTree_check(root1->rchild,root2->lchild)

status BiTree_check(BiTree root1,BiTree root2)
{
	if(root1==NULL&&root2==NULL) return 1;
	if(root1==NULL||root2==NULL) return 0;
	return root1->data==root2->data&&BiTree_check(root1->lchild,root2->rchild)&&BiTree_check(root1->rchild,root2->lchild);
}

status BiTree_symmetry(BiTree T)//
{
	return BiTree_check(T->lchild,T->rchild);
 }

全部代码（可执行）

#include<stdio.h>
#include<bits/stdc++.h> 
typedef char TElemType;
typedef int status; 
typedef struct BiNode
{
	TElemType data;
	struct BiNode *lchild;
	struct BiNode *rchild;
}BiNode,*BiTree;
void CreateBiTree(BiTree &T)//¶þ²æÊ÷µÄÏÈÐò´´½¨ 
{
	TElemType ch;
	scanf("%c",&ch);
	if(ch=='#')
		T=NULL;
	else 
	{
		T=(BiNode*)malloc(sizeof(BiNode));
		if(!T)
			exit(-1);
		T->data=ch;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
}
void CreateBiTree2(BiTree &T)//¶þ²æÊ÷µÄÖÐÐò´´½¨ 
{
	TElemType ch;
	scanf("%c",&ch);
	if(ch=='#')
		T=NULL;
	else 
	{
		T=(BiNode*)malloc(sizeof(BiNode));
		if(!T)
			exit(-1);
		
		CreateBiTree(T->lchild);
		T->data=ch;
		CreateBiTree(T->rchild);
	}
}
void DestroyBiTree(BiTree &T)//¶þ²æÊ÷µÄÏú»ÙËã·¨ 
{
	if(T==NULL)
		exit(-1);
	else
	{
		DestroyBiTree(T->lchild);
		DestroyBiTree(T->rchild);
		free(T);
	}
}

void double_preorderTraverse(BiTree T)//Ë«Ðò±éÀú 
{
	if(T!=NULL)
	{
		printf("%c ",T->data);
		double_preorderTraverse(T->lchild);
		printf("%c ",T->data);
		double_preorderTraverse(T->rchild);
	}
}




int  preorderTraverse(BiTree T)//¶þ²æÊ÷µÄÏÈÐòµÝ¹é±éÀúËã·¨ 
{
	if(T==NULL)
		return 0;
	else 
		{
			printf("%c ",T->data);
			preorderTraverse(T->lchild);
			preorderTraverse(T->rchild);
		}
 } 
 
int  InorderTraverse(BiTree T)//¶þ²æÊ÷µÄÖÐÐòµÝ¹é±éÀúËã·¨ 
{
	if(T==NULL)
		return 0;
	else 
		{
			InorderTraverse(T->lchild);
			printf("%c ",T->data);
			InorderTraverse(T->rchild);
		}
 }
 
int  PostorderTraverse(BiTree T)//¶þ²æÊ÷µÄºóÐòµÝ¹é±éÀúËã·¨ 
{
	if(T==NULL)
		return 0;
	else 
		{
			PostorderTraverse(T->lchild);
			PostorderTraverse(T->rchild);
			printf("%c ",T->data);
		}
 }

int NodeCount(BiTree &T)//Çó½ÚµãµÄ¸öÊý 
{
	if(T==NULL)
		return 0;
	else
		return 1+NodeCount(T->lchild)+NodeCount(T->rchild);
}

int Sum(BiTree &T)//Çó½áµãÖµµÄºÍ 
{
	if(T==NULL)
		return 0;
	else
		return T->data+Sum(T->lchild)+Sum(T->rchild);
}

int max(int x,int y)//ÇóÁ½ÊýµÄ×î´óÖµ 
{
	if(x>y)
		return x;
	else
		return y;	
}

int BiTree_height1(BiTree &T)//ÇóÊ÷µÄÉî¶ÈËã·¨1 
{
	if(T==NULL)
		return 0;
	else
		return 1+max(BiTree_height1(T->lchild),BiTree_height1(T->rchild));
	
} 

int BiTree_height2(BiTree &T)//ÇóÊ÷µÄÉî¶ÈËã·¨2 
{
	int l_height,r_height;
	if(T==NULL)
		return 0;
	else
	{
		l_height=BiTree_height2(T->lchild);
		r_height=BiTree_height2(T->rchild);
		return 1+max(l_height,r_height);
	}
		
	
}

int leafCount(BiTree &T)//ÇóÒ¶×Ó½áµãµÄ¸öÊý 
{
	if(T==NULL)
		return 0;
	if(T->lchild==NULL&&T->rchild==NULL)
		return 1;
	else
	{
		return leafCount(T->lchild)+leafCount(T->rchild);
	}
 } 

void Exchange_lchild_rchild(BiTree &T)//½»»»×óÓÒº¢×Ó½áµã 
{
	if(T!=NULL)	
	if(T->lchild!=NULL||T->rchild!=NULL)
		{
			BiTree temp;
			temp=T->lchild;
			T->lchild=T->rchild;
			T->rchild=temp;
	Exchange_lchild_rchild(T->lchild);
	Exchange_lchild_rchild(T->rchild);
		}
	
 } 

void Findminnode(BiTree &T,char &min)//Ñ°ÕÒ×îСֵ½áµã 
{
	
	if(T!=NULL)
 {
	if(T->data<min)
	{
		min=T->data;
	}
	Findminnode(T->lchild,min);
	Findminnode(T->rchild,min);
	
 }
	
} 

int DegreeOne(BiTree T)
{
	if(NULL == T)
		return 0;
 
	if(NULL == T->lchild && NULL == T->rchild)//ΪҶ×Ó½áµã 
		return 0;
 
	if(NULL != T->lchild && NULL != T->rchild)//Ϊ˫·ÖÖ§½áµã 
		return DegreeOne(T->lchild) + DegreeOne(T->rchild);
	//´ËʱΪµ¥·ÖÖ§½áµã 
	return 1 + DegreeOne(T->lchild) + DegreeOne(T->rchild);
 

}
int DegreeOne1(BiTree &T)//Çóµ¥·ÖÖ§½ÚµãµÄ¸öÊý Ëã·¨2
{
    int lnum, rnum, n;
    if(T == NULL)
        return 0;
    else
    {
    	if((T->lchild == NULL && T->rchild != NULL) ||(T->lchild != NULL && T->rchild == NULL))
            n = 1; //Ϊµ¥·ÖÖ§½áµã
        else
            n = 0; //ÆäËû½áµã
	lnum = DegreeOne1(T->lchild); //µÝ¹éÇó×ó×ÓÊ÷Öе¥·ÖÖ§½áµãÊý
    rnum = DegreeOne1(T->rchild); //µÝ¹éÇóÓÒ×ÓÊ÷Öе¥·ÖÖ§½áµãÊý
    return (lnum + rnum + n);
	}
        
    
}




status BiTree_is_same(BiTree &T,BiTree &S)//ÊÇ·ñÊÇÏàͬµÄ¶þ²æÊ÷ 
{
	if(T==NULL&&S==NULL)
			return 1;
	if(T==NULL||S==NULL)
			return 0;
	if(T->data!=S->data)
			return 0;
	return(BiTree_is_same(T->lchild,S->lchild)&&BiTree_is_same(T->rchild,S->rchild));
}


status BiTree_is_Balanced(BiTree T)//ÅжÏÊÇ·ñÊÇƽºâ¶þ²æÊ÷ 
{
	if(T==NULL)
		return 1;
	if(abs(BiTree_height1(T->lchild)-BiTree_height1(T->rchild))>1)
		return 0;
	return BiTree_is_Balanced(T->lchild)&&BiTree_is_Balanced(T->rchild);
}

status BiTree_check(BiTree root1,BiTree root2)
{
	if(root1==NULL&&root2==NULL) return 1;
	if(root1==NULL||root2==NULL) return 0;
	return root1->data==root2->data&&BiTree_check(root1->lchild,root2->rchild)&&BiTree_check(root1->rchild,root2->lchild);
}

status BiTree_symmetry(BiTree T)//¶Ô³Æ¶þ²æÊ÷ 
{
	return BiTree_check(T->lchild,T->rchild);
 } 














int main()
{	
	int x;
	int node_number,BiTree_height;
	BiTree T;
	char min;
	printf("´´½¨Ê÷ÊäÈëÊ÷TµÄÏÈÐòÐòÁÐ(ÆäÖÐʹÓÃ#´ú±í¿Õ½Úµã)\n");
	CreateBiTree(T);
	
	printf("---²Ëµ¥---\n"); 
	printf("[1]:ÏÈÐò±éÀúËã·¨\n");
	printf("[2]:ÖÐÐò±éÀúËã·¨\n");
	printf("[3]:ºóÐò±éÀúËã·¨\n");
	printf("[4]:Çó½áµã¸öÊýËã·¨\n");
	printf("[5]:ÇóÊ÷µÄÉî¶ÈËã·¨\n");
	printf("[6]:½»»»×óÓÒº¢×Ó½ÚµãËã·¨\n");
	printf("[7]:Ñ°ÕÒ×îСֵ½áµãËã·¨\n"); 
	printf("[8]:Çóµ¥·ÖÖ§½ÚµãµÄ¸öÊýËã·¨\n");
	printf("[9]ÅжÏÊÇ·ñÊÇÏàͬµÄÊ÷\n");
	printf("[10]:ÅжÏÊÇ·ñÊÇƽºâ¶þ²æÊ÷\n"); 
	printf("[11]:ÅжÏÊÇ·ñÊǶԳƶþ²æÊ÷\n"); 
	while(1)
	{
		int n; 
		printf("\nÊäÈëÒª½øÐеIJÙ×÷:");
		scanf("%d",&n);
		switch(n)
		{
			case 1:
					preorderTraverse(T);
					break;
			case 2:
					InorderTraverse(T);
					break;
			case 3:
					PostorderTraverse(T);
					break;
			case 4:
					node_number=NodeCount(T);
					printf("%d",node_number);
					break;
			case 5:
					BiTree_height=BiTree_height1(T);
					printf("%d",BiTree_height);
					break;
			case 6:
					Exchange_lchild_rchild(T);
					break;
			case 7:
					min=T->data;
					Findminnode(T,min);//±ØÐëÔÚµ÷Óú¯ÊýÇ°¸³³õÖµ 
					printf("%c",min);
					
					break;
			case 8:
					printf("Çóµ¥·ÖÖ§½áµã¸öÊý£º");
					printf("%d",DegreeOne1(T)); 
					break;
			case 9:
				
				
				if(BiTree_is_same(T,T)) 
						printf("ÊÇÏàͬµÄÊ÷\n");
					else printf("²»ÊÇÏàͬµÄÊ÷\n");
					break;		
			case 10:
					
					if(BiTree_is_Balanced(T)) 
						printf("ÊÇƽºâ¶þ²æÊ÷\n");
					else printf("²»ÊÇƽºâ¶þ²æÊ÷\n");
					break; 
			case 11:
					
					if(BiTree_symmetry(T)) 
						printf("ÊǶԳƶþ²æÊ÷\n");
					else printf("²»ÊǶԳƶþ²æÊ÷\n");
					break;
				
		}
	} 
	
	
	
	
	
	
	
	
	
	
	
	
	

	
}
收录于
数据结构

当前文章被收录于：

数据结构
27 篇文章 7 人学习

# 数据结构

订阅专栏 查看详情
标签
#二叉树 #数据结构 #c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
从零到一：Admin.NET中Swagger与Knife4jUI的深度集成实践 本文详细介绍了在Admin.NET框架中深度集成Swagger与Knife4jUI的实践方法，从基础配置到高级定制，包括认证配置、安全增强、界面主题定制等。通过Furion框架简化配置，开发者可以快速构建专业且友好的API文档界面，提升团队协作效率。 阅读详情

相关推荐

SigFit实战：从FEA到光学仿真的热力耦合分析全流程解析

在光机系统与芯片封装等精密工程领域，热与力的耦合效应是影响产品性能与可靠性的核心物理问题。有限元分析（FEA）是预测结构在热、力载荷下变形与应力的基础工具，但其结果通常无法直接用于评估光学性能。这需要一座桥梁，将物理场数据转化为光学设计语言。其核心原理在于数据映射与面形表征技术，例如通过泽尼克多项式拟合，将离散的节点位移分解为离焦、像散等标准光学像差。这项技术的工程价值在于，它实现了多物理场仿真的闭环，使工程师能在设计阶段精准预测热变形或应力对波前误差、调制传递函数等关键光学指标的影响。其典型应用场景包括高

weixin_28630185的博客 342

二叉树必备各种递归算法（求树的结点数，高度，叶子结点...）

1、求二叉树中的节点个数 递归解法： （1）如果二叉树为空，节点个数为0 （2）如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1 int NodeNum(BTNode * root) { if(root== NULL) // 递归出口 return 0; return NodeNum(root->lchild) + NodeNum(root->rchild) + 1; } 2、求二叉树的深度 递归解法： （1）如果二叉树为空，二叉

weixin_43800761的博客 5万+

ENVI 5.6 + Sarscape 5.2 保姆级教程：哨兵一号数据处理全流程（含DEM自动下载）

本文提供ENVI 5.6与Sarscape 5.2处理哨兵一号数据的完整实战教程。详细介绍了从数据导入、研究区裁剪、DEM自动下载与集成，到核心的配准、滤波及地理编码全流程，最终生成可用于定量分析的地理编码后向散射系数图。重点演示了DEM数据在SAR处理中的关键作用与自动获取方法，帮助用户快速掌握SAR数据基础处理技能。

coffee的博客 682

算法套路七——二叉树递归

该题与上题一样，递归思想基本一样，也是使用全局变量进行解决，不过该题在代码书写上值得注意，在go语言中只有值传递，当slice做为参数传递给函数的时候，新建了切片s，只是原始切片slice和参数s切片的底层数组是一样的，与Java不同，在Java中需要使用Lsit进行修改，且在函数结束前需要删除List的最后一个元素。给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

Pistachiout的学习博客 1954

将Windbg附加到软件进程上排查异常闪退的问题

使用Windbg和Process Explorer排查因为内存泄漏导致的软件异常闪退问题。

dvlinker的技术专栏 1万+

【人工智能】 WebDev Arena：实时AI Web开发竞赛的技术探索与价值

《AI编程竞赛推动Web开发技术创新》摘要：WebDev Arena作为聚焦Web开发领域的实时AI编程竞赛，通过标准化竞技环境检验AI模型在代码生成、问题解决等方面的能力。竞赛覆盖前端、后端等全流程开发环节，采用实时评分机制，推动AI对复杂Web需求的理解和多元技术栈适配。该赛事不仅促进AI编程技术创新，更为Web开发行业与AI技术融合搭建桥梁，有望提升开发效率、降低技术门槛。未来将拓展Web3.0等前沿技术主题，持续推动行业智能化发展。（150字）

奶爸的编程之路，也就一周冷个三天 258

算法——（6.2）二叉树的递归

那么疑问来了，为什么上一题为什么不用回溯，我在上一题特地强调了，他的路径是作为参数传入进去，最简单的理解就是每个递归函数的每个路径参数都是一个list，而这一题list是一个全局变量，所有的递归公用一个。需要注意的是，尽管对象类型按引用传递，但实际上传递的是引用的副本，而不是引用本身。4.由次可见，当递归左右孩子的时候他们的返回值并没用，这主要是每次返回的是递归的这个节点，这个并没有用处，后面会遇到需要改变左右孩子节点，或者建立关系时候就需要返回值了。变量存储的是对象的引用，而不是对象本身。

qq_57822260的博客 846

OceanSim： 基于Isaac Sim GPU 加速水下机器人感知仿真框架

OceanSim 采用先进的基于物理的渲染技术，对水下视觉和声学传感器进行精确建模。与其他模拟引擎相比，OceanSim 的渲染速度要快得多。作为 NVIDIA Issac Sim 的扩展，OceanSim 采用了多功能设计。通过融入快速发展的 NVIDIA Omniverse 生态系统，我们的模拟器自然而然地在机器人学习和水下机器人技术之间架起了一座桥梁，从而促进了水下应用中体现型人工智能技术的开发和部署。OceanSim 将以开放源码的方式提供，使研究界能够以合作的模式作出贡献。

机器人控制与仿真应用 2055

二叉树的讲解《四》（链式二叉树）

二叉树的链式存储，以及基本操作

m0_64770095的博客 1089

手把手完整实现STM32+ESP8266+MQTT+阿里云服务器+手机APP应用——第一节—阿里云物联网平台配置+IoTStudio界面绘制+MQTT.fx模拟MQTT客户端与使用AT命令发布订阅消息

通过MQTT.fx模拟连接以及通过CH340串口连接ESP8266发送AT命令，实现阿里云物联网平台发送数据同时接收数据，IOT studio界面显示数据。具体来说：使用ESP8266（本系列使用了ESP8266-ESP01/01S以及正点原子的ATK-ESP8266） 来连接网络，获取设备数据发送到阿里云物联网平台并显示数据，通过IOT studio界面显示数据并发送命令控制设备。本系列使用的主控芯片是STM32F103系列，当然也可以使用其他系列单片机都可以实现，思路都是一样的。同时本系列有手机APP源

嵌入式阿齐Archie 5万+

反光柱定位算法实战03：VEnus代码解析和纯反光柱定位中的可改进方向

本文深入解析了开源框架VEnus的反光柱定位与建图实现流程，包括强度提取、聚类、数据关联、位姿优化等核心模块。同时指出其三大局限：匹配质量脆弱性、单一传感器依赖和地图扩展逻辑缺失，并提出改进方向：融合里程计/IMU数据、引入图优化后端、建立动态地图维护机制。该分析为基于反光柱的定位系统优化提供了实用参考，有助于提升工业场景下的定位鲁棒性和精确性。

Studying…… 520

遍历二叉树的递归算法

目录 一、遍历二叉树的相关概念 二、四种遍历二叉树的方式 三、遍历二叉树的算法 四、遍历算法的分析 一、遍历二叉树的相关概念 1、遍历定义:顺着某 一条搜索路径巡访二叉树中的结点，使得每个结点均被访问一次，而且仅被访问一次(又称周游)。“访问”的含义很广，可以是对结点作各种处理，如:输出结点的信息、修改结点的数据值等，但要求这种访问不破坏原来的数据结构。 2、遍历目的:得到树中所有结点的一个线性排列。 3、遍历用途:它是树结构插入、 删除、修改、查找和排序运算的前提，是二叉树...

kxbdys的博客 1777

【Unity实战篇 】| 游戏中实现镂空遮罩效果【矩形、圆形镂空遮罩】

本文来写一下怎样在Unity中完成一个 镂空遮罩 的效果。 镂空遮罩 比较常用的有两种：矩形镂空遮罩、圆形镂空遮罩。 镂空遮罩 在游戏中常被当做新手引导必备的内容，可以给玩家更多不一样的体验。 下面就一起来看一下怎样做出这种效果吧！

努力前行，总会成为自己心中的那道光 1万+

数据结构与算法：二叉树的中序遍历（递归与非递归方法）

数据结构与算法：二叉树的中序遍历（递归与非递归方法） public class BinaryTree<E> { private TreeNode<E> root; //根节点 private List<TreeNode> nodeList = null; //二叉树节点的链式结构 public BinaryTree()...

樊凯的博客 1049

C# WinForm 基于DirectShow.dll编写的程序，可边预览边保存视频，音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择（默认选中第一个）2.可录制wmv和avi两种格式的视频并且都带有音频，avi可以录制的分辨率和帧数进行选择，wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照，也可边录制视频边拍照4.添加了视频和音频的压缩功能（酌情使用）这次二次开发发现C#对DirectShow的相关信息太少，这次做完也不敢藏私共享出来，还望大家指正

android 蓝牙通讯demo

android 下蓝牙通讯demo，实现了发现蓝牙，使能蓝牙，通过蓝牙发送消息。

数据结构与算法：二叉树的先序遍历（递归与非递归方法）

数据结构与算法：二叉树的先序遍历（递归与非递归方法） public class BinaryTree<E> { private TreeNode<E> root; //根节点 private List<TreeNode> nodeList = null; //二叉树节点的链式结构 public BinaryTree(...

樊凯的博客 1272

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

《数据结构风云》递归算法：二叉树遍历的精髓实现

**本文系统解析二叉树四大核心算法：单值验证、树结构比对、子树探测与镜像对称。通过递归分治的思维，层层拆解问题本质，提供清晰的解决路径与代码实现。这不仅是一次算法技巧的传授，更是编程思维的锤炼。后续将深入回溯、动态规划等进阶领域，助你在编程修行路上不断突破。**

晨非辰的学习记录博客~~ 1832

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0， 兼容Win7/Win10/WinXP，解压就可用。

数据结构-二叉树（计算二叉树深度的递归与非递归算法）

思路 二叉树深度递归怎么去想问题？ 求二叉树的深度为什么可以用递归呢？这是因为我们这样思考问题：求一个二叉树的深度，我们即求根结点所在二叉树的深度，即求左右子树的最大深度，对于每个结点都是求左右子树的最大深度，这样就是把一个大的问题切分成小的问题，然后最小的问题有一个出口，结点为空时深度为 0 二叉树的深度如果不用递归该怎么办？ 最直接的想法，就是使用栈，递归本来就是一种栈的方式，这时我们又联想到...

abcnull 的博客 1674

数据结构 创建二叉树 先序中序后序遍历 递归及非递归算法

#include <stdio.h> #include<malloc.h> #include<queue> #include<stack> using namespace std; typedef struct LNode{ int data; struct LNode *lchild, *rchild; }; //层序创建二叉树 struct LNode* creat(int a[],int n) { if(n==0) return NUL

weixin_44371476的博客 677

【数据结构】二叉树递归算法代码总结

上一年备考数据结构中自己整理并验证过的二叉树递归算法。分享给需要的朋友们。

微雨停了的博客 2878

【数据结构与算法】二叉树的递归遍历

二叉树的递归遍历 定义树节点 //定义节点 typedef struct node { struct node *lchild; struct node *rchild; char data; }BiTreeNode, *BiTree;//*BiTree的意思是给 struct node*起了个别名，叫BiTree，故BiTree为指向节点的指针。 按照前序顺序创建二叉树 //按照...

程序媛养成记 4080

数据结构-二叉树（复制二叉树的递归算法）

文章目录思路Java 实现 思路 Java 对象满足深拷贝，直接赋值不就行了，为什么要复制呢？ 确实，Java 的对象赋值满足深拷贝，类似 C 中的地址赋值，那这样直接 a=b 不就行了，干嘛还要写复制的一个算法呢？因为我们的这个复制希望 a 的操作不会影响 b 这颗二叉树，但是 a 和 b 这两颗二叉树中保存到的数据值都是一样的，这就是我们复制的目的 如何复制二叉树呢？ 其实就是写一遍遍历而已 ...

abcnull 的博客 3989

数据结构-二叉树遍历的非递归算法

首先针对于严慧敏版本的《数据结构》中关于非递归算法的描述：

xhoo 的博客 819

#数据结构 二叉树前序遍历非递归算法

qq_42368203的博客 514

【数据结构与算法】二叉树的非递归前中后序遍历

二叉树的前中后遍历如果采取递归的方式来实现，是相当容易的事情。递归之所以强大，是因为有系统自动压栈。那么非递归的前中后序遍历就是借助栈，通过我们自己手动压栈来实现二叉树的遍历。

joy.728的博客 1458

#数据结构判断二叉树是否为平衡二叉树递归算法

qq_42368203的博客 335

数据结构实践—— 二叉树遍历的递归算法

/* * Copyright (c) 2015, 烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称： btree.cpp,main.cpp,btree.h * 作者：唐子健* 完成日期：2015年11月9日 * 版本号：codeblocks * * 问题描述: 实现二叉树的先序、中序、后序遍历的递归算法，并对用”A(B(D,E(H(J,K(L,

ytdxtzj的博客 487
上一篇： 数据结构——从叶子结点到根节点的全部路径
下一篇： 数据结构——基于字符串模式匹配算法的病毒感染检测
点赞 7
评论 0
书签 书签 81
943802606
943802606
博客等级 码龄6年 1万+粉丝 177原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值