二叉树基础运用——学习笔记

最新推荐文章于 2024-10-26 01:57:24 发布
最新推荐文章于 2024-10-26 01:57:24 发布
阅读量262 收藏
点赞数
分类专栏： 基础算法学习 文章标签： BinaryTree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jjwwwww/article/details/81051137
版权

回想刚学二叉树的时候，被二叉树删除搞的要死要活的，后来学习了AVL树、红黑树才慢慢熟练了二叉树的基础操作。篇幅会有点长~慢慢欣赏~

我就当各位都是明白什么是树，什么叫二叉树。在这里我就不多解释了~如果这些都不清楚的话，可能需要先补充些相关知识再看会比较好。

 

一.创建结构体

struct Node {
	int key;
	int count;
	Node* parent;
	Node* left;
	Node* right;
};

二叉树结构的基本构成，数据key，父节点parent，左子节点left，右子节点right。

我擅自加了个count，由于我们做数据排序的时候，有时候会遇到相同的key值，那么这个时候传统的操作是当成重复数据直接抛掉，我个人觉得抛掉有点可惜，那么就加个count来记录插入相同数据的个数。

顺便一提，初学的时候会觉得parent好像没什么用，实际上不用parent也是可以实现二叉树的，但是有了parent一些操作会变得更加简单，例如删除操作（下面会提到）。

当然，上面的count和parent不是必须的。具体结构根据实际需要进行调整即可。

 

二.建立根节点

Node* root;

void InitRoot() {
	root = (Node*)malloc(sizeof(Node));
	root->key = 0;
	root->count = 0;
	root->parent = NULL;
	root->left = NULL;
	root->right = NULL;
}

这里就不多说，很简单。

 

三.插入数据

首先二叉树是有个规则的，就是对于树中的每个子树的根节点，左边的节点都要小于根节点，右边节点都要大于根节点。也就是有下面这个结构：

       中
      /  \
    小    大

举个例子，我们插入[7,3,5,1,9,8,2,4]时，按照上面规则来排，最终得到这么一棵树：

                7
             /      \
            3         9
         /    \      /
        1      5    8
         \    /
          2  4

有兴趣可以自己排一排练习下看看我们是不是排成一样的。

根据这个规则我们来写插入函数：

void InsertTree(Node *root, int key) {
	//首先判断根节点是否有存数据
	if (root->count == 0) {
		root->key = key;
		root->count++;
	}
	else {
		Node* node = root;//创建子节点
		Node* parent = root->parent;//子节点的父节点

		//找到子节点的父节点
		while (node != NULL) {
			parent = node;

			if (key == node->key) {//假如该节点在树中已有，count+1返回
				node->count++;
				return;
			}
			else if(key < node->key){//小于时往左节点寻找
				node = node->left;
			}
			else if (key > node->key) {//大于时向右节点寻找
				node = node->right;
			}
		}

		//给子节点赋值
		node = (Node*)malloc(sizeof(Node));
		node->key = key;
		node->count = 1;
		node->parent = parent;
		node->left = NULL;
		node->right = NULL;

		//把子节点挂到父节点上
		if (key < parent->key) {
			parent->left = node;
		}
		else {
			parent->right = node;
		}
	}
}

 

四.查找数据

查找的情况和插入很相似，同样运用了左小右大的规则，看代码！

Node* Find(Node* root, int key) {
	if (root->count != 0) {//判断根节点是否有数据
		Node* node = root;

		while (node!=NULL)
		{
			if (key == node->key) {//找到节点，直接返回
				return node;
			}
			else if(key < node->key) {//小于时，找向左节点
				node = node->left;
			}
			else if(key > node->key){//大于时，找向右节点
				node = node->right;
			}
		}
	}
	return NULL;
}

相信学会了插入，查找就难不倒你了。

 

五.删除数据

重头戏来了！删除是应该是最难的部分了，为什么难？因为删除的时候有三种情况：

1.被删除的是叶子节点，左右子节点都为空

2.被删除的节点，左右子节点有一个为空

3.被删除的节点，左右子节点都不为空

我们一个一个来分别处理。

首先，被删除的是叶子节点，我们只需要让父亲节点连接的左或右节点为空即可

         父              父
        /               /
       删       -->   NULL
     /   \
   NULL  NULL

代码如下：

if (node->left == NULL&&node->right == NULL) {
	Node* parent = node->parent;//获取父节点

	if (parent == NULL) {//判断是不是根节点
		root->key = 0;
		root->count = 0;
	}
	else {
		if (node == parent->left) {
			parent->left = NULL;
		}
		else {
			parent->right = NULL;
		}
	        free(node);//释放
	}
}

 

当被删除的节点只有一个子节点时，我们只需要把子节点替代删除节点即可：

            父                 父
          /                   /
         删        -->      子
       /   \
     NULL   子

代码如下：

if((node->left!=NULL&&node->right==NULL)||(node->left==NULL&&node->right!=NULL)){
	Node* parent = node->parent;
	Node* child = node->left == NULL ? node->right : node->left;
	child->parent = parent;

	if (parent == NULL) {//判断是不是根节点
		root = child;
	}
	else {
		if (node == parent->left) {
			parent->left = child;
		}
		else {
			parent->right = child;
		}
	        free(node);
	}
}

 

当被删除节点的两个子节点都不为空时，这时候我们需要找一个节点来替代删除节点。同时我们又需要使得节点左小右大的性质不被破坏，所以我们可以以删除结点为根节点，可以找其左子树中的最大节点或者右子树中的最小节点来替代：

           父                      父                               父
          /                       /                                /
         删         -->        左MAX              或者           右MIN
       /   \                   /   \                             /   \
  左子树   右子树       左子树-Max    右子树                  左子树    右子树-MIN

上代码：

if (node->left != NULL&&node->right != NULL) {
	Node* right_min=node->right;
        
	while (right_min->left == NULL) {//找到右子树中的最小值
		right_min = right_min->left;
	}

	int num= right_min->key;
	node->count = right_min->count;
	DeletTree(num);                //先删除右子树最小节点
	node->key = num;              //将删除节点的值进行替换
}

我选择找右子树的最小节点。

可能有人会疑问这里的DeleteTree（num），因为我们要先删除找到的右子树最小节点,再给当前节点赋值，假如先赋值再删除，就只会把当前节点删除（因为此时的key已经改变了），这样不仅没达到效果，还会引起错误。

上删除的完整代码：

void DeletTree(int key) {
	Node* node = Find(root, key); //找到需要删除的节点

	if (node == NULL) {         //判断该节点是不是存在
		return;
	}

        Node* parent=node->parent;
	if (node->left != NULL&&node->right != NULL) {  //子节点都存在时
		Node* right_min = node->right;

		while (right_min->left != NULL) {           //找到其右子树最小节点
			right_min = right_min->right; 
		}

		int num = right_min->key;
		node->count = right_min->count;
		 
		DeletTree(num);                            //删除右子树最小节点

		node->key = num;                           //将右子树最小值赋给该节点
	}
	else if(node->left==NULL&&node->right==NULL){  //当子节点都为空时
		if (parent == NULL) {                      //先判断是否为根节点
			root->key = 0;
			root->count = 0;
		}
		else {
			if (node == parent->left) {
				parent->left = NULL;
			}
			else {
				parent->right = NULL;
			}
			free(node);
		}
		
	}
	else {                                    //剩下情况是一个节点为空
		Node* child = node->left == NULL ? node->right : node->left;
		child->parent = parent;

		if (parent == NULL) {
			root = child;
		}
		else {
			if (node == parent->left) {
				parent->left = child;
			}
			else {
				parent->right = child;
			}
			free(node);
		}
	}
}

PS:由于考虑到有的同学可能递归学的比较好，再提供一份递归版的删除

Node* DeletTree2(int key, Node* node) {
	if (node != NULL) {
		if (key == node->key) {
			if (node->left != NULL&&node->right != NULL) {
				Node* right_min = node->right;

				while (right_min->left != NULL) {
					right_min = right_min->left;
				}

				node->key = right_min->key;
				node->count = right_min->key;
				right_min->parent = DeletTree2(right_min->key, right_min->parent); //注意这里，巧妙运用了parent
			}
			else {
				if (node->left == NULL&&node->right == NULL) {
					free(node);
					node = NULL;
				}
				else {
					Node* child = node->left == NULL ? node->right : node->left;
					free(node);
					node = child;
				}
			}
		}
		else if (key < node->key) {
			node->left = DeletTree2(key, node->left);
		}
		else {
			node->right = DeletTree2(key, node->right);
		}
	}

	return node;
}

使用的时候注意为 root=(DeletTree2(key,root))，防止删除的点刚好是root，此时root会改变。

大致思路和前面的是一样的，不多加注释了，有兴趣可以研究研究。

 

六.数据遍历

到了这里就很轻松了。遍历的情况分为前序遍历，中序遍历，后序遍历。具体是看我们访问节点和其两个子节点的顺序来决定。代码很简单，但是由于运用到了递归，可能在理解上会多少有些抽象，我尽量解释清楚吧。先上代码：

// N=node , L=left , R=right;
//NLR 前序遍历
//LNR 中序遍历 
//LRN 后序遍历

void NLR(Node* node) {                      //前序遍历
	if (node == NULL) {
		return;
	}

	for (int i = 0; i < node->count; i++) {
		printf("%d", node->key);
	}

	NLR(node->left);
	NLR(node->right);
}

void LNR(Node* node) {                    //中序遍历
	if (node == NULL) {
		return;
	}

	LNR(node->left);

	for (int i = 0; i < node->count; i++) {
		printf("%d", node->key);
	}

	LNR(node->right);
}

void LRN(Node* node) {                //后序遍历
	if (node == NULL) {
		return;
	}

	LRN(node->left);
	LRN(node->right);

	for (int i = 0; i < node->count; i++) {
		printf("%d", node->key);
	}
}

可以看出来，其实就是中间一段代码的执行顺序不同：

for (int i = 0; i < node->count; i++) {
	printf("%d", node->key);
}

以第三节的[7,3,5,1,9,8,2,4]为例：

 

                7
             /      \
            3         9
         /    \      /
        1      5    8
         \    /
          2  4
输入：[7,3,5,1,9,8,2,4]
前序：[7,3,1,2,5,4,9,8]
中序：[1,2,3,4,5,7,8,9]
后序：[2,1,4,5,3,8,9,7]

为什么仅仅调整了顺序就会有很大的不同呢？这就是递归的妙处所在，以中序输出为例：

void LNR(Node* node) {
	if (node == NULL) {
		return;
	}

	LNR(node->left) {
		if (node == NULL) {
			return;
		}

		LNR(node->left) {
			......//重复
		};

		for (int i = 0; i < node->count; i++) {
			printf("%d", node->key);
		}

		LNR(node->right);
	};

	for (int i = 0; i < node->count; i++) {
		printf("%d", node->key);
	}

	LNR(node->right);
}

实际上在函数 LNR（）递归调用自身的时候，我们就进入另一个函数了，只不过这个函数的操作步骤和 LNR（）自己本身一样，这样不断递归下去，那么直到 某一次递归的node=NULL时才开始执行其他操作，所以最先访问的是二叉树最左端的数据。

不知道这样解释能不能理解，不行就自己多敲点代码吧~~~熟能生巧

 

七、总结

好了终于又到说拜拜的时候了，这里主要实现了二叉树的增删查和遍历，没有改（对于二叉树要写改的话就是先删再增）。写的不太好的地方多包涵。

数据结构（邓俊辉）学习笔记】优先级队列 07——堆排序
weixin_44399845的博客
08-18 1060
堆排序
【数据结构学习笔记】——二叉树的建立、交换、求宽度
且听风吟
02-03 625
要求编写二叉树类的成员函数，分别实现以下功能： ① 交换二叉树中所有节点的左右子树。 ② 按层次顺序遍历二叉树：首先访问根节点，然后是它的两个孩子节点，然后是孙子节点，依此类推。（将结果输出至屏幕） ③ 求二叉树的宽度，即同一层次上最多的节点数。（将结果输出至屏幕） 分析观察这个二叉树，发现只是并不是完全二叉树。可以用书上makeTree的方法挨个建立，但是觉得太过麻烦。这里采
二叉树基础
03-28
树的基础知识 树的定义： 1. 树包含n（n ≥ 0 ）个节点，n = 0时称为空树。 2. 在树的结构关系中，有且仅有一个节点没有前趋节点，这个节点称为树的根节点。 3. 除根节点外，树中其他的节点有且仅有一个前趋节点，但可以有很多后继节点。如图，A为根节点。
二叉树的用法
红叶的专栏
03-09 435
计算二叉树深度int BinTreeDepth(ChainBinTree *bt)//bt:表示父节点指针 { int dep1,dep2; if(bt==NULL) return 0;//对于空树，深度为0 else { dep1=BinTreeDepth(bt->left);//左子树深度（递归调用） dep2=Bi
二叉树用法
operation_hao的博客
04-11 229
树的一些基本用法 目录 二叉树的创建 二叉树的遍历 二叉堆的基本用法 学习收获 ======================================================== 一.二叉树的创建 创建二叉树（先序，中序，后序） typedef struct node; typedef node *tree; struct node { char date; tree lchi...
二叉树的使用方法
qq_30534935的博客
02-11 1384
转载： http://blog.jobbole.com/108184/ https://blog.youkuaiyun.com/zhanggonglalala/article/details/79738213 https://blog.youkuaiyun.com/heyanxi0101/article/details/79593542 一、概述 平衡树：所有结点左右子树深度差≤1 排序树：所有结点“左小右大 字典树：由...
浅谈二叉树的使用
Lzinner的博客
05-03 386
2018/5/31.说在前面:由于数据结构已经学完了树，对于这种比较难的结构，说一点看法2.二叉树：1.由一个根节点和两个互不相较的子二叉树（左子树和右子树）组成的树2.相关操作介绍：1.创建结构体实现树的建立对于树而言，依旧采取结构体指针的方式，树拥有着一个左子树，一个右子树和一个储存数据的位置typedef struct Node { int data; struct Node *left...
机器学习笔记——从手写数字识别开始
m0_56010727的博客
07-03 2046
文章目录前言监督学习全连接神经网络的实现决策树以及随机森林的实现卷积神经网络的实现支持向量机的实现无监督学习K-means聚类的实现SVD矩阵分解的实现总结 前言 这是作者的第一篇博客，作为初学者将自己大一下学期进行的机器学习内容进行一个简单的整理，并且尝试使用多种方法实现手写minst数字识别项目。 作者自2021年4月，根据本校一位老师的学习指导，至7月假期，课余进行了一些基本机器学习算法的学习，从最基础的线性回归开始，直至后续的随机决策森林，朴素贝叶斯以及简单的CNN等。由于均系课余时间学习，算法
Linux学习笔记03——C编程环境
m0_52248951的博客
05-06 1177
简介 概述 Linux下一般使用C语言编写系统程序以及对性能要求较高的程序 Linux通常使用gcc套件编译程序，运用gdb/ddd调式工具进行调试与排错 学习目标 理解Linux C程序的编译、执行过程，gcc命令选项，自定义函数库的制作 熟悉Linux C程序中编程错误的诊断与处理方法 熟悉使用Linux自带的字符串运算、排序算法、二叉树算法库编写应用程序 熟悉使用gdb/ddd调式Linux C程序 掌握利用命令行参数和环境变量给程序提供数据 能够使用make工具管理大型C/C++编
数据结构学习笔记——查找算法中的树形查找（红黑树）
小宇y的博客
01-14 641
红黑树是一棵二叉排序树（满足结点值中：左子树
二叉树的基本用法总结
u011131874的专栏
09-11 2207
下面列举了二叉树的一些常用方法，水平有限 代码写的质量不怎么地，基本功能是实现了的 功能有：树的建立、删除； 先序、后序、中序、层次遍历； 节点的查找，节点的插入； 兄弟的查找，父节点的查找； 计算树的深度、叶子数、节点数； 树的拷贝； 判断两个树是否相等； 判断是否是满树、完全树； #include #include #include #include #include usi
二叉树的基本操作
2303_80828380的博客
05-23 829
二叉树入门
二叉树的基本概念及运用
kkksij的博客
10-26 707
若不等， 递归遍历左树查找对应的值，创建新树left来接受每次递归的树，递归结束若左树最终不为空，返回左树，右数同理。判断当前节点是否为空，不为空，判断当前节点的左子树和右子树是否同时为空，为空，将leafsize++；=null, 遍历D的左子树，返回0，再遍历右子树，也返回零，此时。判断当前节点是否为空，不为空，判断root.val是否 == val ，以图为例，按照 左子树--> 根节点---> 右子树 的方式进行递归。2.判断k是否为1，为1，即为根节点，return1即可。判断当前节点是否为空。
数据结构之二叉树 - 超详细的教程，手把手教你认识并运用二叉树
ミカミミミ博客
04-07 2027
带你深入理解二叉树的保姆级教程。
二叉树的应用详解 - 数据结构
热门推荐
黄规速博客:学如逆水行舟，不进则退
06-25 4万+
概述： 平衡树——特点：所有结点左右子树深度差≤1 排序树——特点：所有结点“左小右大 字典树——由字符串构成的二叉排序树 判定树——特点：分支查找树（例如12个球如何只称3次便分出轻重） 带权树——特点：路径带权值（例如长度） 最优树——是带权路径长度最短的树，又称 Huffman树，用途之一是通信中的压缩编码。 1. 二叉排序树（二叉查找树Binary Sear
一篇文章带你深入学习二叉树和二叉查找树
qq_31828845的博客
08-19 204
树是计算机科学中经常用到的一种数据结构。树是一种非线性的数据结构，以分层的方式存储数据。 树被用来存储具有层级关系的数据，比如文件系统中的文件。 树还可以用来存储有序列表。 树的定义 树是由一组以边连接的节点组成。公司的组织结构图就是一个树的例子。 组织结构图就是一种树 一棵树最上面的节点成为根节点。如果一个节点下面连接着多个节点，那么该节点称为父节点，它下面的节点称为子节点。一个节点可以有0个...
用最原始最易懂的方法建立二叉树
认知 行动 坚持
11-01 9893
#include #define N 7 using namespace std; typedef struct node { struct node *leftChild; struct node *rightChild; int data; }BiTreeNode, *BiTree; //生成一个结点 BiTreeNode *createNode(int i)
labuladong算法笔记Java
最新发布
01-07
除了具体的数据结构外，笔记也强调掌握各种遍历方式的重要性——无论是迭代还是递归形式。特别是当涉及到复杂结构像二叉树时，理解前序、中序及后序三种不同的遍历模式至关重要[^2]: ```java void preOrder...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值