15.二叉树进阶（二叉搜索树的模拟实现和二叉搜索树的应用）

最新推荐文章于 2024-05-31 21:13:08 发布
最新推荐文章于 2024-05-31 21:13:08 发布
阅读量404 收藏 5
点赞数 9
分类专栏： c++ 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Q2691463021/article/details/137969589
版权

1.二叉搜索树

1.1 二叉搜索树概念

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

二叉搜索树：一颗二叉树，可以为空；如果不为空，满足以下性质：
1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
3.它的左右子树也分别为二叉搜索树

  • 如下图所示：

image-20230306170406611

2. 二叉搜索树的实现

2.1 节点的类模板

// 节点的数据类型为K
template<class K>
struct BSTreeNode
{
    // 左子树根节点的地址
	BSTreeNode<K>* _left;
    // 右子树根节点的地址
	BSTreeNode<K>* _right;
	K _key;

    // 节点的构造函数
	BSTreeNode(const K& key)
		:_key(key)        // 节点存放的值为key
		,_left(nullptr)
		,_right(nullptr)
	{}
};

2.2 insert(插入的实现)

image-20230306182004857

bool Insert(const K& key)
	{
    	// 当树为空时
    	// 直接创建一个新节点来存放这个值
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

    	// 当树不为空时
    	// 将父节点的地址初始化为空，将cur节点的地址初始化为整棵树根节点的地址
		Node* parent = nullptr;
		Node* cur = _root;
    
    	// 当cur为空时，则说明找到了要插入的元素对应的位置
		while (cur)
		{
            // 如果要插入的值key大于当前节点的key，那么往右子树迭代
            // 如果要插入的值key小于当前节点的key，那么往左子树迭代
            // 如果插入的元素key与当前节点cur->_key的值相等，那么返回false(二叉搜索树不允许插入相同的元素)
			if (cur->_key < key)
			{
                // 对父节点和当前节点进行迭代
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
                // 对父节点和当前节点进行迭代
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

    	// 此时，parent指向cur，cur就是要插入元素的位置
    	// 所以我们new一个新的节点，将新节点的地址赋值给cur
		cur = new Node(key);
		if (parent->_key < key)
		{
            // 当我们插入的元素key大于parent->_key时，
            // parent->_right的位置就是cur的位置
			parent->_right = cur;
		}
		else
		{
            // 当我们插入的元素key小于parent->_key时，
            // parent->_left的位置就是cur的位置
			parent->_left = cur;
		}

		return true;
	}

2.3 InOrder(中序遍历)

为了可以访问根节点我们内置了一个中序遍历_InOrder，这样我们就可以访问类的私有成员变量_root，调用时直接调用InOrder就可以了

void InOrder()
{
    _InOrder(_root);
    cout << endl;
}

private:
// 将内置的中序遍历封装成私有的成员函数，这样用户就不能够访问到了
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

        // 中序遍历就是先访问左子树，打印根节点，在访问右子树
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

2.4 Find(查找key,找到返回值为真)

bool Find(const K& key)
{
    // 将当前节点初始化为整颗二叉搜索树的根节点
	Node* cur = _root;
    
    // 如果当前节点为空，说明当前的二叉搜索树没有我们想找的节点
	while (cur)
	{
		if (cur->_key < key)
		{
            // 查找的元素key 大于 cur->_key，就往右子树移动
            
            // 迭代
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
            // 查找的元素key 小于 cur->_key，就往左子树移动
            
            // 迭代
			cur = cur->_left;
		}
		else
		{
            // 查找的元素key 等于 cur->_key，那么就是找到了
			return true;
		}
	}

    // 运行到此处，说明二叉搜索树中没有这个元素
	return false;
}

2.5 Erase(删除)

情况1和情况2：

image-20230307202102399

情况3：

image-20230307203619453

bool Erase(const K& key)
{
    // 将父节点初始化为空，将cur节点初始化为整棵树的根节点
	Node* parent = nullptr;
	Node* cur = _root;
    
    
    // 想要删除元素key，那么首先要找到元素key
    // 寻找的方法和Find()函数的方法是一样的
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
            // 代码运行到这里，说明我们已经找到了元素key,对应的节点为cur
            // 删除元素key，又分为三种情况：
			// 1、cur的左为空
			// 2、cur的右为空
			// 3、cur的左右都不为空，替换删除
            
			if (cur->_left == nullptr)
			{
                // 情况1：cur的左子树为空
                // 情况1又分为两个case
                
                // 情况1：case1：
                // 此处判断 parent == nullptr或者cur == _root 都是可以的
				// if (parent == nullptr)
				if (cur == _root)
				{
                    // case1: 当我们需要删除的节点cur为根节点_root时
                    // 此时，已知cur的左子树为空
                    // 因此cur->_right就是新的根节点
                    // 这样就链接完成了
					_root = cur->_right;
				}
				else
				{ 
                    // 情况1：case2：
					if (parent->_left == cur)
					{
                        // case2_1：当我们需要删除的cur是父节点的左子树的根节点
                        // 此时已知cur的左子树为空，
                        // 因此cur的右子树的根节点(cur->_right),需要代替cur节点连接到父节点的左子树上
						parent->_left = cur->_right;
					}
					else
					{
                        // case2_2：当我们需要删除的cur是父节点的右子树根节点
                        // 此时已知cur的左子树根节点为空，
                        // 因此cur的右子树的根节点(cur->_right),需要代替cur节点连接到父节点的右子树上
						parent->_right = cur->_right;
					}
				}

                // 链接完成之后，cur就可以被释放了
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
                // 情况2：cur的右子树为空
                // 情况2由分为两个case
                // 具体的分析方法参考情况1
                
				//if (parent == nullptr)
				if (cur == _root)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}

				delete cur;
			}
			else
			{
                // 情况3：cur的左右子树都不为空
                // 此时我们需要使用替换删除
                // 替换也就是找cur左子树的最大节点 
                // 或者 右子树的最小节点来替换cur->_key 都可以
                
				// 我们采用找右子树的最小节点替换删除的方式
                // 1.找cur右子树，key值最小的节点
                
                // 将parent节点初始化为cur的地址，是为了防止cur->right就是key值最小节点
                // 注：如果cur->right就是最小节点，则minRight->_left为空，那么就无法进入循环
                // 那么如果将parent初始化为空，那么删除cur节点后，cur->right无法连接到cur的父节点
                // 因此parent初始化为空，且没有进入循环进行更新
				Node* parent = cur;
                
                // 2.将minRight初始化为cur右子树的根节点
				Node* minRight = cur->_right;
				while (minRight->_left)
				{
                    // 3.找cur右子树的key值最小节点，根据二叉搜索树的性质
                    // 我们只需要找根节点的左子树，直到minRight->left为空
                    // 此时minRight就是cur右子树的最小节点
					parent = minRight;
					minRight = minRight->_left;
				}

                // 将cur->_key 替换为最小节点的key值 minRight->_key
				cur->_key = minRight->_key;
                
                // 此时再干掉cur右子树key值最小节点就可以了
                // 代码运行到这里我们已经知道了minRight->left为空
                // （上述循环minRight->left迭代到空，才可以找到cur右子树的key值最小节点）
				if (minRight == parent->_left)
				{
                    // 如果minRight节点是parent的左子树
                    // 那么如果要干掉minRight，我们还需要将minRight遗留的右子树交给父节点parent的左子树
					parent->_left = minRight->_right;
				}
				else
				{
                    // 如果minRight是parent的右子树
                    // 那么如果要干掉minRight，我们还需要将minRight遗留的右子树交给父节点parent的右子树
					parent->_right = minRight->_right;
				}
                
                // 此时我们就可以干掉MinRight了
				delete minRight;
			}

			return true;
		}
	}

    // 代码运行到这里，说明cur为空，也没有找到我们要删除的节点
	return false;
}

2.6 FindR(使用递归的方式进行查找)

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

private:
	// 私有成员函数
	bool _FindR(Node* root, const K& key)
	{
        // 当根节点迭代到空，说明当前整棵树已经遍历完了，那么返回flase
		if (root == nullptr)
			return false;
	
        // 如果root->_key < key，说明key所在的节点在root的右子树
		if (root->_key < key)
			return _FindR(root->_right, key);
        // 如果root->_key > key，说明key所在的节点在root的左子树
		else if (root->_key > key)
			return _FindR(root->_left, key);
		else
            // 此时，找到了key值对应的节点
			return true;
	}

2.7 insertR(使用递归的方式)

// recursion n.递归
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

private:
	bool _InsertR(Node*& root, const K& key)  
	{
        // 3.最后迭代到root为空
		if (root == nullptr)
		{
            // 1.当root为空时
            // root如果是整棵树的根节点，root为空，那么直接将新节点的地址给root，这个新节点就是新的root节点
            // root如果是某个节点的地址
            // 假设root是pos位置节点的引用，pos的父节点是parent，pos是父节点的右子树的根节点，
            // 那么直接将新节点的地址给root，这个新节点父节点的右子树的根节点
			root = new Node(key);
			return true;
		}

        
        // 2.当root不为空时
        // 如果root->_key < key，说明key要插入的位置在root的右子树
		if (root->_key < key)
			return _InsertR(root->_right, key);
        // 如果root->_key > key，说明key要插入的位置在root的左子树
		else if (root->_key > key)
			return _InsertR(root->_left, key);
		else
            // 运行到这里说明key值与搜索二叉树中的值重复了，二叉搜索树不允许插入重复的值，因此返回false
			return false;
	}

2.8 EraseR（使用递归的方式进行删除）

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

private:
	bool _EraseR(Node*& root, const K& key)
	{
        // 当迭代到root为空，说明没有找到我们需要删除的key值，所以返回false
		if (root == nullptr)
		{
			return false;
		}

        // 如果root->_key < key，说明删除的key的位置在root的右子树
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
        // 如果root->_key > key，说明删除的key的位置在root的左子树
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
            // 代码运行到这里说明我们已经定位到了我们要删除的节点了
            // 此时root就是我们要删除的节点
            // 在删除root节点之前，需要将root的父亲节点，与root的后续节点进行连接
            // 将root交给del，将root后面的节点连接之后
            // 就可以删掉del节点了
			Node* del = root;
            
            
            
            // 情况1：当root的右子树为空时
			if (root->_right == nullptr)
			{
                // 此时root为要删除的节点，已知右子树为空
                // 所以用root的左子树的根节点覆盖root
                // 因为使用的是传引用的方式，修改root的地址，就是修改root父亲节点的指向
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
                // 情况2：
                // 要删除节点的左子树为空
				root = root->_right;
			}
			else
			{
                // 情况3：要删除节点的左右子树都不空
                // 我们需要采用替换删除的方法
                // 此时root就是我们需要删除的节点
                // 第一步：我们先去找需要删除节点的右子树的最小节点
				Node* minRight = root->_right;
                
                // 根据搜索二叉树的性质，在根节点的左子树找二叉树key值最小的节点
                // 当minRight->_left为空时，迭代结束，并且找到了key最小的minRight节点
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}

                //此时，已经找到了右子树的最小节点，将它的key元素与root节点的key值进行交换
				swap(root->_key, minRight->_key);

                // 将root节点的key值与minRight的key值进行交换之后，
                // 那么需要删除的节点就是minRight（minRight是右子树的最小节点）
                // 迭代，直到满足情况1或者情况2，迭代结束
				return _EraseR(root->_right, key);
			}

            // 对于情况1和情况2，是释放del节点
			delete del;
			return true;
		}
	}

2.9 构造函数

BSTree()
	:_root(nullptr)
{}

2.10 析构函数

~BSTree()
{
    // 销毁_root节点
	Destroy(_root);
    // 将根节点置空，防止野指针
	_root = nullptr;
}

private:
	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;

        // 递归销毁根节点的左子树和右子树
		Destroy(root->_left);
		Destroy(root->_right);
        
        // 销毁当前节点
		delete root;
	}

2.11 拷贝构造

	BSTree(const BSTree<K>& t)
	{
		_root = Copy(t._root);
	}

private:
	Node* Copy(Node* root)
	{
        // 当root为空，则不会继续向下迭代拷贝
		if (root == nullptr)
			return nullptr;

        // 创建一个根节点（用根节点的key值进行初始化），给新二叉树的根节点
		Node* newRoot = new Node(root->_key);
        // 向左子树进行迭代，返回左子树根节点的地址，给到newRoot->_left
		newRoot->_left = Copy(root->_left);
        // 向右子树进行迭代，返回右子树根节点的地址，给到newRoot->_right
		newRoot->_right = Copy(root->_right);

        // 返回新的二叉树根节点的地址
		return newRoot;
	}

2.12 赋值重载

BSTree<K>& operator=(BSTree<K> t)
{
    // 交换根节点的地址
    // 注：t对象的二叉树只是一个临时对象（不是传引用对象）
	swap(_root, t._root);
    
    // 返回二叉树对象
	return *this;
}

二叉搜索树的类模板的完整实现

namespace qwy
{
    // 二叉树节点的类模板
	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
	{
        // 将二叉类模板类型定义为 Node
		typedef BSTreeNode<K> Node;
	public:
        // 构造函数
		BSTree()
			:_root(nullptr)
		{}

		// 拷贝构造函数
		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t._root);
		}

        // 运算符重载函数
        BSTree<K>& operator=(BSTree<K> t)
        {
            swap(_root, t._root);
            return *this;
        }

        // 析构函数
		~BSTree()
		{
			Destroy(_root);
			_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
				{
					// 1、左为空
					// 2、右为空
					// 3、左右都不为空，替换删除
					if (cur->_left == nullptr)
					{
						//if (parent == nullptr)
						if (cur == _root)
						{
							_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)
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
					}
					else
					{
						// 右子树的最小节点
						Node* parent = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							parent = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;
						if (minRight == parent->_left)
						{
							parent->_left = minRight->_right;
						}
						else
						{
							parent->_right = minRight->_right;
						}
						delete minRight;
					}

					return true;
				}
			}

			return false;
		}

        // 中序遍历
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

        // 插入（使用递归的方式）
		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}

        // 查找（使用递归的方式）
		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}

        // 删除（使用递归的方式）
		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

	private:
        // 析构函数内部调用这个函数
		void Destroy(Node* root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
		}

        // 拷贝构造函数内部调用这个函数
        Node* Copy(Node* root)
        {
            if (root == nullptr)
                return nullptr;

            Node* newRoot = new Node(root->_key);
            newRoot->_left = Copy(root->_left);
            newRoot->_right = Copy(root->_right);

            return newRoot;
        }

        // Erase内部调用这个函数
		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->_right == nullptr)
				{
					root = root->_left;
				}
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else
				{
					Node* minRight = root->_right;
					while (minRight->_left)
					{
						minRight = minRight->_left;
					}

					swap(root->_key, minRight->_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;
		}

		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key < key)
				return _FindR(root->_right, key);
			else if (root->_key > key)
				return _FindR(root->_left, key);
			else
				return true;
		}

		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};
}

3.测试我们实现的二叉搜索树

3.1 测试中序遍历

void TestBSTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	BSTree<int> t;
	for (auto e : a)
	{
		t.Insert(e);
	}

	t.InOrder();
}

4.二叉搜索树的应用

4.1 KV模型

// 根据二叉搜索树改造的KV模型
namespace KV
{
    // 二叉树节点的类模板
	template<class K, class V>
	struct BSTreeNode
	{
        // 指向左子树
		BSTreeNode<K, V>* _left;
        // 指向右子树
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;

        // 构造函数
        // 需要传入key值，和value值
		BSTreeNode(const K& key, const V& value)
			:_key(key)
			,_value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

    // 二叉树的类模板
	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
        // 插入
		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就是新节点要插入的位置
			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;
		}

        // 中序遍历
		void Inorder()
		{
			_Inorder(_root);
		}

		void _Inorder(Node* root)
		{
			if (root == nullptr)
				return;

			_Inorder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_Inorder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}

应用场景一：

/*
	英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
*/

void TestBSTree2()
{
    // 创建一个二叉树对象
	KV::BSTree<string, string> dict;
    
    // 插入KV值
	dict.Insert("sort", "排序");
	dict.Insert("string", "字符串");
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");

	string str;
	while (cin>>str)
	{
        // 进行查找
        // Node* Find(const K& key),返回key所在节点的地址，如果没有找到，则返回空
		KV::BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret)
		{
			cout << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

应用情景二：

/*
	如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
*/

void TestBSTree3()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "香蕉", "草莓","苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

    // 创建一个二叉树对象
	KV::BSTree<string, int> countTree;
	for (auto e : arr)
	{
 		 // 先查找水果在不在搜索树中
		 // 1、不在，说明水果第一次出现，则插入<水果, 1>
		 // 2、在，则查找到的节点中水果对应的次数++
		auto* ret = countTree.Find(e);
		if (ret == nullptr)
		{
			countTree.Insert(e, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.Inorder();
}

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

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

image-20230309170827918

  • 最优情况下:二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log_2 N
  • 最差情况下:二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：frac{N}{2}
  • 问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？后续章节的AVL树和红黑树再来解释
the_nov
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
用c语言编写的数据结构相关的二叉树的二叉搜索
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
BST.rar_二叉搜索树
09-14
二叉树相关代码，包括树的插入，搜索，平衡等相关操作
C语言判定一棵二叉树是否为二叉搜索树的方法分析
12-31
首先说明一下二叉树和二叉搜索树的区别。二叉树指这样的树结构，它的每个结点的孩子数目最多为2个；二叉搜索树是一种二叉树，但是它有附加的一些约束条件，这些约束条件必须对每个结点都成立： 结点node的左子树...
Python实现二叉搜索树BST的方法示例
01-20
二叉排序树（BST）又称二叉查找树、二叉搜索树 二叉排序树(Binary Sort Tree)又称二叉查找树。它或者是一棵空树；或者是具有下列性质的二叉树： 1.若左子树不空，则左子树上所有结点的值均小于根结点的值； 2.若...
Leecode---347：输出前k个高频元素（使用unordered_map）
qq_41920323的博客
05-30 251
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 331
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 462
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 592
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
并查集拓展（扩展域并查集）
Qlarkstar的博客
05-29 915
事实证明，扩展域并查集应该在带权并查集前面讲的，因为比较好理解，而且回过头看带权并查集可能也会更轻松一些。
24.5.26（树链剖分板子，二分+线段树）
breath_of_yuan的博客
05-27 847
思路：可看出峰值的数量是固定的，为 n/2-1，头尾不可为峰，连续俩数不能都为峰，假如我们让奇数位置的值为峰( 除了头，发现如果p的 n值在偶数位，且挨着1，是无法实现的，但其实也不难解决，将p翻转后 n下标的奇偶性就会改变( 最后输出前记得翻转 q。如果只有偶数子节点，那么0/1的选择是固定的，如果存在奇节点，所有偶节点可以取更大值，对于奇节点的选择，如果偶数个奇节点，0/1各一半，如果奇数个，多的那个取父节点的反，将奇点的 0/1 差值排个序，贪心即可。easy线段树题 建平台。补重庆科技 C 二分。
分析和设计算法
日积月累
05-29 275
分析和设计算法
偏微分方程算法之抛物型方程差分格式编程示例一
L_peanut的博客
05-27 234
主要对本专栏所介绍的抛物型偏微分方程的差分格式进行算例补充。
LeetCode 2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3）
<font color="Pink">Tisfy的博客</font>
05-31 835
【LetMeFly】2965.找出缺失和重复的数字：小数据？我选择暴力（附优化方法清单：O(1)空间方法×3） 给你一个下标从 0 开始的二维整数矩阵 grid，大小为 n * n ，其中的值在 [1, n2] 范围内。除了 a 出现 两次，b 缺失 之外，每个整数都 恰好出现一次 。 任务是找出重复的数字a 和缺失的数字 b 。 返回一个下标从 0 开始、长度为 2 的整数数组 ans ，其中 ans[0] 等于 a ，ans[1] 等于 b 。
【算法】位运算算法——两整数之和
2302_79031646的博客
05-28 459
两整数之和(位运算算法)
LeetCode27.移除元素
weixin_60335028的博客
05-27 182
LeetCode27.移除元素题解
【LeetCode算法】第88题：合并两个有序数组
致力于Linux的博客
05-28 456
合并两个有序数组，可以使用双指针法从后往前遍历，并将元素拷贝至目标位置。
【算法】宵暗的妖怪
最新发布
一岁就可帅的博客
05-31 328
值得注意的是，若取两段进行吞噬，反而最多只能获得6的饱食度，并不是最大的。选择[2,4,1]和[4,2,1]这两段即可。饱食度为4+2=6。选择[1,7,2]这一段即可。一个正整数，代表最终饱食度的最大值。
【算法】位运算算法——消失的两个数字(困难)
2302_79031646的博客
05-30 795
题解：消失的两个数字(位运算算法)
平衡二叉树是二叉搜索树吗？
04-04
平衡二叉树是一种特殊的二叉搜索树。二叉搜索树是一种有序的二叉树，其中每个节点的左子树的值都小于该节点的值，而右子树的值都大于该节点的值。而平衡二叉树是在二叉搜索树的基础上增加了一个平衡条件，即任意节点的左右子树的高度差不超过1。 平衡二叉树的平衡条件保证了树的高度相对较小，从而提高了搜索、插入和删除操作的效率。常见的平衡二叉树有红黑树、AVL树等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值