二叉树的一些学习

最新推荐文章于 2024-10-16 19:08:56 发布
最新推荐文章于 2024-10-16 19:08:56 发布
阅读量420 收藏 5
点赞数 6
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Breezekyu/article/details/138999064
版权

         最近为了找实习，在学数据结构，都没怎么刷面试题了，记录一下这段时间以来学过的代码吧，有需要的可以参考一下。有什么不对的地方，望指正，也可以在评论区一起互动起来！！！

代码是参考看了一些厉害的博主才完善的，要是有侵权的，请联系我及时删除！！

        二叉树（Binary Tree）是一种常见的树状数据结构，它由节点组成，每个节点最多有两个子节点：一个左子节点和一个右子节点。这些子节点也可以是空的。

以下是二叉树的一些关键特点：

  1. 根节点：二叉树的顶部节点称为根节点。
  2. 父节点、子节点：每个节点都可以有零个、一个或两个子节点。与节点相连的较高节点称为父节点，而与其相连的较低节点称为子节点。
  3. 叶子节点：没有子节点的节点称为叶子节点。
  4. 深度：从根节点到某个节点的唯一路径上的边数。
  5. 高度：从该节点到叶子节点的最长路径上的边数。
  6. 层次：树中的每一层都有一组节点，根节点在第0层，其子节点在第1层，依此类推。
  7. 遍历：二叉树的遍历是按照某种顺序访问树中所有节点的过程。常见的遍历方式包括前序遍历、中序遍历和后序遍历。

二叉树有许多类型，例如平衡二叉树、二叉搜索树、完全二叉树等，每种类型都有不同的特点和应用场景。

这里我主要以二叉搜索树为主。

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <stdlib.h>
 
/*节点*/
typedef struct inode{
	int nValue;
	struct inode *left;
	struct inode *right;
}stTreeNode;
 
 
/************************************************
* 前序遍历
* 定义：先遍历根节点，然后左，再右
************************************************/
void tree_preScanLoop(stTreeNode *pRoot)
{
	if(pRoot == NULL)
		return;
	
	printf("nValue = %d\n",pRoot->nValue);
	tree_preScanLoop(pRoot->left);
	tree_preScanLoop(pRoot->right);
	return;
}
 
/************************************************
* 中序遍历
* 定义：先遍历左节点，然后根，再右
************************************************/
void tree_midScanLoop(stTreeNode *pRoot)
{
	if(pRoot == NULL)
		return;
 
	tree_midScanLoop(pRoot->left);
	printf("nValue=%d\n",pRoot->nValue);
	tree_midScanLoop(pRoot->right);
 
	return;
}
 
/************************************************
* 后序遍历
* 定义：先遍历左节点，然后右，再根
************************************************/
void tree_PostScanLoop(stTreeNode *pRoot)
{
	if(pRoot == NULL)
		return;
 
	tree_PostScanLoop(pRoot->left);
	tree_PostScanLoop(pRoot->right);
	printf("nValue=%d\n",pRoot->nValue);
 
	return;
}
 
/************************************************
* 创建节点
* 定义：先遍历左节点，然后右，再根
************************************************/
stTreeNode *tree_CreateInode(void)
{
	stTreeNode *pinode = NULL;
	pinode = (stTreeNode*)malloc(sizeof(stTreeNode));
	if(pinode!=NULL)
	{
		memset(pinode,0,sizeof(stTreeNode));
		return pinode;
	}
	
	return NULL;
}
 
 
/************************************************
* 销毁单个节点
* 定义：
************************************************/
void tree_destoryInode(stTreeNode *pinode)
{
	if(pinode!=NULL)
	{
		free(pinode);
		pinode	= NULL;
	}
}
 
 
/************************************************
* 获取树的深度
* 定义：深度即为数的层数
* 一棵树若只有一个节点那么其深度为0
************************************************/
int tree_getDeeps(stTreeNode *pRoot)
{
	int ndeep = 0;
	int nleftDeep = 0;
	int nrightDeep = 0;
 
	if(pRoot!=NULL)
	{
		nleftDeep = tree_getDeeps(pRoot->left);
		nrightDeep = tree_getDeeps(pRoot->right);
		ndeep = (nleftDeep > nrightDeep)?(nleftDeep+1):(nrightDeep+1);
	}
 
	return ndeep;
}
 
/************************************************
* 获取叶子节点数
* 定义：叶子无左右子节点的节点
************************************************/
int tree_getLeafCnts(stTreeNode *pRoot)
{
	static int nCounts = 0;
 
	if(pRoot!=NULL)
	{
		if(pRoot->left==NULL && pRoot->right == NULL){
			nCounts++;
		}
		tree_getLeafCnts(pRoot->left);
		tree_getLeafCnts(pRoot->right);
	}

	return nCounts;
}
 
 
/************************************************
* 查找节点
* 定义：查找规则，如果比根节点小则在左字数查找
************************************************/
stTreeNode *tree_searchInode(stTreeNode *pRoot,int nValue)
{	
	if(pRoot==NULL)
		return NULL;
	
	if(nValue == pRoot->nValue)
		return pRoot;
	else if(pRoot->nValue > nValue)
		return tree_searchInode(pRoot->left,nValue);
	else if(pRoot->nValue < nValue)
		return tree_searchInode(pRoot->right,nValue);
	else
		return NULL;

}

/************************************************
* 查找大节点
* 定义：查找规则，如果比根节点小则在左字数查找
************************************************/
stTreeNode *tree_findMax(stTreeNode *pRoot)
{
    // 方法一
	// if(pRoot){
	// 	/*往右找到最底，最底的最大*/
	// 	for(;pRoot->right!=NULL;pRoot = pRoot->right);
	// 	return pRoot;
	// }
	// return NULL;
    
    // 方法二
	if(pRoot==NULL){
		return NULL;
	}else if(pRoot->right==NULL){
		return pRoot;
	}else{
		return tree_findMax(pRoot->right);
	}
}
 
/************************************************
* 查找小节点
* 定义：查找规则，如果比根节点小则在左字数查找
************************************************/
stTreeNode* tree_findMin(stTreeNode *pRoot)
{
	// 方法一
	// if(pRoot){
	// 	/*往左找到最底，最底的最小*/
	// 	for(;pRoot->left!=NULL;pRoot=pRoot->left);
	// 	return pRoot;
	// }
	// return NULL;

	// 方法二
	if (pRoot == NULL)
        return NULL;
    if (pRoot->left == NULL)    // 结点没有左子树，即为最左叶子结点
        return pRoot;
    else        // 有左子树，则继续在左子树中查找
        return tree_findMin(pRoot->left);
}
 

// 删除最小结点
stTreeNode* DeleteMin(stTreeNode *BiTree)
{
    if (BiTree->left == NULL){
		stTreeNode *temp = BiTree->right;
        free(BiTree);
        return temp;
	}
    else {
        //这里是多次重复赋值，只有最后一步才是将右子树赋值给父子树的左节点
        BiTree->left = DeleteMin(BiTree->left); 
        return BiTree;
    }
}

// 删除最大结点
stTreeNode* DeleteMax(stTreeNode *BiTree)
{
    if (BiTree->right == NULL){
		stTreeNode *temp = BiTree->left;
        free(BiTree);
        return temp;
	}
    else {
        BiTree->right = DeleteMax(BiTree->right); //这里是多次重复赋值，只有最后一步才是将左子树赋值给父子树的右节点
        return BiTree;
    }
}

// 删除指定的节点的递归实现
stTreeNode *delNode(stTreeNode *pRoot,int nDeleteValue){

    // 先找到要删除的结点在二叉树中的位置
    if (pRoot == NULL) {    // 没有找到元素
        perror("can`t find element\n");
        return NULL;
    }
        
    if (pRoot->nValue < nDeleteValue) {        // 元素值大于结点元素值，则去结点右子树寻找
        pRoot->right = delNode(pRoot->right, nDeleteValue);
        return pRoot;
    }
    else if (pRoot->nValue > nDeleteValue) {    // 元素值小于结点元素值，则去结点左子树寻找
        pRoot->left = delNode(pRoot->left, nDeleteValue);
        return pRoot;
    }
	// 找到结点
    else if(pRoot->nValue == nDeleteValue){
		//找到要删除的节点
		if(pRoot->left == NULL && pRoot->right == NULL)//叶节点
		{
			tree_destoryInode(pRoot);
			return NULL;
		}else if(pRoot->left == NULL){//只有右孩子
			stTreeNode * temp = pRoot->right;
			tree_destoryInode(pRoot);
			return temp;
		}else if(pRoot->right == NULL){//只有左孩子
			stTreeNode* temp = pRoot->left;
			tree_destoryInode(pRoot);
			return temp;
		}else{ //左右都有
			//找左子树的最大节点		
			stTreeNode * tempNode = pRoot->right;
			stTreeNode *minNode = tree_findMin(tempNode);
			minNode->left = pRoot->left;
			tree_destoryInode(pRoot);
			return tempNode;
		}
    }
}


/************************************************
* 删除指定的节点（循环实现）
************************************************/
void tree_deleteInode(stTreeNode *pRoot,int nDeleteValue)
{	
	stTreeNode *pRetNode = NULL;
	stTreeNode *pNode = pRoot;
	stTreeNode *parentNode = pRoot;
 
	if(pNode == NULL) // 没有找到元素
		return;
 
	while(pNode)
	{
		if(pNode->nValue == nDeleteValue)
		{
			if(pNode->left == NULL && pNode->right == NULL)/*删除叶子节点*/
			{
				if(pNode == pRoot) //要是是根节点
				{
					tree_destoryInode(pNode);
				}
				else if(parentNode->left == pNode) //是左边的节点
				{
					parentNode->left = NULL;
					tree_destoryInode(pNode);
				}
				else if(parentNode->right == pNode) //是右边的节点
				{
					parentNode->right = NULL;
					tree_destoryInode(pNode);
				}
			}
			else if(pNode->left == NULL)/*左节点空，表示右节点不为空*/
			{
				if(parentNode->left == pNode)  //是左边的节点
				{
					parentNode->left = pNode->right;
					tree_destoryInode(pNode);
				}
				else if(parentNode->right == pNode)  //是右边的节点
				{
					parentNode->right = pNode->right;
					tree_destoryInode(pNode);
				}
			}
			else if(pNode->right == NULL)/*右节点空，表示左节点不为空*/
			{
				if(parentNode->left == pNode) //是左边的节点
				{
					parentNode->left = pNode->left;
					tree_destoryInode(pNode);
				}
				else if(parentNode->right == pNode)  //是右边的节点
				{
					parentNode->right = pNode->left;
					tree_destoryInode(pNode);
				}
			}
			else  //删除有双节点的节点
			{
				if(parentNode->left == pNode) //是左边的节点
				{
					/*找到最小的节点*/
					pRetNode = tree_findMin(pNode->right);
					/*替换内容*/
					pRetNode->left=pNode->left;
					parentNode->left = pNode->right;
				}
				else if(parentNode->right == pNode) //是右边的节点
				{
					/*找到最小的节点*/
					pRetNode = tree_findMin(pNode->right);
					/*替换内容*/
					pRetNode->left=pNode->left;
					parentNode->right=pNode->right;
				}
				tree_destoryInode(pNode);
			}
		}
		else if(nDeleteValue < pNode->nValue)/*往左*/
		{
			parentNode = pNode;
			pNode = pNode->left;
		}
		else if(nDeleteValue > pNode->nValue)/*往右*/
		{
			parentNode = pNode;
			pNode = pNode->right;
		}
 
	}
 
	return;
}

 
/************************************************
* 插入节点
* 定义：插入规则为：左<根<右
************************************************/
int tree_insertNode(stTreeNode **ppRoot,int nVal)
{
	stTreeNode * pNewInode = tree_CreateInode();
	stTreeNode *pinodeTmp = NULL;
	
	if(pNewInode==NULL){
		printf("%s tree_CreateInode failed at (%d) line\n",__FUNCTION__,__LINE__);
		return -1;
	}
	pNewInode->nValue = nVal;
	
	if(pNewInode ==NULL){
		printf("%s input paras error\n",__FUNCTION__);
		return -1;
	}
 
	/*如果是空树*/
	if(*ppRoot==NULL)
	{
		*ppRoot = pNewInode;
	}
	else
	{
		/*树根开始*/
		pinodeTmp = *ppRoot;
		
		while (pinodeTmp !=NULL)
		{
			/*插入节点小于当前节点*/
			if(pNewInode->nValue < pinodeTmp->nValue)
			{
				if(pinodeTmp->left == NULL) //左孩子节点为空，插入
				{
					pinodeTmp->left = pNewInode;
					break;
				}
				else
				{
					pinodeTmp = pinodeTmp->left;
				}
			}
			/*插入节点大于当前节点*/
			else if(pNewInode->nValue > pinodeTmp->nValue)
			{
				/*右孩子节点为空，插入*/
				if(pinodeTmp->right == NULL)
				{
					pinodeTmp->right = pNewInode;
					break;
				}
				else
				{
					/*右孩子节点非空，继续向右孩子节点找*/
					pinodeTmp = pinodeTmp->right;
				}
			}else{
				break;  //遇到相等节点时要break，不然就会卡死 获取上面的 > < 换成 <= >=
			}
		}
	}

 
	return 0;
}


/************************************************
*  删除全部节点(递归实现) 
************************************************/
void tree_destory(stTreeNode *pRoot)
{
	stTreeNode *pleft = NULL;	
	stTreeNode *pright = NULL;
 
	if(pRoot==NULL){
		return;
	}
	else
	{
		pleft	= pRoot->left;
		pright	= pRoot->right;
		tree_destoryInode(pRoot); //要放上面，不要放下面（因为是只需要释放一次pRoot节点即可）
		tree_destory(pleft);
		tree_destory(pright);
	}
	return;
}
 

// 插入一个结点(< 或 > 不会插入重复节点,<= 或 >= 则会插入重复节点)
stTreeNode * InsertNode(stTreeNode **pRoot, int n)
{
    if (*pRoot == NULL) {    //树为空，或已到达叶子结点
        // 为新结点分配内存
        stTreeNode* newNode = (stTreeNode*)malloc(sizeof(stTreeNode));
        if (newNode == NULL) {
            perror("malloc failed!\n");
            // exit(-1);
			return NULL;
        }
        newNode->nValue = n;
        newNode->left = NULL;
        newNode->right = NULL;
        *pRoot = newNode;
    }
    else if ((*pRoot)->nValue <= n) {  // 插入值大于当前结点的值，则将元素插入到结点的右子树
        (*pRoot)->right = InsertNode(&(*pRoot)->right, n);
    }
    else if ((*pRoot)->nValue >= n) {  // 插入值小于当前结点的值，则将元素插入到结点的左子树
        (*pRoot)->left = InsertNode(&(*pRoot)->left, n);
    }
    
    return *pRoot; 
}


int main()
{
	int ni = 0;
	int nRet = -1;
	int nSqe[]={35,2,6,8,10,3,44,1,32,65,7,21};
	int delNum=0;
	
	stTreeNode *pTreeRoot = NULL;
	stTreeNode *pNewTreeNode = NULL;
	stTreeNode *tempNode = NULL;
	
	for(ni= 0;ni<(sizeof(nSqe)/sizeof(int));ni++)
	{

		nRet = tree_insertNode(&pTreeRoot,nSqe[ni]);
		if(nRet<0){
			printf("%s tree_insertNode failed at (%d) line\n",__FUNCTION__,__LINE__);
			break;
		}
	}

	printf("delNum is : ");
	
	scanf("%d",&delNum);
	

	tree_preScanLoop(pTreeRoot);	
	printf("------------------------------------------------------\n");
	delNode(pTreeRoot,delNum);
	
	tree_preScanLoop(pTreeRoot);	
	printf("------------------------------------------------------\n");
 
	tree_destory(pTreeRoot);
	return 0;
}

 

        删除节点的那块得多花时间，二叉树删除节点有四种情况，其实就是要注意删除节点后，其子节点的位置调整。

        我自己写的流程图就放这了，有不懂的可以来看看。（需要结合上面的代码去分析，不然就会一脸懵逼）

        这里有很多地方我都使用了 递归 和 循环遍历 两种方式实现，把它们搞懂，是学会二叉树必不可少的。

嵌入式linux小菜鸟
关注
二叉树 Python学习
01-04
完全二叉树
平衡二叉树.zip 平衡二叉树的学习与思考
02-23
平衡二叉树的学习与思考不仅包括理解和实现平衡二叉树的结构，还包括对插入、删除等操作的理解以及平衡调整策略。理解这些算法背后的逻辑，能帮助我们在实际编程中更好地应用这些数据结构，提高程序的效率。 例如，...
二叉树的学习
m0_63783532的博客
11-11 1426
2.n = n1 + 2n2 + 1（树的结点数 = 总度数 + 1，其中度为0的结点数有n0个，度数和为0×n0；1.n = n0 + n1 + n2（树的结点数 = 度为0的结点数 + 度为1的结点数 + 度为2的结点数）分析：第一层有1个结点；总共有1+2+2^2......+2^(h-1)=(1-2^h)/(1-2)=2^h-1。又推出若完全二叉树有2k个（偶数）个结点，则必有n1=1，n0=k，n2=k-1。若完全二叉树有2k-1个（奇数）个结点，则必有n1=0，n0=k，n2=k-1。
二叉树学习笔记
Josecrystal的博客
02-12 720
概念 二叉树：一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个结点 满二叉树（完美二叉树）： 除最下面一层全为叶节点，其他层每个节点都有两个儿子 完全二叉树：对有n个结点的二叉树按从上到下，从左到右的顺序进行编号（编号为i的节点与满二叉树中编号为i节点位置相同）。如下图所示，J再满二叉树中的位置为10，K位置为11，故下列编.
线索二叉树学习总结
zxzxin的博客~
04-21 1658
目录 线索二叉树由来 线索二叉树结构 中序线索二叉树构造(带头结点) 没有设置头结点的前，中，后续二叉线索树构造 线索二叉树由来 两点由来： 空间的浪费 : 在使用二叉链表的存储结构的过程中，会存在大量的空指针域，为了充分利用这些空指针域，引申出了“线索二叉树”。对于一个有n个节点的二叉链表，每个节点有指向左右节点的2个指针域，整个二叉链表存在2n个指针域。而n...
二叉树学习参考网址
jiechuhoudeshang的博客
06-01 776
二叉树就是这么简单： https://juejin.im/post/5ab5a01d518825555c1d9a24 二叉树入门： https://www.jianshu.com/p/00b5966723c0 用C语言实现二叉树的结构和常用操作： https://blog.csdn.net/yudejiao/article/details/53366745 ...
初步学习二叉树
nulixiaoxuetu的博客
06-01 1025
在学习数组的时候相信很多人都学过，二分查找法，二分查找法的时间复杂度只有O（logn）(注：以2为地)，但是二分查找法在生产实际中很少使用。原因它要有序，且要求是数组（空间连续）。一个数组4字节，如果十亿个数字排序就要大概4G的连续空间。所以在生产中一般使用哈希表，二叉搜索树等。这两张图片相信很多人都见过，这就是现实的二叉树。
二叉树学习
weixin_54014603的博客
03-24 1372
一.了解二叉树 1.基本概念 根结点 左子树指针 右子树指针 孩子结点 父结点 兄弟结点 姊妹结点 2.空的二叉树：就结构体指针 tree=NULL 3.只有跟结点的二叉树 4.只有左子树或右子树的二叉树（完全没有另一边的 一条线的 不常用） 5.左右子树都存在 5.1.完全二叉树（结点连续） 5.2.满二叉树（左右子树都完整） e.g:1.二叉树编号一般从1开始 2.Lchild/2=parent 二.二叉树的遍历 1. eg：前序...
二叉树学习的一些个人心得
晓梦林的博客
11-22 9498
目录前言二叉树的种类满二叉树完全二叉树二叉搜索树平衡二叉搜索树二叉树的存储方式二叉树的遍历方式二叉树的代码描述总结参考文献 前言 开启算法新征程，为了让我对二叉树有新层次的理解，加油学习吧。 二叉树的种类 二叉树的两种形式：满二叉树和完全二叉树 满二叉树 只有度为0和度为2的节点的树，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 如下图： 深度：k 节点个数：2^k-1 完全二叉树 除了最底层的节点没有安排满外，其余每层节点数都达到最大值，并且最下面一层节点都集中在该层最左的若干位置。
二叉树个人学习总结
tanx的博客
02-14 409
二叉树学习总结
二叉树学习心得
lidadeboke的博客
09-17 1279
已知先序遍历为：ADCEFGHIJB，中序遍历为：CDFEGIHJAB，后序遍历该是什么？ 这个类型的题目我们首先要画出二叉树，如下图： 先序遍历算法：根做头，左右遍历； 中序遍历算法：左根右（先找到最左边，在再找根再找到右边）； 后序遍历算法：左右根（同上）。 从先序ADCEFGHIJB，中序CDFEGIHJAB得到 A为根、左树DCEFGHIJ、右树为B（这个B...
数据结构树和二叉树遍历二叉树和线索二叉树PPT学习教案.pptx
10-05
"数据结构树和二叉树遍历二叉树和线索二叉树PPT学习教案.pptx" 本资源主要讲述了数据结构树和二叉树遍历的相关知识点，包括二叉树的基本概念、二叉树遍历的六种方案、先序、中序、后序遍历算法的实现、线索二叉树的...
一个基于Java实现的二叉树学习项目 包含二叉树生成、遍历
05-20
二叉树，一个基于Java实现的二叉树学习项目。包含二叉树生成、遍历。适用人群：计算机，电子信息工程、数学等专业的大学生学习二叉树等数据结构，作为“参考资料”使用。 二叉树，一个基于Java实现的二叉树学习项目...
什么是二叉树的遍历以及学习二叉树的遍历的意义
05-20
综上所述，学习二叉树的遍历对于计算机科学和软件工程的学习与发展具有极其重要的意义。它不仅是理解树形结构的基础，也是解决实际问题的有效工具。掌握了二叉树遍历，就相当于掌握了一项强大的技能，能够在日后的...
数据结构与算法：高级数据结构与实际应用
weidl001的博客
10-16 919
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
数据结构常考基础代码题-顺序表有序插入
qq_52291558的博客
10-16 382
根据题目中的“顺序表递增有序”，我们需要定义一个顺序表结构体，用于存储元素和顺序表的相关信息。
数据结构（排序）
m0_74859128的博客
10-10 792
一、定义排序是将一组数据元素按照某个关键字的值递增或递减的次序重新排列的过程。这个关键字是数据元素中的某个数据项，通过比较关键字的大小来确定数据元素的先后顺序。二、目的便于查找例如在一个有序数组中查找某个元素，使用二分查找等算法效率更高。如果数据是无序的，可能只能进行顺序查找，时间复杂度较高。数据呈现的有序性在很多应用场景中，如成绩排名、文件按时间顺序排列等，需要数据以有序的形式展示，以便于人们理解和分析。三、分类内部排序和外部排序内部排序指待排序的数据元素全部存放在计算机内存中的排序算法。
数据结构常考基础代码题-数组倒置
最新发布
qq_52291558的博客
10-16 331
根据题目中的“将数组中的元素顺序反转”，我们需要实现一个函数Reverse，用于反转数组中从start到end的元素。// 函数用于反转数组A中从start到end的元素int temp;// 使用while循环进行元素交换，直到start和end相遇或交叉// 保存A[start]的值// 将A[end]的值赋给A[start]// 将temp（原A[start]的值）赋给A[end]start++;// 移动start指针end--;// 移动end指针。
数据结构-顺序表
m0_60633015的博客
10-13 266
静态顺序表：使用定长数组存储元素.缺点是 动态顺序表：使用动态开辟的数组存储元素.依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表: 顺序表是用一段。顺序表的指定位置插入。顺序表指定位置的删除。
树转换为二叉树的方法与二叉树学习
"这篇资源主要介绍了如何将一棵普通的树转换为二叉树的步骤，并提供了相关的二叉树学习内容，包括二叉树的定义、性质、遍历算法、线索化二叉树、树与二叉树的转换以及哈夫曼树的构建方法。" 在计算机科学中，树是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值