二叉树--递归的魅力

已于 2023-05-05 22:39:49 修改
阅读量150 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言
于 2023-04-27 13:10:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64860543/article/details/130400899
版权

        最近想把之前学的一些东西稍微总结一下，用C语言写一下基本的数据结构，先从比较难理解但是容易写的二叉树开始。

目录

一、学习二叉树不得不说的知识 

        1.1二叉树的定义

        1.2其他的一些基础知识

二、二叉树的存储结构

2.1顺序存储结构

2.2 链式存储结构

三、基础功能及代码实现

3.1 构造二叉树

3.2 销毁二叉树

3.3 输出二叉树

3.4 二叉树节点数和深度

3.5 二叉树最左的结点和最右的结点

3.6 查找结点

四 写在最后

五 完整代码

一、学习二叉树不得不说的知识 

        1.1二叉树的定义

        二叉树（binary tree）是一个有限的结点集合，这个集合或者为空，或者由一个根节点和两根互不相交的称为左子树和右子树的二叉树组成。

        这是官方给出的定义，我们可以从中知道这么几个点：

        （1）二叉树是可以为一个空树的，也就是一个节点都没有，成为空二叉树

        （2） 二叉树的度最多是2，意味着左右结点可以为空，但是不要求度只能是2。当所有分支节点都有左右孩子节点的时候，并且叶子节点都集中在二叉树最下一层时，这种二叉树成为满二叉树。

           两个基本概念：

                     （1）结点的度：某个结点的子数的个数

                     （2）叶子结点：度为0的结点，也就是没有左右孩子的结点

                                              

                                                 满二叉树如图所示（超级整齐是不是）

        （3）最重要的一点，每一个根节点的左右孩子子树也是一个二叉树，这也就是我们下列使用递归算法的前提。正是因为他的左右孩子结点是一颗全新二叉树的根节点，我们对此类问题才能得心应手，但是这也是比较难理解的点。

        1.2其他的一些基础知识

（1）完全二叉树：若二叉树最多只有最下面两层结点度数可以小于2，并且最下面一层的叶子节点都依次排列在该层最左边的位置上，这样的树成为完全二叉树（complete binary tree）

满二叉树其实就是完全二叉树的一种特例

抓住这两个关键字”最下面两层“、”最左边“，很关键，这就好像让二叉树赋予了某种线性特征一般，结点与结点之间更加有序了，从上到下，从左到右，一个接着一个标号，只要有了结点数目我们就可以构造出一个唯一的完全二叉树，下列所说的顺序存储结构与之有很大的联系。结合下图看看：

 （2）二叉树效率更高（那必须），任何m次树都i可以转换为二叉树结构（这很关键），具体转换过程大家可以自行搜索。

二、二叉树的存储结构

2.1顺序存储结构

        记住几个比较重要的点

（1）对于一般的二叉树，如果按照顺序结构存储，很难得到二叉树中结点与结点之间的逻辑关系，所以我们可以将一般二叉树进行改造，通过虚构一些空节点，从而将一般二叉树转换为完全二叉树，只要将虚构的空节点用特殊的标号（比如‘@’）就可以

（2）完全二叉树和满二叉树适合采用顺序存储结构，因为不会造成空间的大量浪费，而对于一般二叉树，当树的深度提高，空节点数目过多会造成空间的大量浪费。这是顺序结构的缺陷

（3）顺序结构存储有利于我们快速找到一个结点的孩子和双亲。结合上述完全二叉树的结点来看，如果我们将二叉树每个结点的编号放入了一个数组中

typedef Elemtype sqBinTree[MaxSize]

        那么对于编号为i的结点，他的双亲结点的编号就是【i/2】，如果他有左孩子，他的左孩子的结点编号就是【2*i】，如果他有右孩子，他的右孩子的结点编号就是【2*i+1】。

总之呢，他虽然可以快速查找双亲结点和孩子结点，但是他由于浪费大量空间，并且这也导致了插入删除等操作会比较麻烦，正常不用。

2.2 链式存储结构

       为了节省空间，我们想到用链式存储结构保存树的结点，这对于已经学过链表、栈等数据结构的我们来说并不陌生，他之中包含所保存的数据和指针域，其中对于二叉树，他的指针域就比较特殊了，包含两个指向树节点的指针，一个指向左孩子结点，另一个指向右孩子结点。

typedef struct node
{
    Elemtype data;
    struct node* lchild;
    struct node* rchild;
}BTNode;

 优势不仅在于可以节省空间，而且可以快速找到孩子节点

缺陷在于很难找到双亲结点，比较麻烦

三、基础功能及代码实现

3.1 构造二叉树

构造二叉树之前先说两个结论

（1）任何n个结点的二叉树都可以由他的中序序列和先序序列唯一地确定

（2）任何n个结点的二叉树都可以由他的中序序列和后序序列唯一地确定

用这两个结论，我们很容易用两种方法构造出同一个二叉树

两种思路操作方法类似，我们就第一种思路展开说说：
 

由先序序列和中序序列构造二叉树：先序序列提供了二叉树的根节点的信息（任何一棵二叉树的先序序列的第一个节点为根节点），而中序序列提供了由根节点将整个序列分为左、右子树的信息。

  • 确定树的根节点：先序遍历的第一个节点
  • 求解树的子树：找出根节点在中序遍历中的位置，根左边的是左子树，右边的是右子树。
  • 递归求解树：将左子树和右子树看成一棵二叉树，重复上面步骤

 如图，说说分析步骤

1 根据先序可以知道根节点是A，此时用中序序列发现A的位置，此时我们得到结论：以A为根节点的左子树由DGB组成，右子树由ECF组成

2 将DGB作为一个独立的子树，在先序中继续遍历三个结点，顺序为BDG，由于先序序列的第一个结点肯定是根节点，所以此处B为根节点，此时找到DGB（中序），就可以发现DG肯定位于B的左子树上

3 在B的左子树上，先序序列为DG，中序序列为DG，可以由先序序列找到D是根节点，G可以在中序序列是在D后面，由此判断为右孩子

4对于A的右子树结点ECF，与上述步骤类似

个人认为，最重要的落脚在于递归，根据根节点的位置关系一步一步找到左子树，右子树，左子树和右子树又是独立的子树，所以他们也有各自的根节点和左右孩子，由此可以一步一步深入。

先上代码：

//构造二叉树1
//任何n个结点的二叉树都可以由他的中序序列和先序序列唯一地确定
//先序序列的第一个值一定是根节点
/*
*
* 返回值：根节点指针
* 参数：pre，先序序列，mid：中序序列，n：二叉树节点数目
 */
BTNode* create_tree_method1(Elemtype* pre, Elemtype* mid, int n)
{
	int len = 0;
	Elemtype* ptr = NULL;//用于寻找mid中保存根节点的坐标
	if (n <= 0)
		return NULL;
	BTNode* tree = (BTNode*)malloc(sizeof(BTNode));
	tree->data = *pre;//确认根节点
	//测试printf("%c\n", tree->data);
	for (ptr = mid; ptr < mid + n; ptr++,len++)
	{
		if (*ptr == *pre)
		{
			break;// 找到根节点了
		}
	}
	tree->lchild = create_tree_method1(pre + 1, mid, len);
	tree->rchild = create_tree_method1(pre + len + 1, ptr + 1, n - len - 1);
	return tree;
}

对于第二种思路，就直接上代码了，大家可以尝试先写一下

//构造二叉树2
//任何n个结点的二叉树都可以由他的中序序列和后序序列唯一地确定
//后序序列的最后一个值一定是根节点
/*
*
* 返回值：根节点指针
* 参数：post，后序序列，mid：中序序列，n：二叉树节点数目
 */
BTNode* create_tree_method2(Elemtype* post, Elemtype* mid, int n)
{
	if (n <= 0)
		return NULL;
	int len = 0;
	Elemtype dat = *(post + n - 1);//后序序列的最后一个值一定是根节点
	BTNode* b = (BTNode*)malloc(sizeof(BTNode));
	b->data = dat;
	Elemtype* ptr;
	for (ptr = mid; ptr < mid + n; ptr++,len++)
	{
		if (*ptr == dat)//查找根节点，从而确定左子树的长度
			break;
	}
	b->lchild = create_tree_method2(post, mid, len);//构造左子树
	b->rchild = create_tree_method2(post + len, ptr + 1, n - len - 1);// 构造右子树
	return b;
}

3.2 销毁二叉树

        简单简单，对于每个二叉树（我可没说是你传入参数为根节点的二叉树，而是每一个只有根节点、可能没有左节点、可能没有右节点的二叉树，唯独那个空二叉树我觉得可以不去销毁啊，毕竟也毁不掉啊）

        那我们的思路就是下面的代码

/*
* 销毁二叉树
* 传入参数：二叉树根节点的地址
*/
void destroy_tree(BTNode** tree)
{
	if (*tree != NULL)
	{
		destroy_tree(&(*tree)->lchild);//回收左子树
		destroy_tree(&(*tree)->rchild);//回收右子树
		free(*tree);//回收根节点，一定要最后回收根节点，否则就找不到左右了
		(*tree)->lchild = NULL;
		(*tree)->rchild = NULL;
	}
}

3.3 输出二叉树

        用括号表示法输出二叉树，其实步骤很简单，就是先输出根节点数据，然后输出一个括号，输出左孩子结点数据，如果有右孩子，就输出右孩子节点数据。

        但是每一个左孩子又是某个节点的双亲结点，于是我们不能简简单单的只把孩子看作孩子，可能在下一层，他就当爹了（也就是根节点），于是我们避免不了使用迭代，但其实也简单直接把他当作根节点传入函数就可以。

/*
* 输出二叉树，括号表述法输出
* 无返回值
* 参数：根节点指针
*/
void display_tree(BTNode* tree)
{
	if (tree != NULL)
	{
		fprintf(stdout,"%c", tree->data);//只输出根节点
		if (tree->lchild != NULL || tree->rchild != NULL)
		{
			//此时已经到了下一层，一定要加左括号 
			fprintf(stdout, "(");
			//其他的交给左子树，左子树此时也是一个根节点（相对的）
			display_tree(tree->lchild);
			if (tree->rchild != NULL)
				fprintf(stdout, ",");
			display_tree(tree->rchild);
			fprintf(stdout, ")");
		}
	}
}

3.4 二叉树节点数和深度

求节点数，也就是将左孩子结点和右孩子结点树都加起来再加1（别忘了根节点）

递归一定要有一个出去的机会，也就是当我们递归到了空二叉树，那空二叉树的节点数也就是0咯，这个一定别忘！

/*
* 功能：求二叉树的节点数
* 传入根节点，返回节点数
*/
int getNum_tree(BTNode* tree)
{
	//如果是叶子节点的孩子节点，那么就返回节点数目为0
	if (tree == NULL)
		return 0;
	return getNum_tree(tree->lchild) + getNum_tree(tree->rchild) + 1;
}

求深度，也就是看左孩子深度和右孩子深度哪个更高，再加上我们自己的根节点的这一层，再加一个1嘛，同样的，别忘了递归出去的条件

/*
* 功能：求二叉树的深度
* 传入根节点，返回深度
*/
int getHeight_tree(BTNode* tree)
{
	//如果已经到了树的树叶节点的孩子节点，可以认为那个子树的深度为0 
	if (tree == NULL)
		return 0;
	int num_lchild = getHeight_tree(tree->lchild);
	int num_rchild = getHeight_tree(tree->rchild);
	return (num_lchild > num_rchild) ? (num_lchild + 1) :(num_rchild + 1);
}

3.5 二叉树最左的结点和最右的结点

这个交给你们写啦，我放一下参考代码

/*
* 返回最左边的那个节点
* 参数：二叉树根节点
*/
static BTNode* getMostLeftNode_tree(BTNode* tree)
{
	if (tree->lchild == NULL)//如果左子树是空，说明根节点就是最左节点
		return tree;
	else
		return getMostLeftNode_tree(tree->lchild);//否则就去左子树找，就是把左孩子节点当作根节点
}
/*
* 返回最右边的那个节点
* 参数：二叉树根节点
*/
static BTNode* getMostRightNode_tree(BTNode* tree)
{
	if (tree->rchild == NULL)//如果左子树是空，说明根节点就是最左节点
		return tree;
	else
		return getMostRightNode_tree(tree->rchild);//否则就去左子树找，就是把左孩子节点当作根节点
}

3.6 查找结点

查找结点需要分析一下步骤

1 先从根节点开始找，如果数据对了，返回；如果数据不对，就把这个数据交给左子树

2 左子树先从根节点开始，类似1的步骤

3 此时如果一直这么找肯定不行，需要一个递归的返回条件，很简单，类似之前的，如果到了空二叉树还没有找到，那么直接返回NULL，告知没有，但是这个返回的NULL并不是最后的结果，而是返回给他的双亲结点看的

4 当他的双亲结点看到了NULL，也就明白了左子树没有他想要的数据，开始向右子树查找

5 右子树重复之前的寻找步骤，因为他此时也是一个二叉树的根节点，他将结果返回给他的双亲结点

6 如果返回不是NULL，那么说明找到了最终结果，可以一路返回，如果还是NULL，那也没有办法（因为此时已经遍历过左子树和右子树了）只能返回NULL表示并没有发现要查的数据。

我们上代码

/*
* 功能：查找节点
* 参数:tree:根节点指针 x：要查找的数据
* 返回值：查找结点对象的指针
*/
BTNode* findNode_tree(BTNode* tree, Elemtype x)
{
	BTNode* p;
	if (tree == NULL)
	{
		return NULL;//根节点是空节点表示该子树不存在所要查找的节点
	}
	else if (tree->data == x)
	{
		return tree;//如果根节点满足条件，返回根节点
	}
	else
	{
		p = findNode_tree(tree->lchild, x);
		if (p != NULL)
		{
			return p;//如果根节点左孩子节点作为根节点的子树有满足条件的节点，返回
		}
		else
			return findNode_tree(tree->rchild, x);//否则肯定在右孩子节点
	}
}

四 写在最后

        个人以为，二叉树最重要的是知道如何递归的这个过程，最重要的思想是把每一个结点都看作一个二叉树的根节点，而不能把二叉树只看成是一个二叉树。

        我本人使用的是VS2019写下的这些代码，如果当你遇到问题，要积极使用调试，观察他是如何递归，从一个函数到一个函数，从一个树到另一个树，这些都很关键

        两个方法我大力推荐

        1、可通过调试----窗口----调用堆栈或者Ctrl+Alt+c来打开调用堆栈的窗口

        用这个方法可以观察到函数栈帧，可以看出如何一步一步调用子树，帮助理解

        2、调试--快速监视 可以进行对于变量的监视

        这个对于我们解决此类问题来说也很好用，大家也可以多用用

还有其他的调试功能比如看内存、反汇编等等都十分好用，会了调试，妈妈再也不担心我找不到bug啦

五 完整代码

/*
 *title： 二叉树基本函数实现
 *author： 且听风铃
 *data： 2023-4-26
 *
 */
#include <stdio.h>
#include <stdlib.h>

typedef char Elemtype;//先假设输入值是char

typedef struct node
{
	Elemtype data;
	struct node* lchild;
	struct node* rchild;
}BTNode;


BTNode* init_tree(Elemtype x); //初始化二叉树

BTNode* create_tree_method1(Elemtype* pre, Elemtype* mid, int n);

void display_tree(BTNode* tree);
int getNum_tree(BTNode* tree);
int getHeight_tree(BTNode* tree);
static BTNode* getMostLeftNode_tree(BTNode* tree);
static BTNode* getMostRightNode_tree(BTNode* tree);
BTNode* findNode_tree(BTNode* tree, Elemtype x);
void destroy_tree(BTNode** tree);
// 初始化二叉树，仅仅创建树根节点
/*
* 返回值：根节点指针
* 参  数：x，根节点数据
 */
BTNode* init_tree(Elemtype x)
{
	BTNode* tree = (BTNode*)malloc(sizeof(BTNode));
	tree->data = x;
	tree->lchild = NULL;
	tree->rchild = NULL;
	return tree;
}

//构造二叉树1
//任何n个结点的二叉树都可以由他的中序序列和先序序列唯一地确定
//先序序列的第一个值一定是根节点
/*
*
* 返回值：根节点指针
* 参数：pre，先序序列，mid：中序序列，n：二叉树节点数目
 */
BTNode* create_tree_method1(Elemtype* pre, Elemtype* mid, int n)
{
	int len = 0;
	Elemtype* ptr = NULL;//用于寻找mid中保存根节点的坐标
	if (n <= 0)
		return NULL;
	BTNode* tree = (BTNode*)malloc(sizeof(BTNode));
	tree->data = *pre;//确认根节点
	//测试printf("%c\n", tree->data);
	for (ptr = mid; ptr < mid + n; ptr++,len++)
	{
		if (*ptr == *pre)
		{
			break;// 找到根节点了
		}
	}
	tree->lchild = create_tree_method1(pre + 1, mid, len);
	tree->rchild = create_tree_method1(pre + len + 1, ptr + 1, n - len - 1);
	return tree;
}
//构造二叉树2
//任何n个结点的二叉树都可以由他的中序序列和后序序列唯一地确定
//后序序列的最后一个值一定是根节点
/*
*
* 返回值：根节点指针
* 参数：post，后序序列，mid：中序序列，n：二叉树节点数目
 */
BTNode* create_tree_method2(Elemtype* post, Elemtype* mid, int n)
{
	if (n <= 0)
		return NULL;
	int len = 0;
	Elemtype dat = *(post + n - 1);//后序序列的最后一个值一定是根节点
	BTNode* b = (BTNode*)malloc(sizeof(BTNode));
	b->data = dat;
	Elemtype* ptr;
	for (ptr = mid; ptr < mid + n; ptr++,len++)
	{
		if (*ptr == dat)//查找根节点，从而确定左子树的长度
			break;
	}
	b->lchild = create_tree_method2(post, mid, len);//构造左子树
	b->rchild = create_tree_method2(post + len, ptr + 1, n - len - 1);// 构造右子树
	return b;
}

/*
* 输出二叉树，括号表述法输出
* 无返回值
* 参数：根节点指针
*/
void display_tree(BTNode* tree)
{
	if (tree != NULL)
	{
		fprintf(stdout,"%c", tree->data);//只输出根节点
		if (tree->lchild != NULL || tree->rchild != NULL)
		{
			//此时已经到了下一层，一定要加左括号 
			fprintf(stdout, "(");
			//其他的交给左子树，左子树此时也是一个根节点（相对的）
			display_tree(tree->lchild);
			if (tree->rchild != NULL)
				fprintf(stdout, ",");
			display_tree(tree->rchild);
			fprintf(stdout, ")");
		}
	}
}
/*
* 功能：求二叉树的节点数
* 传入根节点，返回节点数
*/
int getNum_tree(BTNode* tree)
{
	//如果是叶子节点的孩子节点，那么就返回节点数目为0
	if (tree == NULL)
		return 0;
	return getNum_tree(tree->lchild) + getNum_tree(tree->rchild) + 1;
}
/*
* 功能：求二叉树的深度
* 传入根节点，返回深度
*/
int getHeight_tree(BTNode* tree)
{
	//如果已经到了树的树叶节点的孩子节点，可以认为那个子树的深度为0 
	if (tree == NULL)
		return 0;
	int num_lchild = getHeight_tree(tree->lchild);
	int num_rchild = getHeight_tree(tree->rchild);
	return (num_lchild > num_rchild) ? (num_lchild + 1) :(num_rchild + 1);
}
/*
* 返回最左边的那个节点
* 参数：二叉树根节点
*/
static BTNode* getMostLeftNode_tree(BTNode* tree)
{
	if (tree->lchild == NULL)//如果左子树是空，说明根节点就是最左节点
		return tree;
	else
		return getMostLeftNode_tree(tree->lchild);//否则就去左子树找，就是把左孩子节点当作根节点
}
/*
* 返回最右边的那个节点
* 参数：二叉树根节点
*/
static BTNode* getMostRightNode_tree(BTNode* tree)
{
	if (tree->rchild == NULL)//如果左子树是空，说明根节点就是最左节点
		return tree;
	else
		return getMostRightNode_tree(tree->rchild);//否则就去左子树找，就是把左孩子节点当作根节点
}

/*
* 功能：查找节点
* 参数:tree:根节点指针 x：要查找的数据
* 返回值：查找结点对象的指针
*/
BTNode* findNode_tree(BTNode* tree, Elemtype x)
{
	BTNode* p;
	if (tree == NULL)
	{
		return NULL;//根节点是空节点表示该子树不存在所要查找的节点
	}
	else if (tree->data == x)
	{
		return tree;//如果根节点满足条件，返回根节点
	}
	else
	{
		p = findNode_tree(tree->lchild, x);
		if (p != NULL)
		{
			return p;//如果根节点左孩子节点作为根节点的子树有满足条件的节点，返回
		}
		else
			return findNode_tree(tree->rchild, x);//否则肯定在右孩子节点
	}
}
/*
* 销毁二叉树
* 传入参数：二叉树根节点的地址
*/
void destroy_tree(BTNode** tree)
{
	if (*tree != NULL)
	{
		destroy_tree(&(*tree)->lchild);//回收左子树
		destroy_tree(&(*tree)->rchild);//回收右子树
		free(*tree);//回收根节点，一定要最后回收根节点，否则就找不到左右了
		(*tree)->lchild = NULL;
		(*tree)->rchild = NULL;
	}
}
void test()
{
	char str1[] = "ABDGCEF";//先序序列
	char str2[] = "DGBAECF";//中序序列
	char str3[] = "GDBEFCA";//后序序列
	BTNode* test = create_tree_method1(str1,str2,7);//先序/中序构造树
	if (test == NULL)
	{
		fprintf(stderr, "create error ...");
		exit(1);
	}
	BTNode* test2 = create_tree_method2(str3, str2, 7);//中序/后续构造树 
	if (test2 == NULL)
	{
		fprintf(stderr, "create error ...");
		exit(1);
	}
	display_tree(test);
	printf("\n==========================\n");
	display_tree(test2);
	fprintf(stdout, "\n二叉树节点个数是%d\n", getNum_tree(test));
	fprintf(stdout, "二叉树深度是%d\n", getHeight_tree(test));

	//测试查找节点
	BTNode* tmp = findNode_tree(test, 'D');
	if (tmp == NULL)
		fprintf(stdout, "未找到");
	else
		fprintf(stdout, "查找到的节点值为%c\n", tmp->data);

	destroy_tree(&test);
	destroy_tree(&test2);
	//测试是否销毁完全
    tmp = findNode_tree(test, 'A');
	if (tmp == NULL)
		fprintf(stdout, "未找到");
	else
		fprintf(stdout, "查找到的节点值为%c\n", tmp->data);

}

int main()
{
	test();
	return 0;
}

听风逝夜al
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Python学习-二叉树-递归】【剑指offer】之重建二叉树
12-21
【Python学习-二叉树-递归】【剑指offer】之重建二叉树题目基础知识例子思路分析递归代码 题目 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字...
【数据结构-二叉树】递归框架&数据结构搜索基础入门
少年初心的博客
12-20 376
【数据结构-二叉树】框架以及数据结构搜索基础入门 结合1.框架 + 2.第三章数据机构基础的搜索。
基于递归理解二叉树
pu_jun_xuan的博客
03-04 206
文章目录前言二叉树的重要性快速排序的逻辑归并排序的逻辑递归算法的秘诀226.翻转二叉树（简单）114.二叉树展开为链表（中等）116.填充每个节点的下一个右侧节点指针（中等）总结 前言 二叉树是算法的基础，很多经典算法(回溯算法、动态规划、分治算法)其实都是树的问题，而树的问题就永远逃不开树的递归遍历框架这几行破代码： /* 二叉树遍历框架 */ void traverse(TreeNode root) { // 前序遍历 traverse(root.left) // 中序遍历
【算法和数据结构】二叉树遍历（递归和非递归）
weixin_38213410的博客
03-20 292
二叉树的前中后序列遍历，递归调用自身的方式写出来的代码非常简洁，一目了然。 二叉树这种结构，个人认为天然的就是递归思想的载体。数学中的分形理论，有着类似的魅力。 递归思想很多大牛都有自己的解释，不再去做过多的解读，简单说起来，就是对于一个复杂的问题，将其分解成若干个简单的问题，对这若干个简单问题，规定相同的方法加以解决，并对问题的最终解决条件加以确立，避免无限的递归调用。 递归和循环的不同...
java二叉树中序遍历非递归，值得一看
m0_57286518的博客
07-11 66
高频问题 1.上一家公司，你为什么会离职？ 公司很好，但是公司调整了业务，接下来的发展路线和自己的目标不一致，所以要换工作 工作太清闲，学不到知识，我不怕累，就是想多锻炼自己，想找具有挑战力工作 公司的管理制度不也是很完善，没有晋升机会，我比较想进步，找一个更好的平台 我想去优秀的公司，让自己变得更好 2.为什么来我们这里？ 对原单位充满感恩，这是我人生中非常重要的经历，我认同原单位领导和文化 两份工作的本质是一致的，行业和工作性质都有紧密联系 选择一份新的工作不代表背叛过去，发扬原公司魅力，同时为了
数据结构-二叉树递归-非递归实现
04-26
数据结构实验二叉树用递归实现先序遍历、中序遍历和后序遍历，用几种不同非递归方法实现了中序遍历，代码附有详细注释
qingq0825#Javabook-Interview#算法-二叉树-递归-二叉树反转1
07-25
原二叉树：反转后的二叉树：TreeNode temp = root.left;欢迎光临我的博客，发现更多技术资源~
leetcode 二叉树-1
02-09
关于 leetcode 二叉树的算法系列-1
中序遍历二叉树-java版本
04-26
在这段代码中，Node类定义了二叉树的节点，BinaryTree类包含一个指向根节点的指针和inOrder方法，用于递归地进行中序遍历。printInOrder方法调用inOrder方法并打印出遍历的结果。 在Main类中，我们创建了一个示例...
数据结构（python）之小杨笔记一
m0_74811962的博客
05-10 353
数据结构：数据结构是计算机科学中研究数据组织、管理和存储方式的一门重要领域。（5.）树：一种非线性的数据结构，由节点和边组成，每个节点最多有一个夫节点和多个子节点。（2.）链表：由一系列节点组成的数据结构，每个结构包含数据和指向下一个节点的指针。（3.）图的算法：用于解决图结构中的各种问题的算法，如最短路径，最小生成树。的数据结构，只能在队列的前端进行删除操作，在队列的后端进行插入操作。（6.）图：一种包含节点和边的数据结构，用于表示对象之间的关系。（1.）堆：一种特殊的树形数据结构，用于实现。
Go解析的数据类型可能含有不同数据结构的处理方式
最新发布
不主动，不拒绝，不负责
05-14 176
最近做一个需求，各种业务消息都会往我的消息队列中写各种类型的数据，服务端需要接受各种不同的参数然后转换为本地数据结构，Go语言不确定上游传过来的数值是什么类型，然后又下面四种解决方案。
【数据结构】线性表----链表详解
Skrrapper的博客
05-14 993
前面我们介绍的顺序表，在逻辑结构和物理结构上都是线性、连续的关系，那么我们在篇尾的时候也提到了是否有一种顺序表，无需在物理结构上连续，从而达到更好存取的目的呢？今天它来了。链表（LinkList）属于线性表的一种，以下是百度百科关于链表的定义：在结构上链表数据域指针域。我们可以类比成火车，火车每一节车厢实际上是独立的，也就好比数据域，存储着各自的数据；但每一节车厢之间都会由一条链连接在一起，从而形成整个火车，链也就好比指针域，起到连接该车厢和指向下一车厢的作用。而实际上这样的存储结构也就是为什么。
【数据结构】链表
小林的博客
05-12 340
​ 链表不同于顺序表，顺序表底层采用数组作为存储容器，需要分配一块连续且完整的内存空间进行使用，而链表不需要，它通过一个指针来连接各个分散的结点，形成了一个链状的结构，每个结点存放一个元素，以及一个指向下一个结点的指针，通过这样一个一个相连，最后形成了链表。​ 它不需要申请连续的空间，只需要按顺序连接即可，虽然物理上可能不想邻，但在逻辑上依然是每个元素相邻存放的，这种结构就叫链表（单链表）
java版数据结构：二叉树
2303_80025768的博客
05-10 698
二叉树的基本应用
数据结构（四）————二叉树和堆（中）
2301_80176226的博客
05-10 1016
CSDN这篇博客介绍了二叉树中的基本概念和存储结构，接下来我们将运用这些结构来实现二叉树这篇博客详细介绍了堆结构的实现和实践中的应用，希望对大家有所收获。
数据结构（十三）----几种特殊的树
weixin_69884785的博客
05-11 802
数据结构----几种特殊的树 一.二叉排序树 1.二叉排序树的查找 2.二叉排序树的插入 3.二叉排序树的构造 4.二叉树的删除 5.二叉排序树的查找效率 二.平衡二叉树 1.平衡二叉树的插入 2.平衡二叉树的查找效率 3.平衡二叉树的删除 三.红黑树 1.红黑树的概念 2.红黑树的查找 3.红黑树的插入 4.红黑树的删除 四.B树 1.B树的定义 2.B树的高度 3.B树的插入 4.B树的删除 五.B+树 1.B+树的查找 2.B+树与B树的对比
数据结构之二叉树
zhyhgx的博客
05-14 831
文章主要讲二叉树的创建、遍历、以及一些简单操作
数据结构之图——探索图论的奥秘
纪大侠博客
05-11 945
以上简单介绍了，图论知识。对于图论中用的比较多最短路和k短路用Java实现了。实际图论是比较难的问题，这边只是做了简单的介绍，抛砖引玉。
二叉树运算和非递归遍历
11-19
二叉树是一种重要的数据结构，它的遍历方式有递归和非递归两种。下面将分别介绍二叉树的基本运算和非递归遍历算法。 1. 二叉树的基本运算 建立二叉树的三叉链式存储结构，可以通过以下步骤完成二叉树的基本运算： -...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

听风逝夜al

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值