链式二叉树的前序创建、递归前序遍历、非递归堆栈前序遍历、前序销毁以及求二叉树的深度

最新推荐文章于 2021-11-19 22:26:55 发布
最新推荐文章于 2021-11-19 22:26:55 发布
阅读量942 收藏 5
点赞数
文章标签： 二叉树 前序遍历 树深度 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/meiyubaihe/article/details/30250959
版权

链式二叉树的前序创建、递归前序遍历、非递归堆栈前序遍历、前序销毁以及求二叉树的深度

需要完整代码可到CSDN资源页搜索链式二叉树的前序创建、递归遍历、利用堆栈的非递归遍历、前序销毁以及求二叉树的深度进行下载

1、数据结构

二叉树的一个结点的数据结构包含4个域：
（1）值域：保存结点的值，类型为 ElemType，可以自己定义为合适的类型， 为了简单，我们再次设定值域的类型为char
（2）指向父结点的指针
（3）指向左儿子结点的指针
（4）指向右儿子结点的指针 
typedef char ElemType;
typedef struct BiTree{
	ElemType data;
	struct BiTree *parent;
	struct BiTree *leftchild;
	struct BiTree *rightchild;
}BiTree;

2、递归创建前序二叉树

前序二叉树的创建顺序即为先创建树的根结点，再创建树的左子树，再创建树的右子树，即为中左右的顺序。
（1）先创建树的根结点
（2）再创建根结点的左子树，左子树也时一棵树，同样需要按照前序顺序进行创建，则又回到（1），这就是一个递归的过程，若左子树为空，则不需要进行递归。
（3）左子树创建完毕后，最后创建右子树，右子树也是一棵树，同样需要按照前序顺序进行创建，也回到（1），这也是一个递归的过程，若右子树为空，也不需要进行递归。若左右子树同时为空，则表示该结点为叶子结点。
递归函数式需要结束递归的条件的：而在此结束递归的条件就是叶子结点，因为叶子结点的左右子树都为空，不需要进行递归调用。但是叶子结点的特征位置特征不够明确，它在树中的深度是不确定的。 因此需要我们找到描述叶子结点的方法：由于叶子节点的左右子树都为空， 我们用 ‘.’来表示空树（结点）。因此在因此在输入叶子结点后，要连续输入两个‘.’来标志该结点为叶子结点，第一个‘.’表示该非最底层叶子结点的左结点为空，因此不需要递归调用，第二个‘.’表示该非最底层叶子结点的右结点为空，因此也不需要递归调用。对于左子树为空的非叶子结点，在输入该结点后要输入一个'.'来标识其左子树为空，对于右子树为空的非叶子结点，在其左子树的所有结点输入入完毕后，需要输入一个'.'来标识其右子树为空。例如：对于树：

  d

  ╱ ╲

  c         e

   ╱           ╲

   b                 f

    ╱                   ╲

   a                         g

（1）首先输入结点d，
（2）输入d的左儿子c，
（3）输入c的左儿子b，
（4）输入b的左儿子a，a为叶子结点，故输入a完毕之后紧接着输入两个空结点'.'以标志a为叶子结点，此时b的左子树输入完毕
（5）输入b的右子树，b的右子树为空，故应输入一个空结点'.'来标志b的右子树为空，此时c的左子树输入完毕
（6）输入c的右子树，c的右子树为空，故应输入一个空结点'.'来标志c的右子树为空，此时d的左子树输入完毕
（7）输入d的右子树，输入d的右儿子e，e的左子树为空，故输入e完毕之后紧接着输入一个空结点'.'来标识e的左子树为空，此时e的左子树输入完毕
（8）输入e的右子树，输入e的右儿子f，f的左子树为空，故输入f完毕之后紧接着输入一个空结点'.'来标识f的左子树为空，此时f的左子树输入完毕
（9）输入f的右子树，输入f的右儿子g，g为叶子结点，故输入g完毕之后紧接着输入两个空结点'.'以标志f为叶子结点，此时f的右子树输入完毕
整棵树的结点页输入完毕，输入结点的顺序为：dcba....e.f.g..
（1）前两个'.'标志a为叶子结点
（2）第三个'.'标志b的右子树为空
（3）第四个'.'标志c的右子树为空
（4）第五个'.'标志e的左子树为空
（5）第六个'.'标志f的左子树为空
（6）最后两个'.'标志g为叶子结点
 
//按先序次序输入二叉树中结点的值（一个字符），'.'表示空树
//对于先序输入，每个叶子结点的左右结点都先输入'.',即在输入一个叶子结点后，要连续输入两个'.'程序才能认定这个结点为叶子结点
BiTree *PreCreateBiTree(  ) 
{

	BiTree *tree;

	tree = NodeMalloc(  );  //为该结点分配空间
	printf( "请输入结点的值:\n" );
	scanf( "%s", &(tree->data) );  //输入结点的值
	if( tree->data == '.' ){  //如果输入为字符型的'.'，表示该结点为空，将为该结点分配的空间释放，并返回NULL
		free( tree );
		tree = NULL;
	}
	else{
		tree->leftchild = PreCreateBiTree( );  //生成当前树的根结点的左子树
		if( tree->leftchild )                   //如果当前结点的左子树不为空
			tree->leftchild->parent = tree;  //则左子树的根结点的父节点即为当前结点
		tree->rightchild = PreCreateBiTree( );//生成当前树的根结点的右子树
		if( tree->rightchild )				//如果当前结点的右子树不为空
			tree->rightchild->parent = tree;//则右子树的根结点的父节点即为当前结点
	}
	return tree;
}


 
 
3、利用递归的前序遍历
 

 

 
 
 
   
 
 
 
 
  
递归的前序遍历与创建函数的逻辑相似：
 
  
（1）首先判断树是否为空，若树为空，则打印树为空的信息
 
  
（2）若树不为空，判断当前结点是否为叶子结点（叶子结点的左右子树都为空），若是叶子结点，则打印叶子结点的值域
 
  
（3）若树不为空，且当前结点不是叶子结点，则先打印当前结点的值域。
 
  
（注意：下面的1）和2）要么其中一个发生，要么都发生，因为当前结点不是叶子结点，所以它至少存在一个子树）
 
 
 

 

 
 
 
  
 
   
1）若左子树不为空，递归调用自身打印左子树的各结点的值域
 
   
2）若右子树不为空，递归调用自身打印右子树的各结点的值域
 
  
 
 
 

 
 

void PreOrderTraverse( BiTree *tree, void( *visit )( BiTree *node ) ) 
{
	if( tree == NULL )
		printf( "the tree is empty!" );
	else if( tree->leftchild == NULL && tree->rightchild == NULL ){ //当前结点为叶子结点则输出当前结点的值	
		visit( tree );  
	}
	else{  //当前结点不是叶子结点，则先打印当前结点的值，
		visit( tree );  
		if( tree->leftchild ){               //若当前结点的左子树不为空，则再按先序打印其左子树的结点
			PreOrderTraverse( tree->leftchild, visit );  
		}
		if( tree->rightchild ){      //如果当前树的根结点的右子树不为空，再按先序打印其右子树的结点
			PreOrderTraverse( tree->rightchild, visit );
		}
	}
}
 

4、利用堆栈实现非递归的前序遍历
 

 
 前序遍历的顺序就是：根，左，右 
 
 
 （1）首先判断树是否为空，若树为空，则打印树为空的信息 
 
 
 （2）若树不为空： 
 
 
 
 
  
1）访问当前树的根结点
 
  
2）判断当前根结点的右子树是否为空，若不为空，将右子树的根结点压栈
 
  
3）判断当前根结点的左子树是否为空：
 
 
 

 

 
 
 
  
 
   
A.若左子树为空：
 
  
 
 
 

 

 
 
 
  
 
   
 
    
a)若栈为空，表示当前树的结点都已经访问完毕，则访问结束
 
    
b)若栈不为空，则弹出栈顶，回到1）对栈顶结点进行访问，此时的栈顶为当前结点的右子树的根结点
 
   
 
  
 
 
 

 

 
 
 
  
b.若左子树不为空，回到1）对左子树进行访问
 
 
 

 
需要注意的是： 
栈使用完毕之后，一定要销毁，不然会造成内存泄露，可能造成下次运行时出错。 

 
  

 
 
//利用栈结构实现非递归的前序遍历
void PreOrderTraverse_stack( BiTree *tree, void( *visit )( BiTree *node ))
{
	BiTree *current;
	Lstack *stack;
	BiTree right;

	current = tree;   //将current指向当前的树根结点
	stack = InitStack( );  //将栈初始化为空栈
	if( current == NULL )
		printf( "the tree is empty!" );
	while( !StackEmpty( stack ) || current ){ 	//栈不为空或者current不为空时进入循环，即还有没有访问完结点时进入循环
		visit( current );               //访问当前结点	
		if( current->rightchild ){   //如果current的右子树不为空
			Push( stack, *current->rightchild );   //将current的右子树的结点压栈
		}
		if( current->leftchild == NULL ){			//如果current的左子树为空，
			if( StackEmpty( stack ) )  //且栈也为空（栈中存的是右子树的根结点，栈为空表示右子树为空）
				break;               //结束循环
			Pop( stack, &right );  //如果栈不为空，弹出栈顶，访问右子树
			current = &right;
		}
		else{							//如果current的左子树不为空，访问左子树
			current = current->leftchild;
		} 
	} //当栈为空且current为空时当前树的所有结点都被访问过,只有栈为空时表示当前树的左子树的所有结点都遍历完了
	DestroyStack( stack );//栈使用完毕之后，一定要销毁，不然会造成内存泄露
}
 
 
5、判断树的深度
 

 

 
 利用递归进行判断： 

 

 
 （1）若树为空，则返回0 

 

 
 （2）若树不为空：则树的深度为其左右子树中深度值较大的值加1 

 

 
 
1）计算左子树的深度depth_l，递归调用相当于又从（1）开始
 
 
2）计算右子树的深度depth_r，递归调用相当于又从（1）开始
 
 
3）比较两个深度值的大小，返回较大值加1为当前树的深度
 

 

 
  
 
//判断树的深度
int BiTreeDepth( BiTree *tree ) 
{
	int depth_r;
	int depth_l;
	if( tree == NULL )  //如果为空树，则返回0，表示树的深度为0
		return 0;
	else{  //否则计算当前树的左右子树的深度
		depth_l = BiTreeDepth( tree->leftchild );
		depth_r = BiTreeDepth( tree->rightchild );
		
		if( depth_l > depth_r )  //当前树的深度为其左右子树深度较大的值加1
			return depth_l + 1;
		else
			return depth_r + 1;
	}
}
 
 
6、先序顺序销毁一个树
 
 
 
  利用递归： 
 
 
 
 
  （1）若树为空，打印树为空的信息 
 
 
 
 
  （2）若树不为空：判断树是否为叶子结点 
 
 

 

 
 
 
  
 
   1）若为叶子结点，则释放该结点 
  
 
 
 
 
 
  2）若不为叶子结点，将该结点的左右子树的根结点保留下来，释放该结点，需要注意的是：由于当前释放的结点不是叶子结点，所以a和b至少有一个会发生。 
 
 

 

 
 
 
  
 
   a.若左子树不为空，则递归调用函数自身销毁左子树，此时左子树不为空，所以进入调用函数后会回到（2） 
  
 
  
 
   b.若右子树不为空，则递归调用函数自身销毁右子树，此时右子树不为空，所以进入调用函数后会回到（2） 
  
 
 
 

 

void PreDestroyBiTree( BiTree *tree )  
{
	BiTree *left;
	BiTree *right;

	if( tree == NULL ){  //如果树为空树，则进行打印
		printf( "DestroyBiTree:the tree is empty!\n" );
	}
	else if( tree->leftchild == NULL && tree->rightchild == NULL ){  //如果当前结点为叶子结点，则释放为其分配的空间
		free( tree );
		tree = NULL;
	}
	else{  
		left = tree->leftchild;  //用两个指针分别指向当前结点的左右子树的根结点，
		right = tree->rightchild;
		
		free( tree );  //释放当前根结点
		tree = NULL;

		if( left ){    //如果当前结点的左子树不为空，则先释放左子树的各个结点
			PreDestroyBiTree( left );
			left = NULL;  //左子树的空间释放完毕后，将指向左子树根结点的指针置为空
		}
		if( right ){//如果当前结点的右子树不为空，则再释放右子树的各个结点
			PreDestroyBiTree( right );
			right = NULL;//右子树的空间释放完毕后，将指向右子树根结点的指针置为空
		}
	}
}<span style="white-space:pre">	</span>
 

 

 
 
7、为了完整性在此给出其他相关数据结构和函数
 
 
 
  （1）堆栈函数stack.c 
 
 
 
 
  
#include"bitree.h"
#include< stdlib.h >
#include< stdio.h >
//初始化栈空间
Lstack *InitStack( )
{
	Lstack *S;
	S = ( Lstack * )malloc( sizeof( Lstack ) );
	if( !S ){ 
		printf( "OVERFLOW!\n");
		exit( EXIT_FAILURE );
	}
	S->link = NULL;
	return S;
}
//销毁栈
void DestroyStack( Lstack *S )
{
	ClearStack( S );
	free( S );
}
 
  
//清空栈
void ClearStack( Lstack *S )
{
	Lstack *top;
	top = S->link;
	while( top != NULL ){
		S->link = S->link->link;
		free( top );
		top = S->link;
	}
	S->link = NULL;
}

//压栈
void Push( Lstack *S, LElemType e )
{
	Lstack *first;
	first = ( Lstack * )malloc( sizeof( Lstack ) );
   	first->data = e;
	first->link = S->link;
	S->link = first;
}

//弹栈
void Pop( Lstack *S, LElemType *e )
{
	if( S->link == NULL ){
		printf( "the stack is empty!\n");
		exit( EXIT_FAILURE );		
	}
	*e = S->link->data;
	S->link = S->link->link;
}<pre name="code" class="cpp">//栈中元素个数
int Length( Lstack *S )
{
	int count = 0;
	Lstack *current = S->link;
	while( current != NULL ){
		count++;
		current = current->link;
	}
	return count;
}

//判断栈是否为空,若为空，返回TRUE，非空返回FALSE
int StackEmpty( Lstack *S )
{
	if( Length( S ) )
		return 0;
	return 1;
}
 
  
 
  
 
  （2）头文件bitree.h 
 
 

 

 
 
<pre name="code" class="cpp">#define TRUE 1
#define FALSE 0

//树的数据结构
typedef char ElemType;  
typedef struct BiTree{
	ElemType data;
	struct BiTree *parent;
	struct BiTree *leftchild;
	struct BiTree *rightchild;
}BiTree;

//堆栈的数据结构
typedef BiTree LElemType;
typedef struct temp{
	struct temp	*link;
	LElemType   data;
}Lstack;

Lstack * InitStack( );//初始化栈为空栈
void DestroyStack( Lstack *S );//将栈销毁
void ClearStack( Lstack *S );  //将栈清空
int GetTop( Lstack *S, LElemType *e );//获得栈顶元素，保持栈的状态不变
void Push( Lstack *S, LElemType e );//并将元素e压入栈顶
void Pop( Lstack *S, LElemType *e ); //弹栈,并将出栈元素的值赋给e
int Length( Lstack *S );//栈中元素个数
int StackEmpty( Lstack *S );//判断栈是否为空,若为空，返回TRUE，非空返回FALSE
void Print( Lstack *S ); //打印栈中的所有元素


BiTree *NodeMalloc( );  //为一个树结点分配空间
BiTree *InitBiTree( );  //构造空的二叉树
BiTree *PreCreateBiTree( ); //按先序次序输入二叉树中结点的值（一个字符），字符型的句号'.'表示为空树
void PreDestroyBiTree( BiTree *tree ); //按先序次序销毁树
void PreOrderTraverse( BiTree *tree, void( *visit )( BiTree *node ) ); //递归的前序遍历，按先序次序输出二叉树中各个结点的值（字符型）
void PrintElem( BiTree *node );//打印结点值
void PreOrderTraverse_stack( BiTree *tree, void( *visit )( BiTree *node ));//利用堆栈的非递归的前序遍历
int BiTreeEmpty( BiTree *tree );//判断树是否为空
int BiTreeDepth( BiTree *tree );//求树的深度

 
 
 
 
 
 
 
 
 
 （3）树函数bitree.c 

 

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

BiTree *InitBiTree(  )  //构造空的二叉树
{
	 return NULL;
}

BiTree * NodeMalloc(  )  //为一个树结点分配空间并将结点进行初始化
{
	BiTree *node;
	node = ( BiTree * )malloc( sizeof( BiTree ) );
	if( node == NULL ){
		printf( "NodeMalloc:OVERFLOW\n" );
		exit( EXIT_FAILURE );
	}
	node->leftchild = NULL;   //初始化结点的各个指针域为NULL
	node->rightchild = NULL;
	node->parent = NULL;
	return node;
}

//按先序次序输入二叉树中结点的值（一个字符），'.'表示空树
//对于先序输入，每个叶子结点的左右结点都先输入'.',即在输入一个叶子结点后，要连续输入两个'.'程序才能认定这个结点为叶子结点
BiTree *PreCreateBiTree(  ) 
{

	BiTree *tree;

	tree = NodeMalloc(  );  //为该结点分配空间
	printf( "请输入结点的值:\n" );
	scanf( "%s", &(tree->data) );  //输入结点的值
	if( tree->data == '.' ){  //如果输入为字符型的'.'，表示该结点为空，将为该结点分配的空间释放，并返回NULL
		free( tree );
		tree = NULL;
	}
	else{
		tree->leftchild = PreCreateBiTree( );  //生成当前树的根结点的左子树
		if( tree->leftchild )                   //如果当前结点的左子树不为空
			tree->leftchild->parent = tree;  //则左子树的根结点的父节点即为当前结点
		tree->rightchild = PreCreateBiTree( );//生成当前树的根结点的右子树
		if( tree->rightchild )				//如果当前结点的右子树不为空
			tree->rightchild->parent = tree;//则右子树的根结点的父节点即为当前结点
	}
	return tree;
}
//先序顺序销毁一个树，即先释放根结点，再释放左右子树（左右子树的释放顺序可以调换）
void PreDestroyBiTree( BiTree *tree )  
{
	BiTree *left;
	BiTree *right;

	if( tree == NULL ){  //如果树为空树，则进行打印
		printf( "DestroyBiTree:the tree is empty!\n" );
	}
	else if( tree->leftchild == NULL && tree->rightchild == NULL ){  //如果当前结点为叶子结点，则释放为其分配的空间
		free( tree );
		tree = NULL;
	}
	else{  
		left = tree->leftchild;  //用两个指针分别指向当前结点的左右子树的根结点，
		right = tree->rightchild;
		
		free( tree );  //释放当前结点
		tree = NULL;

		if( left ){    //如果当前结点的左子树不为空，则先释放左子树的各个结点
			PreDestroyBiTree( left );
			left = NULL;  //左子树的空间释放完毕后，将指向左子树根结点的指针置为空
		}
		if( right ){//如果当前结点的右子树不为空，则再释放右子树的各个结点
			PreDestroyBiTree( right );
			right = NULL;//右子树的空间释放完毕后，将指向右子树根结点的指针置为空
		}
	}
}


//递归的前序遍历，按先序次序输出二叉树中各个结点的值（字符型）
void PreOrderTraverse( BiTree *tree, void( *visit )( BiTree *node ) ) 
{
	if( tree == NULL )
		printf( "the tree is empty!" );
	else if( tree->leftchild == NULL && tree->rightchild == NULL ){ //当前结点为叶子结点则输出当前结点的值	
		visit( tree );  
	}
	else{  //当前结点不是叶子结点，则先打印当前结点的值，
		visit( tree );  
		if( tree->leftchild ){               //若当前结点的左子树不为空，则再按先序打印其左子树的结点
			PreOrderTraverse( tree->leftchild, visit );  
		}
		if( tree->rightchild ){      //如果当前树的根结点的右子树不为空，再按先序打印其右子树的结点
			PreOrderTraverse( tree->rightchild, visit );
		}
	}
}


//打印树结点的data域
void PrintElem( BiTree *node )
{
	if( node ){
		printf( "%c", node->data );
	}
}

//利用栈结构实现非递归的前序遍历
void PreOrderTraverse_stack( BiTree *tree, void( *visit )( BiTree *node ))
{
	BiTree *current;
	Lstack *stack;
	BiTree right;

	current = tree;   //将current指向当前的树根结点
	stack = InitStack( );  //将栈初始化为空栈
	if( current == NULL )
		printf( "the tree is empty!" );
	while( !StackEmpty( stack ) || current ){ 	//栈不为空或者current不为空时进入循环，即还有没有访问完结点时进入循环
		visit( current );               //访问当前结点	
		if( current->rightchild ){   //如果current的右子树不为空
			Push( stack, *current->rightchild );   //将current的右子树的结点压栈
		}
		if( current->leftchild == NULL ){			//如果current的左子树为空，
			if( StackEmpty( stack ) )  //且栈也为空（栈中存的是右子树的根结点，栈为空表示右子树为空）
				break;               //结束循环
			Pop( stack, &right );  //如果栈不为空，弹出栈顶，访问右子树
			current = &right;
		}
		else{							//如果current的左子树不为空，访问左子树
			current = current->leftchild;
		} 
	} //当栈为空且current为空时当前树的所有结点都被访问过,只有栈为空时表示当前树的左子树的所有结点都遍历完了
	DestroyStack( stack );
}

int BiTreeEmpty( BiTree *tree )
{
	if( tree == NULL )
		return TRUE;
	else
		return FALSE;
}

//判断树的深度
int BiTreeDepth( BiTree *tree ) 
{
	int depth_r;
	int depth_l;
	if( tree == NULL )  //如果为空树，则返回0，表示树的深度为0
		return 0;
	else{  //否则计算当前树的左右子树的深度
		depth_l = BiTreeDepth( tree->leftchild );
		depth_r = BiTreeDepth( tree->rightchild );
		
		if( depth_l > depth_r )  //当前树的深度为其左右子树深度较大的值加1
			return depth_l + 1;
		else
			return depth_r + 1;
	}
}
（4）主函数:main.c 

 

 
  
 
#include< stdio.h >
#include"bitree.h"
void main()
{
	BiTree *bi;
	int depth;


	printf( "先序顺序构建二叉树，对于叶子结点在其后要连续输入两个'.'\n" );
	printf( "以标志该结点为叶子结点,'.'表示空结点\n" );
	bi = PreCreateBiTree(  ); 
	
	printf( "*****PreOrderTraverse*****\n" );
	PreOrderTraverse( bi, PrintElem );
	printf( "\n" );

	printf( "**PreOrderTraverse_stack**\n" );
	PreOrderTraverse_stack( bi, PrintElem );
	printf( "\n" );

	printf( "*******BiTreeDepth********\n" );
	depth = BiTreeDepth( bi );
	printf( "the depth of the tree is %d\n", depth );
<span style="white-space:pre">	</span>printf( "*****PreDestroyBiTree*****\n" );
<span style="white-space:pre">	</span>PreDestroyBiTree( bi );
} 
 
 
 
 
 
 
 
 
 
 

 

 
 
 
  

 
 
  
 
 
 

 

 
 
  

 

 
 
  


                

        

        

    

  


    

      

        

            

              
                
                  JessicaWind
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
【数据结构】 拿捏二叉树堆排序与遍历

				
			

			

				

					qq_61386381的博客
				

				

					07-29
					
					1435
					
				

			

		

		

			
				
二叉树的存储结构



二叉树的堆排序

堆的概念

堆向上调整算法

堆向下调整算法

堆排序应用之TopK问题



二叉树的遍历

链式二叉树

创建二叉树

二叉树的遍历

前序遍历

中序遍历

后续遍历

层序遍历

............

			
		

	



                

              
                



	

		

			

				
					
(六)数据结构之二叉树的简单实现

				
			

			

				

					TECH_PRO的博客
				

				

					09-17
					
					585
					
				

			

		

		

			
				
1、基本数据结构
/* 二叉树的基本数据结构的定义 */
typedef char ElementType;
typedef struct TreeNode *BinTree;
typedef BinTree Position;
struct TreeNode{
	ElementType Data;
	BinTree Left;
	BinTree Right;
};
采用链式存储方式来存储二叉

			
		

	



                


  
              

                


	

		

			

				
					
【数据结构】二叉树前序遍历（非递归）

				
			

			

				

					qq_42270373的博客
				

				

					10-31
					
					397
					
				

			

		

		

			
				
前序遍历的顺序：根-左-右


	思路分析：
	
非递归的二叉树前序遍历大的思想分为：①访问它的左路节点；②访问左路节点的右子树

具体非递归的实现思路如下：  
①拿到根节点，然后将其入栈，再看它的左子树是否为空； 
②若左子树不为空，则把此时左子树作为当前节点，重复操作①； 
③当左子树为空时，让栈顶节点出栈，但不输出，并去访问出栈节点的右子树，看其是否为空； 
④若出栈节点的右子树不为空，则...

			
		

	





	

		

			

				
					
链式二叉树的中序创建、递归中序遍历、非递归堆栈中序遍历、中序销毁

				
			

			

				

					JessicaWin
				

				

					06-12
					
					1284
					
				

			

		

		

			
				
链式二叉树的中创建、递归中序遍历、非递归堆栈中序遍历、中序销毁

			
		

	



		

			
		



	

		

			

				
					
链式二叉树的后序创建、递归后序遍历、非递归堆栈后序遍历、后序销毁

				
			

			

				

					JessicaWin
				

				

					06-13
					
					1216
					
				

			

		

		

			
				
链式二叉树的后序创建、递归后序遍历、非递归堆栈后序遍历、后序销毁

			
		

	





	

		

			

				
					
链式二叉树的三种遍历方法(C递归)

				
			

			

				

					ana35287的博客
				

				

					01-29
					
					587
					
				

			

		

		

			
				
二叉树的三种遍历
链式二叉树又称二叉链表，遍历有三种，分别是前序(先序)，中序，后序。
首先创建二叉树，没有建立，何谈遍历？
定义二叉树的存储结构为链式存储

1 typedef struct BiNode{
2     int data;
3     BiNode *lchild,*rchild;   //左孩子和右孩子
5 }BiNode;
6 typedef st...

			
		

	





	

		

			

				
					
二叉树的创建和遍历实现

				
			

			

				

					weixin_43083491的博客
				

				

					11-19
					
					2390
					
				

			

		

		

			
				
二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。
既然二叉树是通过递归定义的，所以想要创建一颗二叉树，这里可以借助递归去创造。

			
		

	





	

		

			

				
					
数据结构--二叉树(递归实现)

				
			

			

				

					一氧化二氢的执着
				

				

					10-23
					
					206
					
				

			

		

		

			
				
概述
二叉树是数据结构中十分重要的一类结构, 其中有很多应用.
二叉树的特点：

每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
二叉树的子树有左右之分，其子树的次序不能颠倒。


二叉树根据存储的结构可分为链式存储和顺序存储,
本文只涉及链式存储, 顺序存储请参展作者上一篇文章:二叉树的顺序存储–堆

结构
typedef char BTDataType;

typedef struct...

			
		

	





	

		

			

				
					
二叉树基础概念

				
			

			

				

					icecoola_的博客
				

				

					12-04
					
					876
					
				

			

		

		

			
				
数据结构 二叉树 概念 历遍 代码实现 基础知识

			
		

	





	

		

			

				
					
链式二叉树的前序创建、递归遍历、利用堆栈的非递归遍历、前序销毁以及求二叉树的深度

				
			

			

				

					06-12
				

			

		

		

			
				
综上所述，链式二叉树的前序操作涵盖了创建、遍历和销毁等基本操作，同时计算树的深度对于理解和分析二叉树的特性至关重要。在实际应用中，这些概念和算法经常被用到，尤其是在数据结构和算法的学习与实践中。

			
		

	





	

		

			

				
					
基于C语言的Dao编程语言设计源码

				
			

			

				

					09-28
				

			

		

		

			
				
该项目是一款名为Dao的编程语言设计源码，采用C语言为主要开发语言，并辅以C、C++、Shell和CSS等语言。项目文件共计225个，其中包含126个Dao源文件、39个C源文件、36个C头文件、9个C++源文件、3个文本文件、2个Vim配置文件、1个ChangeLog文件、1个daomake工具文件、1个README文件、1个配置文件。这个项目旨在构建一个高效、可扩展的编程语言环境。

			
		

	





	

		

			

				
					
如何自定义数据集进行目标检测_keras-yolo3.zip

				
			

			

				

					09-28
				

			

		

		

			
				
如何自定义数据集进行目标检测_keras-yolo3

			
		

	





	

		

			

				
					
基于JavaScript及多语言融合的勤工俭学平台设计源码

				
			

			

				

					09-28
				

			

		

		

			
				
本项目是一款基于JavaScript及多语言融合的勤工俭学平台设计源码，共计367个文件，涵盖231个Java源代码文件、27个XML配置文件、23个JavaScript文件、19个CSS文件、8个PNG图像文件以及少量其他类型文件。该平台旨在为勤工俭学活动提供高效便捷的解决方案，支持多种语言的交互，满足不同用户的需求。

			
		

	





	

		

			

				
					
初始化对LoRA微调动态的影响研究

				
			

			

				

					09-28
				

			

		

		

			
				
内容概要：研究了低秩适应（Low Rank Adaptation, LoRA）方法下不同随机初始化设置的效果与动态特性。论文主要发现，在初始化矩阵B为零、矩阵A随机时，模型通常可以使用更大的学习率并取得较好的效果，但这种情况下会出现内部不稳定现象。然而当A被初始化为零而B随机时，则不具备上述优势。通过理论和大量实验证明，初始化选择A而非B将导致更好的优化结果与训练稳定性。
适合人群：机器学习、神经网络的研究员、深度学习领域的科研学者。
使用场景及目标：在大规模语义模型的参数调整过程中选择恰当的初始化配置，从而提升效率以及性能。对于LoRA微调任务来说，在有限算力条件下高效地利用少量新增训练参数进行自适座行动。
其他说明：文中提出的结论有助于未来改进基于小样本学习的任务，同时指出了目前两种初始化方式均存在缺陷，提示可能需要进一步的研究来解决这些问题。尽管当前方法表现优于默认的LoRA初始化，但仍有一定局限性和潜在改进方向。


			
		

	





	

		

			

				
					
【PFJSP问题】基于matlab豪猪算法CPO求解置换流水车间调度问题PFSP【含Matlab源码 7895期】.mp4

				
			

			

				

					09-28
				

			

		

		

			
				
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白；
1、代码压缩包内容
主函数：main.m；
调用函数：其他m文件；无需运行 
运行结果效果图；

2、代码运行版本
Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主；

3、运行操作步骤
步骤一：将所有文件放到Matlab的当前文件夹中； 
步骤二：双击打开main.m文件； 
步骤三：点击运行，等程序运行完得到结果；

4、仿真咨询
如需其他服务，可私信博主或扫描视频QQ名片；
4.1 博客或资源的完整代码提供
4.2 期刊或参考文献复现
4.3 Matlab程序定制
4.4 科研合作


			
		

	





	

		

			

				
					
IGWO-SVM：改良的灰狼优化算法改进支持向量机 
采用三种改进思路：两种Logistic和Tent混沌映射和采用DIH策略

					
最新发布

				
			

			

				

					09-28
				

			

		

		

			
				
IGWO-SVM：改良的灰狼优化算法改进支持向量机。
采用三种改进思路：两种Logistic和Tent混沌映射和采用DIH策略。
采用基于DIH维度学习的狩猎搜索策略为每只狼构建邻域，增强局部和全局搜索能力，收敛速度比GWO更快，适用于paper。


			
		

	





	

		

			

				
					
二叉树非递归遍历：前序与中序实现解析

				
			

			

				

					
				

			

		

		

			
				
"深入理解二叉树的非递归遍历"  二叉树是计算机科学中基础且关键的数据结构，它衍生出了许多其他复杂的数据结构，如堆、B树、红黑树等。二叉树的遍历是理解和操作二叉树的重要手段，主要分为前序遍历、中序遍历和...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值