一篇文带你搞懂搜索二叉树的原理和实现

最新推荐文章于 2023-03-17 20:40:57 发布
最新推荐文章于 2023-03-17 20:40:57 发布
阅读量935 收藏 9
点赞数 4
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m1059247324/article/details/106794872
版权

二叉搜索树

概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

在这里插入图片描述

1.二叉搜索树的查找
在这里插入图片描述

2.二叉树的插入

a. 树为空，则直接插入
在这里插入图片描述
b. 树不空，按二叉搜索树性质查找插入位置,插入新节点
在这里插入图片描述

3.二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

  • a. 要删除的结点无孩子结点
  • b. 要删除的结点只有左孩子结点
  • c. 要删除的结点只有右孩子结点
  • d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

  • 情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点
  • 情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点
  • 情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题
    在这里插入图片描述

4.二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述

5.以下就是二叉树的常见的两种用法

1.用来进行基础的查找，因为其特殊的性质，所以
查找的时间复杂度为 O(logN)，只有在极端情况下，二叉搜索树会变成单链表，此时时间复杂度为 O(N)，为了解决这个问题，又引入了新的AVL树，有兴趣的可以去了解。

#include<iostream>
#include<string>
using namespace std;

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;
	BSTreeNode(const K& key)
		:_key(key),_left(nullptr),_right(nullptr){}
};
template<class K>
class BSTree	
{
	typedef BSTreeNode<K> Node;
public:
	//递归插入的子函数
	bool _Insert(Node* root, Node* parent, const K key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		if (root)  //当 root 不为空就让 parent 等于 root
		{
			parent = root;
		}
		if (root == nullptr)
		{
			if (parent->_key < key)
			{
				root = new Node(key);
				parent->_right = root;
				return true;
			}
			else if (parent->_key > key)
			{
				root = new Node(key);
				parent->_left = root;
				return true;
			}
			else
			{
				return false;
			}
		}
		if (root->_key < key)  //key 大就插右边
		{
			return _Insert(root->_right, parent, key);
		}
		else if (root->_key > key)
		{
			return _Insert(root->_left, parent, key);
		}
		else
		{
			return false;
		}
	}
	//递归插入
	bool Insert(const K& key)
	{

		Node* parent = new Node(0);    //parent 的目的是为了保存 root 的上一个节点，并再 new 新节点时指向新节点
		return _Insert(_root, parent, key);
	}
	
	//非递归插入
	//bool Insert(const K& key)
	//{
	//	if (_root == nullptr)
	//	{
	//		_root = new Node(key);
	//		return true;
	//	}
	//	Node* parent = _root;
	//	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)   //key大就插右边
	//	{
	//		parent->_right = cur;
	//	}
	//	else
	//	{
	//		parent->_left = cur;
	//	}
	//	return true;
	//}

	//寻找给被删除节点所替换的节点
	Node*& _FindNode(Node* root,int flag)  //flag 给0 找左子树最大，给 1 找右子树最小
	{
		if (flag == 0)
		{
			if (root == nullptr || root->_right == nullptr)
				return root;
			return _FindNode(root->_right,0);
		}
		else
		{
			if (root == nullptr || root->_left == nullptr)
				return root;
			return _FindNode(root->_left, 1);
		}
	}
	//递归删除的子函数
	bool _erase(Node* root, Node* parent,const K key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			if (root->_right != nullptr)
				parent = root;
			_erase(root->_right, parent, key);
		}
		else if(root->_key > key)
		{
			if (root->_left != nullptr)
				parent = root;
			_erase(root->_left, parent, key);
		}
		else  //等于
		{
			if (root->_left == nullptr && root->_right == nullptr)   //当没有子叶子，就直接删除
			{
				if (parent->_left == root)  //当父亲的左子树是root
				{
					delete root;
					parent->_left = nullptr;
					return true;
				}
				else if (parent->_right == root)  //当父亲的右子树是root
				{
					delete root;
					parent->_right = nullptr;
					return true;
				}
				else   //此时说明删除的是根节点，确定没有子树所以直接删除
				{
					_root = nullptr;
					return true;
				}
			}
			else if (root->_left != nullptr && root->_right == nullptr)  //没有右子树
			{
				if (parent->_left == root)
				{
					parent->_left = root->_left;
					delete root;
					return true;
				}
				else if(parent->_right == root)
				{
					parent->_right = root->_left;
					delete root;
					return true;
				}
				else  //此时要删除的是根节点，它没有右子树
				{
					_root = root->_left;   //让_root 指向根的左子树
					root = nullptr;    //再把root置空
					return true;
				}
			}
			else if (root->_right != nullptr && root->_left == nullptr)  //没有左子树
			{
				if (parent->_left == root)
				{
					parent->_left = root->_right;
					delete root;
					return true;
				}
				else if(parent->_right == root)
				{
					parent->_right = root->_right;
					delete root;
					return true;
				}
				else  //此时要删除的是根节点，它没有左子树
				{  
					_root = root->_right;    
					root = nullptr;
					return true;
				}
			}
			else //左右叶子都有,就找它左子树的最大节点或者它右子树的最小节点并记录该节点值,然后先删除该节点
			{     //再把值赋给要删除点
				//这里我找右子树的最小节点进行交换
				Node* tmp = root;
				tmp = _FindNode(root->_right, 1);
				int ret = tmp->_key;
				_erase(root, parent, tmp->_key);
				root->_key = ret;
			}
		}
	}
	//递归删除
	bool erase(const K& key)
	{
		Node* parent = new Node(0);
		return _erase(_root, parent,key);
	}

	//非递归删除
	//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
	//		{
	//			// 找到了，开始删除
	//			// 1、左为空
	//			// 2、右为空
	//			// 3、左右都不为空
	//			if (cur->_left == nullptr && cur->_right != nullptr)
	//			{
	//				if (cur == _root)
	//				{
	//					_root = cur->_right;
	//				}
	//				else
	//				{
	//					if (parent->_right == cur)
	//						parent->_right = cur->_right;
	//					else
	//						parent->_left = cur->_right;
	//				}
	//				delete cur;
	//			}
	//			else if (cur->_right == nullptr && cur->_left != nullptr)
	//			{
	//				if (cur == _root)
	//				{
	//					_root = cur->_left;
	//				}
	//				else
	//				{
	//					if (parent->_left == cur)
	//						parent->_left = cur->_left;
	//					else
	//						parent->_right = cur->_left;
	//				}

	//				delete cur;
	//			}
	//			else
	//			{
	//				// 修改
	//				Node* rightMinParent = cur;
	//				Node* rightMin = cur->_right;
	//				while (rightMin->_left)
	//				{
	//					rightMinParent = rightMin;
	//					rightMin = rightMin->_left;
	//				}
	//				// 替代删除
	//				cur->_key = rightMin->_key;
	//				// 转换成删除rightMin(rightMin是左为空，父亲指向他的右)
	//				if (rightMin == rightMinParent->_left)
	//					rightMinParent->_left = rightMin->_right;
	//				else
	//					rightMinParent->_right = rightMin->_right;

	//				delete rightMin;
	//			}
	//			return true;
	//		}
	//	}
	//	return false;
	//}
	//递归查找的子函数
	bool _find(Node* root, const K key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _find(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _find(root->_left, key);
		}
		else
			return true;	
	}
	//递归查找
	bool find(const K& key)
	{
		Node* parent = new Node(0);
		return _find(_root, key);
	}

	//中序输出的子函数
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		else
		{
			_Inorder(root->_left);
			cout << root->_key << " ";
			_Inorder(root->_right);
		}
	}
	//中序输出
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};
int main()
{
	BSTree<int> bs;
	int a[] = { 5,3,7,1,4,6,8,0,2,9 };
	for (auto e : a)
		bs.Insert(e);
	for (auto e : a)
	{
		cout << "删除 " << e << endl;
		bs.erase(e);
		bs.Inorder();
	}
}

2.用来作为字典记录某一个事物出现的次数 (没有该物种就添加，有就 +1 记载它出现的次数)

#include<iostream>
#include<string>
using namespace std;
template<class K,class T>
struct BSTreeNode
{
	BSTreeNode<K,T>* _left;
	BSTreeNode<K,T>* _right;
	K _key;
	T _val;
	BSTreeNode(const K& key = " ",const T& val = 0)
		:_key(key), _val(val),_left(nullptr), _right(nullptr) {}
};
template<class K, class T>
class BSTree
{
	typedef BSTreeNode<K,T> Node;
public:
	//递归插入的子函数
	bool _Insert(Node* root, Node* parent, const K key, const T val)
	{
		if (_root == nullptr)
		{
			_root = new Node(key,val);
			return true;
		}
		if (root)  //当 root 不为空就让 parent 等于 root
		{
			parent = root;
		}
		if (root == nullptr)
		{
			if (parent->_key < key)
			{
				root = new Node(key,val);
				parent->_right = root;
				return true;
			}
			else if (parent->_key > key)
			{
				root = new Node(key,val);
				parent->_left = root;
				return true;
			}
			else
			{
				return false;
			}
		}
		if (root->_key < key)  //key 大就插右边
		{
			return _Insert(root->_right, parent, key,val);
		}
		else if (root->_key > key)
		{
			 return _Insert(root->_left, parent, key,val);
		}
		else
		{
			return false;
		}
	}
	//递归插入
	bool Insert(const K& key, const T& val)
	{

		Node* parent = new Node();    //parent 的目的是为了保存 root 的上一个节点，并再 new 新节点时指向新节点
		return _Insert(_root, parent, key,val);
	}

	//非递归插入
	//bool Insert(const K& key)
	//{
	//	if (_root == nullptr)
	//	{
	//		_root = new Node(key);
	//		return true;
	//	}
	//	Node* parent = _root;
	//	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)   //key大就插右边
	//	{
	//		parent->_right = cur;
	//	}
	//	else
	//	{
	//		parent->_left = cur;
	//	}
	//	return true;
	//}

	//寻找给被删除节点所替换的节点
	Node*& _FindNode(Node* root, int flag)  //flag 给0 找左子树最大，给 1 找右子树最小
	{
		if (flag == 0)
		{
			if (root == nullptr || root->_right == nullptr)
				return root;
			return _FindNode(root->_right, 0);
		}
		else
		{
			if (root == nullptr || root->_left == nullptr)
				return root;
			return _FindNode(root->_left, 1);
		}
	}
	//递归删除的子函数
	bool _erase(Node* root, Node* parent, const K key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			if (root->_right != nullptr)
				parent = root;
			_erase(root->_right, parent, key);
		}
		else if (root->_key > key)
		{
			if (root->_left != nullptr)
				parent = root;
			_erase(root->_left, parent, key);
		}
		else  //等于
		{
			if (root->_left == nullptr && root->_right == nullptr)   //当没有子树，就直接删除
			{
				if (parent->_left == root)  //当父亲的左子树是root
				{
					delete root;
					parent->_left = nullptr;
					return true;
				}
				else if (parent->_right == root)  //当父亲的右子树是root
				{
					delete root;
					parent->_right = nullptr;
					return true;
				}
				else  //到这里说明是根节点，因为确定没有子树，所以直接删除
				{
					_root = nullptr;
					return true;
				}
			}
			else if (root->_left != nullptr && root->_right == nullptr)  //没有右子树
			{
				if (parent->_left == root)   
				{
					parent->_left = root->_left;
					delete root;
					return true;
				}
				else if (parent->_right == root)
				{
					parent->_right = root->_left;
					delete root;
					return true;
				}
				else      //到这说明要删除节点就是根节点，没有右叶子，所以要判断
				{
					_root = root->_left;
					root = nullptr;
					return true;
				}
			}
			else if (root->_right != nullptr && root->_left == nullptr)  //没有左叶子
			{
				if (parent->_left == root)
				{
					parent->_left = root->_right;
					delete root;
					return true;
				}
				else if (parent->_right == root)
				{
					parent->_right = root->_right;
					delete root;
					return true;
				}
				else  // 到这说明要删除节点就是根节点，没有左叶子，所以要判断
				{
					_root = root->_right;
					root = nullptr;
					return true;
				}
			}
			else //左右叶子都有,就找它左子树的最大节点或者它右子树的最小节点并记录该节点值,然后先删除该节点
			{     //再把值赋给要删除点
				//这里我找右子树的最小节点进行交换
				Node* tmp = root;
				tmp = _FindNode(root->_right, 1);
				K ret = tmp->_key;
				T s1 = tmp->_val;
				_erase(root, parent, tmp->_key);
				root->_key = ret;
				root->_val = s1;
			}
		}
	}
	//递归删除
	bool erase(const K& key)
	{
		Node* parent = new Node();
		return _erase(_root, parent, key);
	}

	//非递归删除
	//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
	//		{
	//			// 找到了，开始删除
	//			// 1、左为空
	//			// 2、右为空
	//			// 3、左右都不为空
	//			if (cur->_left == nullptr && cur->_right != nullptr) 
	//			{
	//				if (cur == _root)
	//				{
	//					_root = cur->_right;
	//				}
	//				else
	//				{
	//					if (parent->_right == cur)
	//						parent->_right = cur->_right;
	//					else
	//						parent->_left = cur->_right;
	//				}
	//				delete cur;
	//			}
	//			else if (cur->_right == nullptr && cur->_left != nullptr)
	//			{
	//				if (cur == _root)
	//				{
	//					_root = cur->_left;
	//				}
	//				else
	//				{
	//					if (parent->_left == cur)
	//						parent->_left = cur->_left;
	//					else
	//						parent->_right = cur->_left;
	//				}

	//				delete cur;
	//			}
	//			else
	//			{
	//				// 修改
	//				Node* rightMinParent = cur;
	//				Node* rightMin = cur->_right;
	//				while (rightMin->_left)
	//				{
	//					rightMinParent = rightMin;
	//					rightMin = rightMin->_left;
	//				}
	//				// 替代删除
	//				cur->_key = rightMin->_key;
	//				// 转换成删除rightMin(rightMin是左为空，父亲指向他的右)
	//				if (rightMin == rightMinParent->_left)
	//					rightMinParent->_left = rightMin->_right;
	//				else
	//					rightMinParent->_right = rightMin->_right;

	//				delete rightMin;
	//			}
	//			return true;
	//		}
	//	}
	//	return false;
	//}

	//递归查找的子函数
	Node* _find(Node* root, const K key)
	{
		if (root == nullptr)
			return nullptr;
		if (root->_key < key)
		{
			return _find(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _find(root->_left, key);
		}
		else
			return root;
	}
	//递归查找
	Node* find(const K& key)
	{
		return _find(_root, key);
	}    
    //非递归查找
	//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;
	//}

	//中序输出的子函数
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		else
		{
			_Inorder(root->_left);
			cout << root->_key << "-" << root->_val << " ";
			_Inorder(root->_right);
		}
	}
	//中序输出
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};
int main()
{
	BSTree<string,int> bs;
	string strArr[] = { "西瓜", "苹果", "西瓜", "苹果", "蓝莓", "香蕉", "西瓜", "樱桃", "西瓜", "西瓜" ,"蓝莓","黄桃"};
	for (auto e : strArr)
	{
		BSTreeNode<string, int>* tmp = bs.find(e);
		if (tmp == nullptr)
		{
			bs.Insert(e, 1);
		}
		else
		{
			tmp->_val++;
		}
	}
	//bs.Inorder();
	//for (auto e : strArr)
	//{
	//	cout << "删除 " << e << endl;
	//	bs.erase(e);
	//	bs.Inorder();
	//}
}
、山有木兮木有枝
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
二叉查找树的原理及实现
qq_39747794的博客
11-01 1169
前言 学习了一些数据结构之后，你是不是已经有些小得意了，以为数据结构就这点东西嘛，不就用好栈、队列什么什么的就好，呵呵，那些只是皮毛。接下来的东西才会让你真正认识到数据结构的博大精深，当你看到接下来那些酷炫狂赛的操作时，你会惊叹于数据结构的神奇。在学习那些酷炫的AVL树，红黑树之前，我们先入个门，学习最简单的动态查找表——二叉查找树。 二叉查找树 二叉查找树有被称为二叉排序树，它要么是个空树...
二叉查找树原理理解
angrypop的博客
08-24 1234
二叉查找树原理理解 1.问题的提出 查找数组中第k小的数，且要求m次动态更新。 很容易想到每插入一个数就排序一遍，时间效率O(mnlogn） 注意到每次只插入一个数，排序造成了极大的时间浪费。 为了解决问题，使用二叉查找树Binary Search Tree。 2.原理 二叉查找树要满足如下性质： 1.是二叉树 2.每个节点的左子节点（如有）都比其小，右子节点（如有）...
二叉查找树实现原理分析
aikuangchou2298的博客
04-08 195
引言 二叉查找树是一种能将链表插入的灵活性和有序数组查找的高效性结合起来的一种重要的数据结构，它是我们后面学习红黑树和AVL树的基础，本文我们就先来看一下二叉查找树的实现原理。 二叉查找树的定义 二叉查找树最重要的一个特征就是：每个结点都含有一个Comparable的键及其相关联的值，该结点的键要大于左子树中所有结点的键，而小于右子树中所有结点的键。 下图就是一个典型的二叉查找...
二叉搜索树原理
牛牛码特的博客
06-20 150
二叉搜索树（BST）又称二叉查找树或二叉排序树。一棵二叉搜索树是以二叉树来组织的，可以使用一个链表数据结构来表示，其中每一个结点就是一个对象。一般地，除了key和卫星数据之外，每个结点还包含属性lchild、rchild和parent，分别指向结点的左孩子、右孩子和双亲（父结点）。如果某个孩子结点或父结点不存在，则相应属性的值为空（NIL）。根结点是树中唯一父指针为NIL的结点，而叶子结点的孩子结点指针也为NIL。 ...
二叉搜索树的性质
u010005161的博客
05-28 2119
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树） 它或者是一棵空树，或者是具有下列性质的二叉树：  1. 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；  2. 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；  3. 它的左、右子树也分别为二叉排序树。 因此，若对它进行中序遍历，则是一颗递增的排好序的序列！ 这一点
C语言实现二叉树的搜索及相关算法示例
08-30
C语言实现二叉树的搜索及相关算法示例 本文主要介绍了C语言实现二叉树的搜索及相关...本文介绍了C语言实现二叉树的搜索及相关算法，包括二叉树的搜索、插入、遍历、节点前驱和后继等算法，并提供了相应的C语言代码。
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
二叉树的实现
08-25
1）创建一棵二叉树，并对其初始化； 2）先根、中根、后根遍历二叉树(递归算法)； 3）在二叉树中搜索给定结点的父结点； 4）搜索二叉树中符合数据域条件的结点； 5）从二叉树中删除给定结点及其左右子树。
C语言二叉树的三种遍历方式的实现及原理
12-31
二叉树遍历分为三种：前序、中序、后序，其中序遍历最为重要。为啥叫这个名字？是根据根节点的顺序命名的。 ...下面介绍一下，二叉树的三种遍历方式，其中每一种遍历方式都有三种实现方式。 节点定
哈夫曼树和线索二叉树的实现
11-19
线索二叉树的实现主要通过将哈夫曼树转换成一个线索二叉树，每个结点包含一个指向左孩子和右孩子的指针。我们可以使用一个循环来将哈夫曼树转换成线索二叉树，并更新每个结点的字段。 在测试结果中，我们可以看到...
二叉搜索树的原理及其实现
画船听雨眠
10-26 645
二叉搜索树的原理及其实现 代码 #include <iostream> #include <vector> #include <algorithm> #include <queue> using namespace std; struct poi { int val; poi *l, *r; poi() {} poi(int ...
二叉搜索树的基本实现原理
最新发布
a7897989的博客
03-17 189
二叉搜索树，从名字就可以猜出的作用，对的，就是用来搜索，二叉搜索树在查找数据方面是极其强大的，其时间复杂度度为 logN, 即从十亿个数中查找一个树只需要找 10 次，速度可见有多快。情况4：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点。情况2：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除。情况3：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除。若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
二叉树的性质及二叉查找树的实现
全村最靓的仔
08-31 394
二叉树的性质 树中的结点数等于数的边数加1，也等于所有的度数之和加1(此性质适合所有的树) 在二叉树的第i层上最多有2i2^i2i个结点，其中i从第0层开始 高度为h的二叉树至多有2h+1−12^{h+1}-12h+1−1个结点 对于任意一棵二叉树T，如果其终端节点数为n0，度为2的结点数为n2，则n0 = n2 + 1 (可以使用性质1来推导，n = n0 + n2 + n1 , n = ...
索引-二叉树原理
hyy
12-11 414
二叉树原理 查找快，没有索引左边那样从头往下查。二叉树是放了第一个位置的数，进来第二个和第一个作比较，比第一个小放到左下边例如5，大放到右下边例如77.以此类推。 ...
二叉树原理
mk_csdn的博客
03-16 233
class Btree:    def __init__(self, value):        self.left = None        self.data = value        self.right = None    def insertLeft(self, value):        self.left = Btree(value)        return self....
二叉搜索树
m0_53421868的博客
12-20 3679
二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 插入 //增删查改 bool insert(const T& val) { Node* node = new Node(val); if (!_root) { _root = node; } else { Node*.
树结构(一) - 二叉树查找树的原理与实现
I_will_try的博客
12-20 553
原文：http://blog.csdn.net/leicool_518/article/details/42491273 一、二叉树查找树的原理 二叉查找树(Binary Search Tree)，它是特殊的二叉树：对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] = key[x]。那么，这
二叉搜索树的原理和实现
Meliorem的博客
11-20 873
什么是二叉搜索树二叉搜索树是一种特殊的二叉树，它是被广泛运用的存储查找结构------完全平衡二叉树（AVLtree） 和红黑树的基础（RBtree） 二叉搜索树的规则： 二叉搜索树可以是一棵空树 如果其节点的左子树不空 则其左子树上的所有节点的值小于根节点的值 如果其节点的右子树不空 则其右子树上的所有节点的值小于根节点的值 每个节点的左右子树都是二叉搜索树 为什么要设计出这种规则的二叉搜索树呢？
"PHP实现绘制二叉树图形显示功能详解：包括二叉搜索树、平衡树和红黑树实例
++来实现的，但是我想用PHP来实现，因为我对PHP比较熟悉。于是我开始研究如何在PHP中实现绘制...这一功能对于理解和调试二叉树结构非常有帮助，希望大家可以从中受益，也欢迎大家进一步探讨和优化实现方式。感谢阅读！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值