【二叉树进阶】二叉搜索树的结构、实现及应用

最新推荐文章于 2024-04-23 15:29:24 发布
最新推荐文章于 2024-04-23 15:29:24 发布
阅读量975 收藏 11
点赞数 4
分类专栏： C++ 数据结构 文章标签： 数据结构 c++ 二叉搜索树 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48025315/article/details/125304855
版权

文章目录

前言

普通的二叉树单纯用来存储数据意义不大，还不如用数组和链表。

普通数组和链表，面对一些需要频繁查找、插入、删除的场景，也很麻烦。

  • 普通数组/链表：暴力查找，O(N)
  • 排序数组：二分查找，O(log2N)

所以这里引入了二叉搜索树。

一、二叉搜索树的概念

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

  • 若它的左子树不为空，则左子树上所有节点的值都 小于「根节点的值」
  • 若它的右子树不为空，则右子树上所有节点的值都 大于「根节点的值」
  • 它的所有子树也都是二叉搜索树
image-20220302092401506

二叉搜索树的结构特点带来的好处：

  • 存储数据：对二叉搜索树进行「中序遍历」，正好是一个「升序」序列
  • 查找一个值：最多查找树的高度次
  • ……

二、二叉搜索树的实现

2.1 节点 & 树的整体结构

定义二叉搜索树节点类模板：

#include<iostream>
using namespace std;

// 定义二叉搜索树节点
template<class K>
struct BinarySearchTreeNode // cpp中不用typedef
{
	K _key;
	BinarySearchTreeNode<K>* _left;
	BinarySearchTreeNode<K>* _right;

	// 构造函数
	BinarySearchTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

定义二叉搜索树类模板：

// 定义二叉搜索树
template<class K>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node; // 重命名树节点类名
private:
	Node* _root = nullptr; // 根节点

public:
	// 构造函数
	BinarySearchTree();
    // 拷贝构造函数
	BinarySearchTree(const BinarySearchTree<K>& tree); // 引用
    // 赋值运算符重载函数
	BinarySearchTree<K>& operator=(BinarySearchTree<K> tree); // 传值
    // 析构函数
    ~BinarySearchTree();
    
	// 插入元素key
	bool Insert(const K& key); // 常引用：减少传参时的拷贝，保护形参不会被更改
	// 查找元素key，查找到了返回节点地址，否则返回nullptr
    Node* Find(const K& key);
    // 删除元素key
    bool Erase(const K& key);
    
    // 插入元素key（递归版本）
    bool InsertR(const K& key);
    // 查找元素key（递归版本）
	Node* FindR(const K& key);
    // 删除元素key（递归版本）
	bool EraseR(const K& key);
    
	// 中序遍历
	void InOrder();

private:
    // 拷贝构造子函数
	Node* _Copy(Node* _root);
    // 析构子函数
	void _Destroy(Node* root);
    
    // 插入元素key子函数（递归版本）
	bool _InsertR(Node*& root, const K& key); // 形参为引用，这里很妙
    // 查找元素key子函数（递归版本）
	Node* _FindR(Node* root, const K& key);
    // 删除元素key子函数（递归版本）
	bool _EraseR(Node*& root, const K& key); // 形参为引用，这里很妙
    
	// 中序遍历子函数
	void _InOrder(Node* _root);
};

2.2 默认成员函数的实现

2.2.1 构造函数
//...
public:
	// 构造函数
	BinarySearchTree()
		:_root(nullptr)
	{}
//...
2.2.2 拷贝构造函数（要弄懂）
//...
public:
	// 拷贝构造函数
	BinarySearchTree(const BinarySearchTree<K>& tree)
	{
		// 深拷贝，用已存在的树tree去拷贝一个新树，然后返回新树的根
		_root = _Copy(tree._root);
	}

private:
	// 拷贝构造子函数
	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;
	}
//...
2.2.3 赋值运算符重载（要弄懂）
//...
public:
	// 赋值运算符重载函数
	BinarySearchTree<K>& operator=(BinarySearchTree<K> tree) // 传值
	{
		// 现代写法
		// 比如 t1 = t2，tree是t2的深拷贝，tree就是t1想要的，
		// 所以t1和tree换个头（根节点地址），但不换身体（整颗树）,t1就指向了tree整棵树，然后返回去
		std::swap(_root, tree._root);
		return *this;
	}
//...
2.2.4 析构函数
//...
public:
	// 析构函数
	~BinarySearchTree()
	{
		_Destroy(_root);
	}

private:
	// 析构子函数
	void _Destroy(Node* root)
	{
		// 根节点不为空
		if (root)
		{
			// 建议使用后序遍历，左-右-根
			_Destroy(root->_left);
			_Destroy(root->_right);
			delete root;
			root = nullptr;
		}
	}
//...

三、二叉搜索树的相关接口实现

3.1 二叉搜索树的查找

3.1.1 非递归写法

如果根节点为空，返回 nullptr

如果根节点不为空，从根节点开始，查找 key：

  • 如果 key 比当前节点小，则去当前节点的左子树中查找
  • 如果 key 比当前节点大，则去当前节点的右子树中查找
  • 如果 key 等于当前节点，返回 节点地址
// 查找元素key，查找到了返回节点地址，否则返回nullptr
Node* Find(const K& key)
{
    // 树为空
    if (_root == nullptr)
    {
        return nullptr;
    }

    // 树不为空，从根节点开始查找元素key
    Node* cur = _root;
    while (cur) // 当cur为空，停止循环，说明没找到
    {
        if (key > cur->_key)
        {
            cur = cur->_right;
        }
        else if (key < cur->_key)
        {
            cur = cur->_left;
        }
        else // 查找到了，返回节点地址
        {
            return cur;
            break;
        }
    }

    // 没有找到
    return nullptr;
}
3.1.2 递归写法（优先用非递归）

分而治之的思想：

每一级递归时，在我们眼中，当前树就是这样的，只有 root、left、right 三个节点。

递归算法思路：

根据「二叉搜索树性质」，查找 key，太简单了，略……

// 定义二叉搜索树
template<class K>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node; // 重命名
    
private:
	Node* _root = nullptr; // 根节点
    
public:
	// 查找元素key（递归版本）
	// 调用函数需要传递树的根，根是私有成员，所以套一层函数InsertR来间接调用，从而保护根
	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}

private:
	// 查找元素key子函数（递归版本）
	Node* _FindR(Node* root, const K& key)
	{
		// 递归出口（终止条件），当前树的根节点为空
		if (root == nullptr)
		{
			return nullptr; // 没找到，返回nullptr
		}

		// 当前树的根节点不为空
		if (key > root->_key)
		{
			return _FindR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			// 找到了，返回该节点地址
			return root;
		}
	}
}

3.2 二叉搜索树的插入

3.2.1 非递归写法

  1. 树为空，直接插入。

    image-20220303220602951

  2. 树不为空，根据「二叉搜索树性质」，从根节点开始，查找到适合插入 key 的空位置，然后插入。

    image-20220305210758589

代码如下：

// 插入元素key
bool Insert(const K& key) // 常引用：减少传参时的拷贝，保护形参	不会被更改
{
    // 树为空
    if (_root == nullptr)
    {
        _root = new Node(key); // 直接插入新节点
        return true;
    }

    // 树不为空，从根节点开始，先查找到插入key的位置
    Node* cur = _root;
    
    // 记录cur的父节点，因为新节点最终会插入在cur的父节点左右孩子的位置
    Node* parent = nullptr;
    
    while (cur) // 当cur为空，说明找到插入key的位置了
    {
        if (key < cur->_key) // key比当前节点小
        {
            parent = cur;
            cur = cur->_left; // 去当前节点的左子树查找
        }
        else if (key > cur->_key) // key比当前节点大
        {
            parent = cur;
            cur = cur->_right; // 去当前节点的右子树查找
        }
        else
        {
            // key等于当前节点，说明元素已经在树中存在，二叉搜索树不允许冗余，则返回false
            return false;
        }
    }
    // 申请一个新节点
    cur = new Node(key);

    // 判断下新节点应该链接在其父节点的左边还是右边
    if (key > parent->_key)
    {
        parent->_right = cur; // key比父节点大，链接在右边
    }
    else
    {
        parent->_left = cur; // key比父节点小，链接在左边
    }

    // 插入成功，返回true
    return true;
}

注意一点：

插入元素的顺序不同，树的结构也会不同，但中序遍历的结果是一样的。

image-20220305201054474
3.2.2 递归写法（优先用非递归）

分而治之的思想：

每一级递归时，在我们眼中，当前树就是这样的，只有 root、left、right 三个节点。

递归算法思路：

如果当前树的根节点为空，则直接插入；

如果当前树的根节点不为空：

  • 插入的值 key 如果比当前树的根节点大，则去往当前树的右子树中插入；
  • 插入的值 key 如果比当前树的根节点小，则去往当前树的左子树中插入；
// 定义二叉搜索树
template<class K>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node; // 重命名
    
private:
	Node* _root = nullptr; // 根节点
    
public:
	// 插入元素key（递归版本）
	// 调用函数需要传递树的根，根是私有成员，所以套一层函数InsertR来间接调用，从而保护根
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

private:
	// 插入元素key子函数（递归版本）
	bool _InsertR(Node*& root, const K& key) // 形参是根节点的引用，这里很巧妙
	{
		// 当前树的根节点为空
		if (root == nullptr)
		{
			root = new Node(key); // 插入新节点
			return true;          // 返回true
		}

		// 当前树的根节点不为空
		if (key > root->_key)
		{
			// 去往当前树的右子树中插入
			return _InsertR(root->_right, key);
		}
		else if (key < root->_key)
		{
			// 去往当前树的左子树中插入
			return _InsertR(root->_left, key);
		}
		else
		{
			// 二叉搜索树不允许数据冗余，返回false
			return false;
		}
	}
}
【拓展】

函数形参是根节点的引用 bool _InsertR(Node*& root, const K& key);，这里很巧妙，我们在函数体内就不用定义一个变量来保存要插入的节点的父节点了。

我们以插入节点 10 为例，分析下原理：

image-20220306183524491

这样一来，我通过改变 root，从而控制 root 父节点（节点 9）右指针的指向。

3.3 二叉搜索树的中序遍历

注意一点：

我们在类外面，用对象调用函数时需要传递树的根，但根是私有成员，只能再去写一个 GetRoot 接口来传递树的根，但这样根又被暴露出去了，所以我们在这里，套一层无参函数 InOrder() 来调用有参函数 _InOrder(Node* _root)，从而保护了根节点。

template<class K>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node; // 重命名树节点类名
private:
	Node* _root = nullptr; // 根节点

public:
    // 其它成员函数......
    
	// 中序遍历
	// void InOrder(Node* _root)
	// 调用函数需要传递树的根，根是私有成员，所以套一层无参函数InOrder()来间接调用，从而保护根
	void InOrder()
	{
		_InOrder(_root); // 调用中序遍历子函数
        cout << endl;
	}

private:
	// 中序遍历子函数
	void _InOrder(Node* root)
	{
		if (root)
		{
			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
	}
};

3.4 二叉搜索树的删除（难点）

3.4.1 非递归写法

二叉搜索树的删除比较复杂，要分情况讨论：

首先查找元素 key 是否在二叉搜索树中，如果不存在，则返回 false，否则删除结点，分下面几种情况：

情况1和2：要删除的结点「无孩子」结点（叶子节点），或者要删除的结点「只有左孩子」结点

  • 先判断被删除节点 cur 是父节点 parent 的 左孩子 还是 右孩子。
  • 让父结点 parent 的左 / 右指针指向被删除节点的 左孩子 （我被删除了，我的父亲要帮我接管左孩子）
  • 然后删除该节点。
image-20220306105243164

【注意】：

还有一种情况需要考虑到，删除的是根节点，cur 没有父节点，所以直接把 cur 的左孩子变为根：

image-20220306125539742

情况3：要删除的结点「只有右孩子」结点

  • 先判断被删除节点 cur 是父节点 parent 的 左孩子 还是 右孩子。

  • 让父结点 parent 的左 / 右指针指向被删除节点的 右孩子。（我被删除了，我的父亲要帮我接管右孩子）

  • 然后删除该节点。

  • 这里就不详细画图演示了，和上面的类似。

    image-20220306110432302

【注意】：

还有一种情况需要考虑到，删除的是根节点，cur 没有父节点，所以直接把 cur 的右孩子变为根：

image-20220306125822620

情况4：要删除的结点「有左右孩子」结点

有两个孩子，不好直接删除，所以我们用替代法删除：

找一个「替代节点」，比被删除节点的左孩子值大，比被删除节点右孩子的值小。

即被删除节点左子树中的最大节点或者右子树中的最小节点。

  1. 左子树中的最大节点 --> 即左子树的最右侧节点（它的右孩子一定为空）
  2. 右子树中的最小节点 --> 即右子树的最左侧节点（它的左孩子一定为空）

「替代节点」找到后，将替代节点中的值赋给「要的删除节点」，转换成删除替代节点。

image-20220306122609747

以找被删除节点 左子树中的最大节点 作为替代节点为例，删除思路如下：

image-20220306114312704

【注意】：

在第 3 步：

  • 先要判断一下最大节点 maxleft 是父节点 maxleft_parent 的 左孩子 还是 右孩子。

  • 让父结点 maxleft_parent 的左 / 右指针指向被删除节点的 左孩子 （我被删除了，我的父亲要帮我接管左孩子，因为左子树的最大节点没有的右孩子）

image-20220306114751318

代码如下：

// 删除元素key
bool Erase(const K& key)
{
    // 树为空，删除失败
    if (_root == nullptr)
    {
        return false;
    }

    // 树不为空，从根节点开始，查找元素key
    Node* cur = _root;                              // 记录元素key的位置
    Node* parent = nullptr;                         // 记录cur的父节点

    while (cur) // 如果cur为空，说明没有找到元素key的位置
    {
        if (key > cur->_key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (key < cur->_key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else // 找到要删除的元素key了，分为以下几种情况：
        {
            // 1、要删除的节点没有左右孩子，或者要删除的节点只有一个左孩子
            if (cur->_right == nullptr)
            {
                if (cur == _root) // 如果要删除的cur是树的根节点，cur没有父节点
                {
                    _root = cur->_left;
                }
                else
                {
                    // 判断下
                    if (cur == parent->_left) // 被删除节点cur是父节点的左孩子
                    {
                        parent->_left = cur->_left; // 让父节点左指针指向cur左孩子
                    }
                    else // 被删除节点cur是父节点的右孩子
                    {
                        parent->_right = cur->_left; // 让父节点右指针指向cur左孩子
                    }
                }

                // 删除
                delete cur;
            }

            // 2、要删除的节点只有一个右孩子
            else if (cur->_left == nullptr)
            {
                if (cur == _root) // 如果要删除的cur是树的根节点，cur没有父节点
                {
                    _root = cur->_right;
                }
                else
                {
                    // 判断下
                    if (cur == parent->_left) // 被删除节点cur是父节点的左孩子
                    {
                        parent->_left = cur->_right; // 让父节点左指针指向cur右孩子
                    }
                    else // 被删除节点cur是父节点的右孩子
                    {
                        parent->_right = cur->_right; // 让父节点左指针指向cur右孩子
                    }
                }
                
                // 删除
                delete cur;
            }

            // 3、要删除的节点有左、右两个孩子
            else
            {
                // 找替代节点：被删除节点的左子树中的最大节点，即左子树的最右节点（它的右孩子一定为空）
                Node* maxleft = cur->_left; // 从左子树的根节点开始找
                Node* maxleft_parent = cur; // 记录最大节点的父亲

                // 3.1 找最大节点
                while (maxleft->_right) // 右孩子为空时，说明找到最大节点了
                {
                    maxleft_parent = maxleft;
                    maxleft = maxleft->_right; // 继续往右找
                }

                // 3.2 把最大节点的值赋给被删除节点
                cur->_key = maxleft->_key;

                // 3.3 判断一下
                if (maxleft == maxleft_parent->_left) // 如果最大节点是父节点左孩子
                {
                    // 让父节点左指针指向maxleft左孩子
                    maxleft_parent->_left = maxleft->_left; 
                }
                else // 如果最大节点是父节点的右孩子
                {
                    // 让父节点右指针指向maxleft左孩子
                    maxleft_parent->_right = maxleft->_left; 
                }

                // 3.4 删除
                delete maxleft;
            }

            // 删除成功，返回true
            return true;
        }
    }

    // 没有找到元素key，删除失败，返回false
    return false;
}
3.4.2 递归写法（优先用非递归）

分而治之的思想：

每一级递归时，在我们眼中，当前树就是这样的，只有 root、left、right 三个节点。

递归算法思路：

// 定义二叉搜索树
template<class K>
class BinarySearchTree
{
	typedef BinarySearchTreeNode<K> Node; // 重命名
    
private:
	Node* _root = nullptr; // 根节点
    
public:
	// 删除元素key（递归版本）
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key); // 保护根
	}

private:
// 删除元素key子函数（递归版本）
	bool _EraseR(Node*& root, const K& key)
	{
		// 树为空，删除失败
		if (root == nullptr)
		{
			return false;
		}

		// 树不为空，查找要删除的节点
		if (key > root->_key)
		{
			return _EraseR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _EraseR(root->_left, key);
		}
		else // 找到了，删除该节点
		{
			Node* del = root; // 保存当前节点的地址

			// 1、当前节点没有左右孩子，或者当前节点只有一个左孩子
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			// 2、当前节点只有一个右孩子
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			// 3、当前节点有左右两个孩子
			else
			{
				// 找到当前节点的右子树中最小节点替代删除
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}

				// 替代节点值赋给当前节点
				root->_key = minRight->_key;

				// 转换成，在当前节点的右子树中去删除替代节点
				return _EraseR(root->_right, minRight->_key);
			}

			delete del;
			return true;
		}
	}
}

【拓展】

在删除有两个孩子的节点时，需要注意的细节：

image-20220306201604815

3.5 总结 & 一些细节

  • 二叉搜索树的查找，根据「二叉搜索树性质」来找某节点

  • 二叉搜索树的插入，

    • 先根据「二叉搜索树性质」来查找适合插入的空位置，
    • 必须要保存新节点的父节点，并判断新节点是左孩子还是右孩子，然后再插入新节点。（不允许冗余）

  • 二叉搜索树的删除，

    • 先根据「二叉搜索树性质」来查找要删除的节点 cur，

    • 并根据要删除节点 cur 所在位置的不同情况，来具体操作，

    • 必须要保存要删除节点 cur 的父节点，并判断要删除节点 cur 是左孩子还是右孩子，先让父亲接管要删除节点 cur 的孩子，然后再删除节点 cur。

      删除节点 cur 的 3 种情况汇总：cur左为空，父亲指向右；右为空，父亲指向左；左右都不为空，找替代节点。

      image-20220306175043379

  • 对于上述接口的递归写法，一般能用循环（非递归）就用非递归，有些递归好是好，也容易让人理解，但是对于深度高的树，建立栈帧也是一笔不小的开销，有可能会导致栈溢出。

四、二叉搜索树的应用

4.1 K的模型 – set

K (Key) 模型：确定一个值在不在一个集合中，K 模型即只有 Key 作为关键码，二叉搜索树结构中只需要存储 Key 即可，关键码即为需要搜索到的值。

举个例子1：

  • 学生宿舍楼的门禁系统，你的学生卡里有学号，你在这栋楼的学生学号集合中，才能刷卡进去。

举个例子2：给一个单词 word，判断该单词是否拼写正确，具体方式如下：

  • 以单词集合中的每个单词作为 key，构建一棵二叉搜索树。
  • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

👆上面实现的二叉搜索树就是 K 模型！

4.2 KV的查找模型 – map

KV (Key/Value) 模型：每一个关键码 Key，都有与之对应的值 Value，即 < Key, Value > 的键值对。

该种方式在现实生活中非常常见：

  • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文 < word, chinese > 就构成一种键值对；
  • 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是 < word, count > 就构成一种键值对；
  • 再比如高铁站买票后刷身份证进站，你的身份证中并没有买票信息，那是如何进站的呢，通过身份证号，查找用这个身份证号买的车票信息，通过 < 身份证号, 车票信息 > 键值对。

注意：👇

KV模型中，二叉搜索树的每个节点不仅要存放 key，还要存放 value，但是在插入、删除的时候，还是按照 key 值来查找到该节点，对其进行插入、删除操作。

所以我们要对上面的二叉搜索树进行改造，主要是这几个改动：1、节点类模板 2、树类模板中的插入节点函数、中序遍历函数。而查找、删除函数无需改动。

示例1：英汉词典

实现一个简单的英汉词典 dict，可以通过英文找到与其对应的中文，具体实现方式如下：

  • < 单词，中文含义 > 为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较 Key
  • 查询英文单词时，只需给出英文单词，就可快速找到与其对应的 key，通过 key 就可知道中文含义 value 了。
void TestTree2()
{
	// KV模型 -- 英汉词典，通过英文找到与其对应的中文
	KEY_VALUE::BinarySearchTree<string, string> dict;
	
	// 插入 < 单词，中文含义 > 构建二叉搜索树
	dict.Insert("boy", "男孩");
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");
	dict.Insert("tree", "树");
	dict.Insert("boy", "男孩");

	// 查找单词对应中文含义
	string word;
	while (cin >> word)
	{
		if (word == "q") // 输入q退出查找
		{
			cout << "quit！" << endl;
			break;
		}
		else
		{
            // 查找该单词
			auto ret = dict.Find(word);
			// 这样写可以，不过太烦了 KEY_VALUE::BinarySearchTreeNode<string, string>* ret = dict.Find(word);
			
            // 判断有没有查找到
			if (ret == nullptr) // 没有查找到
			{
				cout << "词典中无此单词，请重新输入" << endl;
			}
			else // 查找到了
			{
				cout << ret->_key << " -- " << ret->_value << endl;
			}
		}
	}
}
示例2：统计单词出现的次数

统计 str 中每个单词出现的次数，方法如下：

  • 按照原来的做法可能是，对所有单词排序，然后遍历，如果遍历的结果一样，次数就加1……

  • 现在直接用KV模型，用 < 单词，单词出现次数 > 为键值对构造二叉搜索树，只需给出单词，就可快速找到与其对应的 key，通过 key 就可知道单词出现的次数 value 了。

void TestTree3()
{
	string str[] = { "sort","sort", "tree","sort", "node", "tree","sort", "sort", };

	// KV模型 -- 统计str中每个单词出现的次数
	KEY_VALUE::BinarySearchTree<string, int> tree;

	// 遍历str
	for (auto& e : str) // 传引用，避免string深拷贝
	{
		// 先检查当前准备插入的单词，是否已经在二叉搜索树tree中了
		auto ret = tree.Find(e);
		if (ret == nullptr) // 不在树中
		{
			// 插入 < 单词，单词出现次数 >
			tree.Insert(e, 1);               // 当前次数是1次
		}
		else // 在树中
		{
			ret->_value++;                   // 修改value，出现次数+1
		}
	}

	// 打印每个 < 单词，单词出现次数 >
	tree.InOrder();
}

运行结果：

因为二叉搜索树的特性，插入字符串的时候就排好序了，中序遍历出来的结果也是有序的：

image-20220307181811979

五、二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有 n 个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是与树的深度有关，即树越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的顺序不同，可能得到不同结构的二叉搜索树：

image-20220305201054474

二叉搜索树的查找是很快的，但是它很依赖于树的形状：

image-20220307194944222

最优情况下，有 n 个结点的二叉搜索树为完全二叉树，其平均比较次数为：O(log2N)

最差情况下，有 n 个结点的二叉搜索树退化为单支树，其平均比较次数为：O(N)

留一个问题：

如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，都可以是二叉搜索树的性能最佳？这就要引出 AVL 树了。

CodeWinter
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-二叉查找树的应用
Junds0的博客
12-08 3207
第1关：二叉排序树应用一 本关的编程任务是补全右侧代码片段insertBiSortTree和creatBiSortTree中Begin至End中间的代码，具体要求如下： 在insertBiSortTree中，实现向升序二叉排序树插入元素； 在creatBiSortTree中，实现创建升序二叉排序树。 // binary_sort_tree.cpp // BinarySortTree // // Created by ljpc on 2018/5/11. // Copyright © 2018年 lj
二叉搜索树的应用
iwkxi的博客
08-18 1226
首先，我们的目的是查找Key的时候随便查找Value，所以节点的结构、Insert和new的时候都要增加第二个参数Value。递归时，我们很容易知道当前节点的前一个节点是什么，但是无法知道下一个节点是什么，所以我们不能改变当前节点的右指针(后继指针)。再比如检查一篇文章单词释放拼写错误：以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树，在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。考虑用栈来存储p、q的路径，让路径长的先走，路径相等后同时走，转换成求两个路径的交点。...
二叉搜索树的构造（Java实现）
世纪末的架构师的博客
01-17 3197
二叉搜索树的学习笔记，使用Java语言对二叉搜索树进行了构造、添加元素、是否为空的判断、当前节点的个数判断以及是否包含某个元素的递归实现
二叉搜索树（BST）详细解释及常见应用
fucheng的博客
04-23 326
二叉搜索树（BST）详细解释及常见应用
C++数据结构：二叉搜索树的结构、模拟实现及应用
weixin_43908419的博客
04-17 406
本文对二叉搜索树的结构、性能、实现及使用进行了详解，并在文末给出了完整版的实现代码
【数据结构】二叉搜索树
YZmu_yu的博客
03-01 159
二叉搜索的实现及其应用场景，替换删除法，性能分析
计算机+数据结构与算法+学习路线+蓝桥杯
05-10
树形结构：二叉树、二叉搜索树、AVL树、红黑树、并查集等。 图论算法：深度优先搜索（DFS）、广度优先搜索（BFS）、Dijkstra算法、Floyd算法、Kruskal算法、Prim算法等。 排序与查找：冒泡排序、插入排序、选择排序...
数据结构-1-8习题-(54页-有答案).doc
01-14
5. 习题3：通常涵盖树和二叉树，如二叉搜索树、平衡二叉树（AVL树、红黑树）的性质和操作，还包括树的遍历（前序、中序、后序）。 6. 习题3参考答案：展示了如何构造和操作各种类型的二叉树，以及如何判断一棵树...
2015河北工业大学数据结构考研真题
11-08
2015年河北工业大学计算机科学与技术考研的数据结构真题涵盖了一系列基础和进阶的问题，旨在考察考生对数据结构理论知识和实践应用的掌握程度。 1. 数据结构的四种基本类型包括线性结构、树形结构、图形结构和集合...
Java数据结构和算法中文第二版
05-21
二叉搜索树如何工作 查找节点 插入一个节点 遍历树 查找最大值和最小值 删除节点 二叉树的效率 用数组表示树 重复关键字 完整的tree.java程序 哈夫曼(Huffman)编码 小结 问题 实验 编程作业 第9章 红...
大厂学院算法与数据结构解析课程大纲1
08-08
二叉树和递归紧密相连，课程将分析二叉树、二叉搜索树、B树、B+树、AVL树和红黑树，通过翻转二叉树、平衡二叉树和验证二叉搜索树等题目，让学员掌握递归思想。 贪心算法和动态规划是高级算法，课程将讲解它们的原理...
LeetCode：98. 验证二叉搜索树
梦~'
08-15 401
98. 验证二叉搜索树 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 示例1: 输入: 2 / \ 1 3 输出: true 示例2: 输入: 5 / \ 1 4 / \ 3 6 输出: false 解释: 输入为: [5,...
6.2哈夫曼树编码与解码
m0_65022800的博客
05-29 577
哈夫曼树相关的几个名词 路径：在一棵树中，一个结点到另一个结点之间的通路，称为路径。图 1 中，从根结点到结点 a 之间的通路就是一条路径。 路径长度：在一条路径中，每经过一个结点，路径长度都要加 1 。例如在一棵树中，规定根结点所在层数为1层，那么从根结点到第 i 层结点的路径长度为 i - 1 。图 1 中从根结点到结点 c 的路径长度为 3。 结点的权：给每一个结点赋予一个新的数值，被称为这个结点的权。例如，图 1 中结点 a 的权为 7，结点 b 的权为 5。 结点的带权路径长度：指的是从根结点到
2021-04-25
weixin_56742464的博客
04-25 90
二叉搜索树在大数据查找方面的运用 怎么搞呀
二叉查找树（通过外排思想处理大数据）
za30312的博客
06-04 494
因为要读的文件很大 ，不能直接一次读进数组，需要通过读一部分，释放内存，再读的方式来解决， 因为直接插入二叉查找（排序）树，则不需要再将排序好的数据先放入别的文件。#include <stdio.h> #include <windows.h> #include <stack> #include <iostream> using namespace std; typedef int ElementTy
Java 数据结构之二叉搜索树
Junds0的博客
03-24 1204
第1关：二叉搜索树的介绍与构建 本关任务：构建一棵二叉搜索树，向其中添加结点。 package step1; /** * Created by zengpeng on 2018/3/3. */ public class BSTree { private TreeNode root;//根结点 public BSTree() { root = null; } /** * 向树root中插入key * * @param k
【数据结构】二叉查找树
wakawaka
12-03 345
建树 树节点的存储方式与普通的二叉树相似，用结构体存储，其中一个int变量存储数据，两个指针指向左右儿子。 读入一个新数据，从根节点开始寻找，大于当前节点则继续寻找右子树，右子树为空则直接插入，小于当前节点则继续寻找左子树，左子树为空则直接插入。 注： 初始数据要求随机数，为了产生真正意义上的“随机数”，使用时间作为随机数种子。 查找 从根节
平衡二叉树是二叉搜索树吗
最新发布
06-13
平衡二叉树是一种特殊的二叉搜索树（Binary Search Tree, BST），它满足两个额外的条件：对于任意节点，其左子树中所有节点的值都小于该节点的值，右子树中所有节点的值都大于该节点的值，同时树的高度被尽可能地...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值