树

最新推荐文章于 2024-02-25 09:32:23 发布
最新推荐文章于 2024-02-25 09:32:23 发布
阅读量229 收藏 1
点赞数 1
分类专栏： 数据结构 # 算法笔记(胡凡)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43318827/article/details/106878899
版权

快速导航

二叉排序树

这里采用将数据先全部存储数组vec中，再构造树
删除结点操作： 为了保证删除之后仍然是一颗二叉排序树，有两个方法。一个是找到比当前结点小的最大结点来覆盖当前结点，再删除原来位置上的结点；另一种是找到比当前结点大的最小结点覆盖当前结点，再删除原来位置上的结点。
其中比当前结点小的最大结点叫做该结点的前驱；比当前结点大的最小结点叫做该结点的后继。结点的前驱是该结点左子树中的最右结点，而结点的后继则是该结点右子树中的最左结点。
所以这里用两个函数分别寻找前驱和后继：

node* findMAX(node* root) //找前驱
{
	while (root -> right != NULL) //不停往右直到没有右孩子
		root = root -> right;
	return root;
}
node* findMIN(node* root) //找后继
{
	while (root -> left != NULL) //不停往左直到没有左孩子
		root = root -> left;
	return root;
}

接着写删除函数，如果打算用前驱P来替换当前结点N，于是问题就转换为了在N的左子树中删除P。

void delete_Node(node* &root, int x)
{
	if (!root) //结点不存在
		return;
	if (root -> val == x) //找到结点，进入删除环节
	{
		if (root -> left == NULL && root -> right == NULL) //不存在左右子孩子，说明是叶子结点，直接删除
			root = NULL;
		else if (root -> left != NULL) //有左孩子，则找前驱结点
		{
			node* pre = findMAX(root -> left);
			root -> val = pre -> val; //让前驱覆盖当前结点
			delete_Node(root -> left, pre -> val); //然后删除前驱结点
		}else{
			node* next = findMIN(root -> right); //有右孩子，则找后继结点
			root -> val = next -> val; //后继结点覆盖当前结点
			delete_Node(root -> left, next -> val); //接着删除后继结点
		}
	}
	else if (root -> val > x)
		delete_Node(root -> left, x);
	else
		delete_Node(root -> right, x);
}

完整代码：

#include <iostream>
#include <cstdlib>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
struct node
{
	int val;
	node* left;
	node* right;
	node(int v) : val(v), left(NULL), right(NULL) {}
};
vector<int> vec; //数组
void search(node*, int);
void insert(node* &, int);
node* creat_tree();
node* findMAX(node*);
node* findMIN(node*);
void delete_Node(node* &, int);
void preorder(node*);
void inorder(node*);
void postorder(node*);
void levelorder(node*);
int main()
{
	int value;
	while (cin >> value)
		vec.push_back(value);
	node* root = creat_tree();
	cout << "先序序列：";
	preorder(root);
	cout << endl;
	cout << "中序序列：";
	inorder(root);
	cout << endl;
	cout << "后序序列：";
	postorder(root);
	cout << endl;
	system("pause");
	return 0;
}
node* creat_tree() //建立树
{
	node* root = NULL;
	for (int i = 0;i < vec.size(); i++)
		insert(root, vec[i]);
	return root;
}
void search(node* root, int x) //寻找结点
{
	if (!root)
		return;
	if (root -> val == x)
		cout << "find it!";
	else if (x < root -> val)
		search(root -> left, x);
	else
		search(root -> right, x);
}
void insert(node* &root, int x) //插入结点
{
	if (!root)
	{
		root = new node(x); //因为传入的参数采用了引用，所以这里直接赋值就能实现插入
		return;
	}
	if (root -> val == x)
		return;
	else if (x < root -> val) //二叉排序树，小于则在左边
		insert(root -> left, x);
	else
		insert(root -> right, x);
}
node* findMAX(node* root)
{
	while (root -> right != NULL)
		root = root -> right;
	return root;
}
node* findMIN(node* root)
{
	while (root -> left != NULL)
		root = root -> left;
	return root;
}
void delete_Node(node* &root, int x)
{
	if (!root)
		return;
	if (root -> val == x)
	{
		if (root -> left == NULL && root -> right == NULL)
			root = NULL;
		else if (root -> left != NULL)
		{
			node* pre = findMAX(root -> left);
			root -> val = pre -> val;
			delete_Node(root -> left, pre -> val);
		}else{
			node* next = findMIN(root -> right);
			root -> val = next -> val;
			delete_Node(root -> left, next -> val);
		}
	}
	else if (root -> val > x)
		delete_Node(root -> left, x);
	else
		delete_Node(root -> right, x);
}
void preorder(node* root) //前序遍历
{
	if (root == NULL)
		return;
	cout << root -> val;
	preorder(root -> left);
	preorder(root -> right);
}
void inorder(node* root) //中序
{
	if (root == NULL)
		return;
	inorder(root -> left);
	cout << root -> val;
	inorder(root -> right);
}
void postorder(node* root) //后序
{
	if (root == NULL)
		return;
	postorder(root -> left);
	postorder(root -> right);
	cout << root -> val;
}
void levelorder(node* root) //层序遍历
{
	queue<node*> que;
	que.push(root);
	while (!que.empty())
	{
		node* p = que.front();
		cout << p -> val;
		que.pop();
		if (p -> left != NULL)
			que.push(p -> left);
		if (p -> right != NULL)
			que.push(p -> right);
	}
}
输出：
5 3 7 4 2 8 6
^Z
先序序列：5324768
中序序列：2345678
后序序列：2436875
删除结点5：432768

平衡二叉树

构造平衡二叉树的核心就是每个结点的平衡因子，即任意结点的左子树和右子树的高度之差为该结点的平衡因子。
现在在结构体中用height表示当前结点的高度：

struct node
{
	int val;
	int height;
	node* left;
	node* right;
	node(int v) : val(v), height(1), left(NULL), right(NULL) {}
};

用某个结点左孩子结点的高度减去右孩子结点的高度即可得到平衡因子。
在二叉树代码的基础上多出这几个函数：

int get_height(node* root) //得到当前结点的高度
{
	if (!root)
		return 0;
	return root -> height;
}
int get_balance_factor(node* root) //得到当前结点的平衡因子
{
	return get_height(root -> left) - get_height(root -> right);
}
void update_height(node* root) //更新高度，一般在插入结点后使用
{
	root -> height = max(get_height(root -> left), get_height(root -> right)) + 1;
}

旋转操作

然后是调整二叉树变成平衡二叉树的关键，左旋和右旋：

左旋


左旋的操作可以细分
在这里插入图片描述

//左旋
void LR(node* &root)
{
	node* temp = root -> right;
	root -> right = temp -> left; //temp的左子树赋给root的右边
	temp -> left = root; //root赋给temp的左
	update_height(root); //更新高度
	update_height(temp);
	root = temp;
}
右旋

在这里插入图片描述
在这里插入图片描述
右旋其实就是左旋的对称过程：

void RR(node* &root)
{
	node* temp = root -> left;
	root -> left = temp -> right;
	temp -> right = root;
	update_height(root);
	update_height(temp);
	root = temp;
}

插入操作

插入过程中难免会造成树的失衡，此时有多种情况：若A的平衡因子是2，说明左子树的高度比右子树大2，于是以A为根结点的子树一定是下面两种情况：

注意：LL和LR表示的是树型，不是左右旋

LL情况

把以C为根结点的子树看作是一个整体，然后以根节点A作为root进行右旋：

LR情况

LR型只不过比LL型多一个步骤罢了：

然后是A的平衡因子为-2，此时右子树的高度比左子树大2，于是以结点A为根节点的子树只有下图RR和LR两种：
在这里插入图片描述

RR型情况

和LL型一样，把以C为根节点的子树看作一个整体，然后以结点A作为root进行左旋：
在这里插入图片描述

RL型情况

把情况转换为RR型，然后按上面RR型的做法进行左旋：
在这里插入图片描述
将上面的内容应用于insert函数，每次插入一个结点之后更新当前子树的高度，然后根据树型进行平衡操作：

void insert(node* &root, int v) //插入结点
{
	if (root == NULL)
	{
		root = new node(v);
		return;
	}
	if (v < root -> val)
	{
		insert(root -> left, v); //往左子树插
		update_height(root); //更新树高
		if (get_balance_factor(root) == 2) //等于2说明是LL或者LR
		{
			if (get_balance_factor(root -> left) == 1) //1说明是LL
				RR(root); //执行右旋
			else if (get_balance_factor(root -> left) == -1) //LR
			{
				LR(root -> left); //先左旋，变成LL型
				RR(root); //再右旋
			}
		}
	}
	else
	{
		insert(root -> right, v); //往右子树插
		update_height(root);
		if (get_balance_factor(root) == -2) //RR或者RL型
		{
			if (get_balance_factor(root -> right) == -1) //RR
				LR(root); //左旋
			else if (get_balance_factor(root -> left) == 1) //LR
			{
				RR(root -> right);
				LR(root);
			}
		}
	}
}

完整代码：

#include <iostream>
#include <cstdlib>
#include <vector>
#include <queue>
#include <cmath>
#include <algorithm>
using namespace std;
struct node
{
	int val;
	int height;
	node* left;
	node* right;
	node(int v) : val(v), height(1), left(NULL), right(NULL) {}
};
vector<int> vec; //数组
int get_height(node*);
int get_balance_factor(node*);
void update_height(node*);
void LR(node* &);
void RR(node* &);
void insert(node* &, int);
void preorder(node* root);
void inorder(node* root);
void postorder(node* root);
void levelorder(node* root);
node* creat_tree();
int main()
{
	int value;
	while (cin >> value)
		vec.push_back(value);
	node* root = creat_tree();
	cout << "先序序列：";
	preorder(root);
	cout << endl;
	cout << "中序序列：";
	inorder(root);
	cout << endl;
	cout << "后序序列：";
	postorder(root);
	cout << endl;
	cout << "层序序列：";
	levelorder(root);
	cout << endl;
	system("pause");
	return 0;
}
int get_height(node* root)
{
	if (!root)
		return 0;
	return root -> height;
}
int get_balance_factor(node* root)
{
	return get_height(root -> left) - get_height(root -> right);
}
void update_height(node* root)
{
	root -> height = max(get_height(root -> left), get_height(root -> right)) + 1;
}
void LR(node* &root)
{
	node* temp = root -> right;
	root -> right = temp -> left;
	temp -> left = root;
	update_height(root);
	update_height(temp);
	root = temp;
}
void RR(node* &root)
{
	node* temp = root -> left;
	root -> left = temp -> right;
	temp -> right = root;
	update_height(root);
	update_height(temp);
	root = temp;
}
node* creat_tree() //建立树
{
	node* root = NULL;
	for (int i = 0;i < vec.size(); i++)
		insert(root, vec[i]);
	return root;
}
void insert(node* &root, int v) //插入结点
{
	if (root == NULL)
	{
		root = new node(v);
		return;
	}
	if (v < root -> val)
	{
		insert(root -> left, v);
		update_height(root);
		if (get_balance_factor(root) == 2)
		{
			if (get_balance_factor(root -> left) == 1)
				RR(root);
			else if (get_balance_factor(root -> left) == -1)
			{
				LR(root -> left);
				RR(root);
			}
		}
	}
	else
	{
		insert(root -> right, v);
		update_height(root);
		if (get_balance_factor(root) == -2)
		{
			if (get_balance_factor(root -> right) == -1)
				LR(root);
			else if (get_balance_factor(root -> left) == 1)
			{
				RR(root -> right);
				LR(root);
			}
		}
	}
}
void preorder(node* root) //前序遍历
{
	if (root == NULL)
		return;
	cout << root -> val;
	preorder(root -> left);
	preorder(root -> right);
}
void inorder(node* root) //中序
{
	if (root == NULL)
		return;
	inorder(root -> left);
	cout << root -> val;
	inorder(root -> right);
}
void postorder(node* root) //后序
{
	if (root == NULL)
		return;
	postorder(root -> left);
	postorder(root -> right);
	cout << root -> val;
}
void levelorder(node* root) //层序遍历
{
	queue<node*> que;
	que.push(root);
	while (!que.empty())
	{
		node* p = que.front();
		cout << p -> val;
		que.pop();
		if (p -> left != NULL)
			que.push(p -> left);
		if (p -> right != NULL)
			que.push(p -> right);
	}
}
输出：
1 2 3 4 5 6
^Z
先序序列：421356
中序序列：123456
后序序列：132654
层序序列：425136

例题PAT甲级1066 Root of AVL Tree

树

这个树指的是一般意义上的树，即子结点个数不限且子结点没有先后次序的树，这里的结点结构体中使用一个数组来存储所有的子结点
举例：

      0
    / | \
   1  2  3
 /  \    |
4    5   6

#include <iostream>
#include <cstdlib>
#include <vector>
#include <queue>
using namespace std;
struct node
{
	int layer; //用来记录结点的层次
	int value; //结点的数值
	vector<int> child; //结点的子结点
};
vector<node> Node(10);
void pre_order(int);
void layer_order(int);
int newNode(int);
int main()
{
	for (int i = 0; i < Node.size(); i++)
		Node[i].value = i;
	for (int i = 1; i <= 3; i++)
		Node[0].child.push_back(i);
	Node[1].child.push_back(4);
	Node[1].child.push_back(5);
	Node[3].child.push_back(6);
	cout << "先根遍历：";
	pre_order(0);
	cout << endl;
	cout << "层序遍历：";
	layer_order(0);
	cout << endl;
	cout << Node[0].layer << ' ' << Node[5].layer;
	system("pause");
	return 0;
}
void pre_order(int root) //先根遍历
{
	cout << Node[root].value;
	for (int i = 0; i < Node[root].child.size(); i++)
		pre_order(Node[root].child[i]);
}
void layer_order(int root) //层序遍历
{
	queue<int> que;
	que.push(root);
	Node[root].layer = 0;
	while (!que.empty())
	{
		int front = que.front();
		cout << Node[front].value;
		que.pop();
		for (int i = 0; i < Node[front].child.size(); i++)
		{
			int child = Node[front].child[i];
			Node[child].layer = Node[front].layer + 1;
			que.push(child);
		}
	}
}
输出：
先根遍历：0145236
层序遍历：0123456
0 2
冷眼观world
关注
专栏目录
回归树
壮壮不太胖的学习笔记
06-01 4398
回归树，就是用树模型做回归问题，每一片叶子都输出一个预测值。预测值一般是叶子结点所含训练集输出的均值。 回归树的分支标准：标准方差（Standard Deviation）。 回归树使用某一特征将原集合分为多个子集，用标准方差衡量子集中的元素是否接近，越小表示越接近。 首先计算根节点标准方差： 使用标准方差来确定分支，以计算Outlook分支后的标准方差为例： 同理可计算其他特征的标准差，并得到方差的减小值： 标准差降低最多的特征是Outlook，利用其进行分支。 接下来，重复这个过程，使用标准方差
20170816_二叉树的建立+前序遍历+中序遍历+后序遍历+层序遍历
风暴计划
08-16 879
20170816_二叉树的建立+前序遍历+中序遍历+后序遍历+层序遍历
第九章 ——数据结构
qq_43721152的博客
08-21 232
9.1树与二叉树 9.1.1 树的定义与性质 树是概括这种传递关系的一种数据结构。 （1）树可以没有节点，这种情况把他称为空树。 （2）树的层次从根节点开始算起，即根节点为第一层，根节点子树的根节点为第二层，以此类推。 （3）把结点的子树棵树称为结点的度，而树中结点的最大的度称为树的度（也称树的宽度） （4）由于一条边连接两个结点，所以树没有环。有n个结点的树，边有n-1.且满足连通、边数等于顶点...
【机器学习实战】3、决策树
呆呆的猫的博客
03-13 36万+
(声明：本文内容来自机器学习实战和统计学习方法，是两者的整合，并非来自单个书籍）决策树（decision tree）：是一种基本的分类与回归方法，此处主要讨论分类的决策树。在分类问题中，表示基于特征对实例进行分类的过程，可以认为是if-then的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。决策树通常有三个步骤：特征选择、决策树的生成、决策树的修剪。用决策树分类：从根节点开始，对实例的某一特征进行测试，根据测试结果将实例分配到其子节点，此时每个子节点对应着该特征的一个取值，如此递归的对实例进行测
Python圣诞树
兔子王
12-07 5万+
Python圣诞树源码。
LSM树
艾斯-李的博客
06-26 3万+
关于LSM树 LSM树，即日志结构合并树(Log-Structured Merge-Tree)。其实它并不属于一个具体的数据结构，它更多是一种数据结构的设计思想。大多NoSQL数据库核心思想都是基于LSM来做的，只是具体的实现不同。所以本来不打算列入该系列，但是有朋友留言了好几次让我讲LSM树，那么就说一下LSM树。 LSM树诞生背景 传统关系型数据库使用btree或一些变体作为存储结构，能...
C++红黑树
~
03-26 6704
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
使用决策树算法预测隐形眼镜类型
最新发布
兔子王
02-25 2万+
使用决策树算法预测隐形眼镜的类型。
通过命令方式查看目录树
howard2005的专栏
05-10 2046
在Windows和CentOS上查看目录树
bootstrap树形下拉框 下拉框树形菜单
11-15
Bootstrap Tree形下拉框是一种将传统的下拉菜单与树形结构结合的UI组件，它使得在有限的空间内展示层级关系的数据变得更加便捷。这种组件通常用于需要用户从一个多级分类中选择一个选项的情况，例如在组织架构、地区...
C4.5决策树算法的Python代码和数据样本
12-21
资源中包含完整的C4.5决策树算法Python代码和测试数据，其中有4个文件：C45.py是算法的实现代码，treePlotter.py是绘制决策树代码，PlayData.txt是样本数据，C45test.py用来构建、绘制并测试决策树，您可以运行该...
Ztree+treeTable实现 Java实现 树形菜单 树形表格
08-07
在Java开发中，构建用户界面时，树形菜单和树形表格是常见且重要的组件，它们可以帮助用户以层次结构的方式浏览和操作数据。本篇将详细介绍如何利用Ztree和treeTable来实现这样的功能。 Ztree是一款基于JavaScript...
Python——画一棵漂亮的樱花树（不同种樱花+玫瑰+圣诞树喔）
热门推荐
碎片
10-22 56万+
最近翻到一篇知乎，上面有不少用Python（大多是turtle库）绘制的树图，感觉很漂亮，我整理了一下，挑了一些我觉得不错的代码分享给大家（这些我都测试过，确实可以生成） one 樱花树 动态生成樱花 效果图（这个是动态的）： 实现代码 import turtle as T import random import time # 画樱花的躯干(60,t) def Tree(branch, ...
HTML圣诞树代码(动态音效)
qq_63108921的博客
12-19 18万+
<!DOCTYPE html> <html lang="en" > <head> <meta charset="UTF-8"> <title>圣诞树</title> <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/5.0.0/normalize.min.css"> <...
素数
冷眼看world的博客
04-19 2208
素数的判断 判断一个数n是否为素数，就需要判断n是否能被2、3…、n-1中的一个数整除。只有都不能整除n，n才能判定为素数。 bool isPrime(int n) { if (n <= 1) return false; for (int i = 2; i < n; i++) { if(n % i == 0) retu...
质因子分解
冷眼看world的博客
04-20 1299
质因子分解是指将一个正整数n写成一个或多个素数的乘积形式，比如6 = 2 * 3、8 = 2 * 2 * 2、180 = 2 * 2 * 3 * 3 * 5。 或者也可以写成指数形式，6 = 21 * 31、8 = 23、180 = 22 * 32 * 51。最后因为都要归结到若干不同素数的乘积，因此不妨先把素数表打印出来。用上一章讲的方法就可以。 因为每个质因子都可以不止出现一次，因此不妨定...
最大公约数和最小公倍数
冷眼看world的博客
04-19 971
最大公约数 a和b的最大公约数指a与b的所有公约数中最大的那个公约数，比如4和6的最大公约数是2。求解最大公约数常用欧几里得算法（即辗转相除法） 欧几里得算法基于这个定理： 设a、b是正整数，则gcd(a, b) = gcd(b, a % b); 证明： 设a = kb + r，其中k和r分别为a除以b得到的商和余数 则有r = a - kb成立 设d为a和b的一个公约数 那么由r = a -...
大整数运算
冷眼看world的博客
04-26 682
大整数的存储 比如2358133可以存储在int数组d[1000]中，d[0] = 3，d[1] = 1，d[2] = 8…即整数的高位存储在数组到高位，整数的低位存储在数组的低位。 不反过来存储的原因是进行运算的时候都是从低位到高位枚举，顺位存储和这种思维相合。这时候还有要注意一个问题：如果把整数按字符串%s读入时，和上面的存储顺序是相反的，因此要存到d数组时得反转一下。 ...
C语言绘制圣诞树的程序实现
"如何用C语言画一个‘圣诞树’" 在C语言中，绘制图形通常是通过控制字符输出来实现的，对于“圣诞树”的绘制也不例外。这个程序利用了位操作和几何形状的递归思想来生成不同的圣诞树形状。下面我们将详细解释这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值