二叉树进阶

于 2022-06-23 15:21:25 发布
阅读量312 收藏 4
点赞数 10
文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58867976/article/details/125409765
版权

目录

前言

二叉搜索树(非递归)

二叉搜索树(递归)

二叉树的性能分析

Key模型与Key-Value模型

全部代码

前言

二叉搜索树又称二叉排序树，它或者是一棵空树，因为它的左子树的值<根的值<右子树的值(左右子树不为空时)，左右子树也是二叉搜索树，所以它的中序遍历则是升序

节点封装如下

注意：为了避免存储重复数，以及找不到要删除的数的节点，插入与删除的返回类型采用布尔类型

二叉搜索树具有排序+去重的作用

二叉搜素树的实现(非递归)

插入

如果是一颗空树，则直接插入即可

要插入节点，需要找到前驱节点，所以一般都需要遍历这颗树，就需要两个指针parent和cur，类似于单链表插入节点

新插入节点的值与二叉树中某个节点的值一致时，则直接返回，即插入失败

找到前驱节点之后，再判断节点值的大小，来确定插入左边还是右边，然后返回即可

 

删除

先查找要删除的元素

找到之后，要删除的元素只有右节点，或者左右节点均为空时，如果只有根节点，就删除根节点，否则就删除找到的节点，然后让它的父亲指向它的右孩子

找到之后，要删除的元素只有左节点，或者左右节点均为空时，如果只有根节点，就删除根节点，否则就删除找到的节点，然后让它的父亲指向它的左孩子

 

找到之后，左右孩子都存在时，先找到右子树的最左节点，然后把找到节点的值赋值给要删除的节点，如果找到的最左节点，有右孩子时，则让它的父亲指向它的右孩子，然后删除刚刚找到的左节点或右节点

二叉搜索树的实现(递归)

因为节点指针是私有的，而递归写法的插入与删除都要用到根节点，所以需要再套一层

 

插入

递归和非递归类似，都是先找到其前驱节点，然后再连接即可，比如下图，开始值为3的节点的右孩子是nullptr，然后再展开后，将指向nullptr的指针指向值为5的节点，则值为3的节点的右孩子是值为5的节点了

删除

和非递归类似，都是先找到要删除的节点，如果要删除的节点为不存在，则删除失败

要删除的节点的右孩子为nullptr时，让它的左孩子变为它的父节点的左孩子即可

 要删除的节点的左孩子为nullptr时，让它的右孩子变为它的父节点的左孩子即可

要删除的节点既有左孩子又有右孩子时，先将要删除的节点的值与根节点的右子树的最左节点的值交换，然后遍历根节点的右子树来删除最左节点

二叉树的性能分析

最优情况：当二叉搜索树是完全二叉树时，其平均比较次数为log2 n

最差情况：当二叉搜索树退化为单支树时，其平均比较次数为n/2

解决方法

将二叉树进一步优化，使其成为平衡二叉树，有AVL树或红黑树两种

Key模型与Key-Value模型

Key模型

门禁系统，存储该栋楼所有同学学号或小区所有业主的车牌号，有就让进入，没有就无法进入

Key—Value模型

字典,通过一个单词的英文，从而知道它的中文意思

Key—Value模型则需要存储两个值，一个是Key,另一个则是Value

 

全部代码

//二叉搜索树

#pragma once
#include<iostream>
using namespace std;

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	BSTreeNode(const K& key):_left(nullptr),_right(nullptr),_key(key)
	{}
};

template<class K>
struct BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree():_root(nullptr)
	{}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//找到，准备开始删除
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
				}
				else
				{
					Node* minParent = cur;
					Node* min = cur->_right;
					while (min->_left)
					{
						minParent = min;
						min = min->_left;
					}
					cur->_key = min->_key;
					if (minParent->_left == min)
						minParent->_left = min->_right;
					else
						minParent->_right = min->_right;
					delete min;
				}
				return true;
			}
		}
		return false;
	}

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}

	Node* EraseR(const K& key)
	{
		return _Erase(_root, key);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if(root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				Node* min = root->_right;
				while (min->_left)
				{
					min = min->_left;
				}
				swap(min->_key, root->_key);
				//递归到右子树去删除
				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return  true;
		}
		if (root->_key < key)
			return _InsertR(root->_right, key);
		else if (root->_key > key)
			return _InsertR(root->_left, key);
		else
			return false;
	}
	
	Node* _FindR(Node* root,const K& key)
	{
		if (_root == nullptr)
		{
			return nullptr;
		}
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return root;
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root;
};

void TestBSTree()
{
	BSTree<int> t;
	int a[] = { 5,3,4,1,7,8,2,6,0,9,5,5 };
	for (auto e : a)
	{
		t.InsertR(e);
	}
	//排序+去重
	t.InOrder();

	t.Erase(7);
	t.InOrder();

	t.Erase(5);
	t.InOrder();

	t.Erase(0);
	t.InOrder();

	t.Erase(1);
	t.InOrder();

	for (auto e : a)
	{
		t.Erase(e);
		t.InOrder();
	}
	t.InOrder();
}


namespace KV
{
	template<class K,class V>
	struct BSTreeNode
	{
		BSTreeNode<K,V>* _left;
		BSTreeNode<K,V>* _right;
		K _key;
		V _value;

		//pair<K,V> _kv;

		BSTreeNode(const K& key,const V& value) :_left(nullptr), _right(nullptr), _key(key),_value(value)
		{}
	};

	template<class K,class V>
	struct BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		BSTree() :_root(nullptr)
		{}

		bool Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}

			Node* parent = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			cur = new Node(key, value);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return cur;
				}
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//找到，准备开始删除
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_right;
							else
								parent->_right = cur->_right;
						}
						delete cur;
					}
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}
						delete cur;
					}
					else
					{
						Node* minParent = cur;
						Node* min = cur->_right;
						while (min->_left)
						{
							minParent = min;
							min = min->_left;
						}
						cur->_key = min->_key;
						if (minParent->_left == min)
							minParent->_left = min->_right;
						else
							minParent->_right = min->_right;
						delete min;
					}
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
		Node* _root;
	};

	void TestBstree1()
	{
		//字典KV模型
		BSTree<string, string> dict;
		dict.Insert("sort", "排序");
		dict.Insert("left", "左边");
		dict.Insert("right", "右边");
		dict.Insert("map", "地图、映射");
		//...

		string str;
		while (cin >> str)
		{
			BSTreeNode<string, string>* ret = dict.Find(str);
			if (ret)
			{
				cout << "对应中文解释: " << ret->_value << endl;
			}
			else
			{
				cout << "无此单词" << endl;
			}
		}
	}

	void TestBstree2()
	{
		//统计水果出现次数
		string arr[] = { "苹果" , "西瓜" ,"草莓" , "苹果", "西瓜" , "苹果" , "苹果" , "西瓜" ,"苹果","香蕉" ,"苹果" , "香蕉" };
		BSTree<string, int> countTree;
		for (auto& str : arr)
		{
			//BSTreeNode<string,int>* ret = cout << countTree.Find(str);
			auto ret = countTree.Find(str);
			if (ret != nullptr)
			{
				ret->_value++;
			}
			else
			{
				countTree.Insert(str, 1);
			}
		}

		countTree.InOrder();
	}
}

 

风影66666
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
数据结构——二叉树进阶
New_learner55的博客
12-28 308
在我看来，在数据结构中，存在三个最经典的树型结构，他们分别是二叉排序树（BST），二叉平衡树（AVL） 和 红黑树（BRT）。 二叉排序树又叫做二叉搜索树，它可以是一棵空树，也可以是具有三个性质的一棵二叉树。 性质一：若它的左子树不为空，则左子树上的所有结点的值均小于它的根结点的值 性质二： 若它的右子树不为空，则右子树上的所有结点的值均大于它的根结点的值 性质三： 左右子树也是二叉排序树。 构造二叉搜索树的目的是提高查找和插入删除关键字的速度。因为二叉排序树是一个排序好的有序数据集，查找的速度肯定是快于无
二叉搜索树
CHheart的博客
07-13 198
二叉搜索树 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值。 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。 它的左右子树也分别为二叉搜索树。 int a [] = {5,3,4,1,7,8,2,6,0,9}; 二叉搜索树的查找 二叉搜索树的插入 a. 树为空，则直接插入 b. 树不空，按二叉搜索树性质查找插入位置，插入新节点 插入10 二叉搜索树的删除 首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况： a. 要删除的结点无孩子结点 b
数据结构--二叉树进阶
平生的小铺子
08-20 407
因为我们之前在学习数据结构的时候使用的是C语言，但是并不是所有的数据结构都适合使用C语言学习，如今我们了解了C++的基础语法，具备了学习这些稍微难一点的数据结构的前提，所以我们再次回顾数据结构，使用C++这一更加先进的武器，来解决更加复杂的问题 二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也
易语言二叉树遍历源码-易语言
06-13
二叉树在计算机科学中是一种...这个源码实例对于易语言的学习者来说是一个很好的进阶教程，可以帮助他们更好地理解数据结构和递归算法。在实际编程中，熟练掌握二叉树遍历对于提高程序效率和解决问题的能力至关重要。
算法竞赛入门到进阶 课件+源码
06-17
这可能包括数组、链表、栈、队列、树（二叉树、平衡树、堆）、图等。课件中会介绍这些数据结构的定义、操作和性能分析，源码则会提供实现示例，帮助你在实践中熟悉它们。 三、高级算法 随着技能的提升，你将接触到...
二叉树和图的常用算法操作.zip
08-16
这个“二叉树和图的常用算法操作”压缩包可能包含了关于这两种数据结构的一些基础和进阶操作的实现，旨在帮助学习者深入理解和应用这些概念。 首先，我们来看二叉树。二叉树是一种特殊的树形数据结构，其中每个节点...
树的相关编程.docx
03-23
在计算机科学中，树是一...以上知识点涵盖了树结构在编程中的一些基础和进阶应用，它们对于理解和解决涉及树的数据结构问题至关重要。掌握这些概念和算法能够帮助你在LeetCode等平台上的数据结构题目中取得良好的表现。
Java基础，Java进阶，Java数据结构，十大算法
04-04
接下来是“Java进阶”部分，这部分将深入探讨更多高级特性： 1. **多线程**：Java提供的Thread类和Runnable接口，线程同步机制（synchronized关键字、wait/notify、Lock锁）以及并发工具类。 2. **网络编程**：套...
js构建二叉树进行数值数组的去重与优化详解
10-18
主要给大家介绍了关于js构建二叉树进行数值数组的去重与优化的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。
【经典算法题】二叉树的进阶
ai15013602354的博客
02-11 600
二叉树的算法题的总纲离不开递归，而其较难的题目往往递归较为复杂让人难以想到，本文带来几道经典的二叉树题目。来一场思维的旅行，享受算法的乐趣！
二叉树的进阶面试题
ZhuiZhuDream5的博客
04-10 310
package com.wschase.binarytree; import java.util.*; /**二叉树的进阶面试题 * Author:WSChase * Created:2019/4/10 */ class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) {...
算法入门到进阶——二叉树
m0_56145255的博客
03-19 757
文章目录基本概念二叉树的存储二叉树的性质二叉树的存储结构二叉树的遍历宽度优先遍历深度优先遍历先序遍历中序遍历后序遍历例题题目思路源码运行结果同理，已知中序和后序，输出先序源码运行结果 基本概念 树是非线性数据结构，它能很好的描述数据的层次关系。树形结构的现实场景很常见，例如，文件目录，书本的目录就是典型的树形结构。 二叉树是最常用的树形结构，特别适合程序设计，常常将一般的树转换成二叉树来处理。 二叉树的存储 二叉树的性质 二叉树的每个结点最多有两个子结点，分别是左孩子，右孩子，以它们为根的子树称为左子树和
python二叉树去重_python 二叉树
weixin_42322467的博客
02-03 151
from __future__ import annotationsclass TreeNode:def __init__(self, value, l_node: TreeNode = None, r_node: TreeNode = None):self.value = valueself.l_node = l_nodeself.r_node = r_nodedef get_value(sel...
构建二叉树进行数值数组的去重及优化
weixin_34072637的博客
02-15 522
构建二叉树进行数值数组的去重及优化 常见两层循环实现数组去重 let arr = [11, 12, 13, 9, 8, 7, 0, 1, 2, 2, 5, 7, 11, 11, 7, 6, 4, 5, 2, 2] let newArr = [] for (let i = 0; i < arr.length; i++) { l...
python二叉树去重_构建二叉树进行数值数组的去重及优化_console.log(([][[]]+[])[+!![]]+([]+{})[!+[]+!![]]) - SegmentFault 思否...
weixin_39523280的博客
12-21 195
构建二叉树进行数值数组的去重及优化常见两层循环实现数组去重let arr = [11, 12, 13, 9, 8, 7, 0, 1, 2, 2, 5, 7, 11, 11, 7, 6, 4, 5, 2, 2]let newArr = []for (let i = 0; i < arr.length; i++) {let unique = truefor (let j = 0; j < ...
树的理论知识
ZZcppc的博客
12-13 419
树的基础知识1.1 定义1.2 节点的度1.3 树的深度2.1 二叉树的定义2.2 二叉树的特点2.3 二叉树的性质2.4 特殊的二叉树2.4.1 满二叉树2.4.2 完全二叉树2.5.线索二叉树2.6.二叉搜索（排序）树2.5.1定义2.5.2 查找2.5.3 删除2.5.4 插入2.7 平衡二叉树（AVL树）2.7.1定义2.7.2特点2.8 红黑树2.9 多路查找树（B树） 1.1 定义 树（Tree）是n（n>=0)个结点的有限集。n=0时称为空树。 在任意一颗非空树中： 1）有且仅有一个特
基于二叉树和链表结构的文本重复序列去重算法
wangyan_HBU的博客
02-17 795
#include #include #include #include #include #include #include #include #include #define handle_error(msg)    do{perror(msg);exit(EXIT_FAILURE);}while(0) #define MAXSIZE

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值