DS二叉搜索树

本文主要是介绍DS二叉搜索树，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

我们在数据结构初阶专栏已经对二叉树进行了介绍并用C语言做了实现，但是当时没有对二叉搜树进行介绍，而是把他放到数据结构进阶构专栏的第一期来介绍，原因是后面的map和set（红黑树）是基于搜索树的，这里介绍完后再去学习他们的成本会低一点！

本期内容介绍

二叉搜索树介绍

二叉搜索树的实现

二叉搜索树的应用

二叉搜索树的性能分析

二叉搜索树的介绍

什么是二叉搜索树？

二叉搜索树又称二叉排序树（走中序就是有序的）或二叉查找树。他是一颗空树或满足以下性质的二叉树！

1、如果它的左子树不为空，则左子树的所有节点的值都小于根节点的值

2、如果它的右子树不为空，则右子树的所有节点的值都大于根节点的值

3、它的左右子树也必须都为二叉搜索树

一般把二叉搜索树的节点的值叫做键值（key），一个键值唯一标识唯一一个节点！所以一般的key模型的二叉搜索树是不允许修改的（key_value模型仅可以修改value）；因为在key模型的二叉搜索树中修改了key值会影响二叉搜索的搜索性，修改后可能就不在符合左边比根节点小，右边比根节点大的性质了！！！

二叉搜索树的实现

由于二叉搜索树是不允许修改键值(key)的，他主要作用是查询，所以没有修改接口。

OK，还是和以前一样，先搭个架子出来：我们得有节点的类专门搞节点，然后一个二叉搜索树的类专门负责查找等操作！

template<class K>
struct BSTreeNode
{BSTreeNode* _left;BSTreeNode* _right;K _key;BSTreeNode(const K& key):_left(nullptr), _right(nullptr), _key(key){}
};template<class K>
class BSTree
{typedef BSTreeNode<K> Node;
public:private:Node* _root = nullptr;//只有一个成员，给一个缺省参数可以不用自己写构造了
};

下面就是实现插入、查询和删除的接口操作了！

insert

实现思路：

如果是第一次插入即根节点为空则直接new一个值为key的节点连接到_root返回即可！

如果不是第一次插入，则从父节点开始查找合适的插入位置并用parent的变量记录合适位置的父节点的值，如果比当前的节点大，去右边，否则去左边，直到为空即找到了合适的位置，插入！如果是等于说明要插入的值引进存在直接返回！

最后找到了插入位置new一个键值为key的节点连接到合适位置的父节点即可！

但是这里要插到做还是右呢？如果key的值比parent的值大插入到右边，否则插入到左边！

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->_left;//去当前节点的左边}else if (cur->_key < key)//要插入的值比当前节点的值大{parent = cur;cur = cur->_right;//去当前节点的右边}else{return false;//要插入的值已经存在}}//找到了要插入节点的合适位置cur = new Node(key);//申请一个键值为key的节点if (parent->_key < key)//key的值比父节点小{parent->_right = cur;//连接到父节点的右边}else{parent->_left = cur;//否则连接到父节点的左边}return true;//插入成功
}

OK，我们知道他的中序是有序的，所以我们可以插入一些乱序的数字然后走个中序看看是否是有序的即可验证师插入！

InOrder

实现思路：先遍历左子树 --> 根 -->右子树

但是这的根节点是BSTree私有的，咋办呢？解决方案右以下几种：

1、把你的测试函数搞成友元，就可以在测试函数中访问_root了（强烈不推荐）

2、提供get和set函数

3、把中序搞成私有的子函数，在提供一个共有的把子函数套一层（推荐）

void _Inorder(const Node* _root)
{if (_root == nullptr){return;}_Inorder(_root->_left);cout << _root->_key << " ";_Inorder(_root->_right);
}

OK，验证一下：

Find

实现思路：比较当前节点的值和key的值，如果比key大去右边，否则去左边找！

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

Erase

实现思路

删除可以分为4种情况：1、被删节点的左为空 2、被删节点的右为空 3、被删节点的左右都为空 4、被删节点的左右都不为空。前三中只需要特殊处理一下可以合并为两种！注意：所有的删除都得找到这个节点，否则直接返回false;

被删节点的左为空

1、如果当前节点是根节点且只有右单枝，让根节点指向它的右单枝的下一个

2、不是根节点，如果被删节点==它的父节点的左，则把他的右连接到父亲的左

如果被删节点==它的父节点的右，则把他的右连接到父亲的右

被删节点的右为空

1、如果当前节点是根节点且只有左单枝，让根节点指向它的左单枝的下一个

2、不是根节点，如果被删节点==它的父节点的左，则把他的左连接到父亲的左

如果被删节点==它的父节点的右，则把他的左连接到父亲的右

被删节点的左右都不为空

用替换法删除即找一个合适的节点替他删除！可以找左子树最大（右）或右子树最左（小）的节点来替换。

找到替换的节点后可以交换键值也可以赋值，然后删除替换节点即可！

bool Erase(const K& key)
{Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_key > key)//比key大，往左找{parent = cur;cur = cur->_left;}else if (cur->_key < key)//比key小，往右找{parent = cur;cur = cur->_right;}else//找到了{if (cur->_left == nullptr)//被删除节点的左为空{if (_root == cur)//删除根且只有右枝没有左枝{_root = cur->_right;//让根指向它的右}else{if (parent->_left == cur)//父亲的左==cur，把cur的右连接到父亲的左{parent->_left = cur->_right;}else//父亲的右==cur，把cur的右连接到父亲的右{parent->_right = cur->_right;}}delete cur;}else if (cur->_right == nullptr)//被删除节点的右为空{if (_root == cur)//删除根且只有左枝没有右枝{_root = cur->_left;//让根指向它的左}else{if (parent->_left == cur)//父亲的左==cur，把cur的左连接到父亲的左{parent->_left = cur->_left;}else{parent->_right = cur->_left;//父亲的右==cur，把cur的右连接到父亲的左}}delete cur;}else//被删除节点的左右都不为空则用替换法删除即找到一个合适的节点来替他被删（左子树最（大）右，或右子树的最（小）左）{Node* rightMinParent = cur;//右子树最（小）左节点的父亲Node* rightMin = cur->_right;//右子树的最左节点while (rightMin->_left){rightMinParent = rightMin;rightMin = rightMin->_left;}swap(cur->_key, rightMin->_key);//右子树左节点与被删节点的值交换if (rightMinParent->_left == rightMin)//如果rightMinParent的左==rightMin{rightMinParent->_left = rightMin->_right;//则把rightMin的右连接到rightMinParent的左}else//如果rightMinParent的右==rightMin{rightMinParent->_right = rightMin->_right;//则把rightMin的右连接到rightMinParent的右}delete rightMin;}return true;}}return false;
}

OK，验证一下：

析构函数

因为只有一个成员，所以直接给一个缺省值就不用写构造了！析构得写，和二叉树的销毁一样！先左子树销毁-->右子树销毁-->根销毁，可以和中序一样搞一个子函数外面套一下即可！

void Destory(Node*& root)
{if (root == nullptr)return;Destory(root->_left);Destory(root->_right);delete root;root = nullptr;
}

~BSTree()
{Destory(_root);
}

key模型的全部源码

#pragma oncetemplate<class K>
struct BSTreeNode
{BSTreeNode* _left;BSTreeNode* _right;K _key;BSTreeNode(const K& key):_left(nullptr),_right(nullptr),_key(key){}
};template<class K>
class BSTree
{typedef BSTreeNode<K> Node;
public: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->_left;//去当前节点的左边}else if (cur->_key < key)//要插入的值比当前节点的值大{parent = cur;cur = cur->_right;//去当前节点的右边}else{return false;//要插入的值已经存在}}//找到了要插入节点的合适位置cur = new Node(key);//申请一个键值为key的节点if (parent->_key < 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->_left;}else if(cur->_key < key){cur = cur->_right;}else{return true;//找到了}}return false;//没找到}bool Erase(const K& key)
{Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_key > key)//比key大，往左找{parent = cur;cur = cur->_left;}else if (cur->_key < key)//比key小，往右找{parent = cur;cur = cur->_right;}else//找到了{if (cur->_left == nullptr)//被删除节点的左为空{if (_root == cur)//删除根且只有右枝没有左枝{_root = cur->_right;//让根指向它的右}else{if (parent->_left == cur)//父亲的左==cur，把cur的右连接到父亲的左{parent->_left = cur->_right;}else//父亲的右==cur，把cur的右连接到父亲的右{parent->_right = cur->_right;}}delete cur;}else if (cur->_right == nullptr)//被删除节点的右为空{if (_root == cur)//删除根且只有左枝没有右枝{_root = cur->_left;//让根指向它的左}else{if (parent->_left == cur)//父亲的左==cur，把cur的左连接到父亲的左{parent->_left = cur->_left;}else{parent->_right = cur->_left;//父亲的右==cur，把cur的右连接到父亲的左}}delete cur;}else//被删除节点的左右都不为空则用替换法删除即找到一个合适的节点来替他被删（左子树最（大）右，或右子树的最（小）左）{Node* rightMinParent = cur;//右子树最（小）左节点的父亲Node* rightMin = cur->_right;//右子树的最左节点while (rightMin->_left){rightMinParent = rightMin;rightMin = rightMin->_left;}swap(cur->_key, rightMin->_key);//右子树左节点与被删节点的值交换if (rightMinParent->_left == rightMin)//如果rightMinParent的左==rightMin{rightMinParent->_left = rightMin->_right;//则把rightMin的右连接到rightMinParent的左}else//如果rightMinParent的右==rightMin{rightMinParent->_right = rightMin->_right;//则把rightMin的右连接到rightMinParent的右}delete rightMin;}return true;}}return false;
}void Inorder(){_Inorder(_root);cout << endl;}~BSTree(){Destory(_root);}private:void _Inorder(const Node* _root){if (_root == nullptr){return;}_Inorder(_root->_left);cout << _root->_key << " ";_Inorder(_root->_right);}void Destory(Node*& root){if (root == nullptr)return;Destory(root->_left);Destory(root->_right);delete root;root = nullptr;}private:Node* _root = nullptr;//只有一个成员，给一个缺省参数可以不用自己写构造了
};

二叉搜索树的应用

1、K模型：就是我们上面介绍和实现的key模型，K模型中只存键值key，不可被修改！这个在生活中也是很常见的，比如说20万个单词找出拼写错误的单词！此时你只需要根据单词库中的单词建立一个key模型的搜索树即可，然后一一查找即可，如果是false的就是错误的！另外，宿舍的门禁系统，你刷脸或刷卡时会放你进去，这个也是一个key模型的搜索树！

2、KV模型：每个节点中不仅存一个键值key还要存一个key对应的value。即<KV>键值对。这个也是很常见的，比如说英汉词典，你的学号对应你等！

key_value模型全部源代码

上面K模型已经实现了，这里KV模型在上面的K上稍加修改即可（插入的时候多加一个value）！

namespace key_value
{template<class K, class V>struct BSTreeNode{BSTreeNode* _left;BSTreeNode* _right;K _key;V _value;BSTreeNode(const K& key, const V& value):_left(nullptr), _right(nullptr), _key(key),_value(value){}};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->_left;//去当前节点的左边}else if (cur->_key < key)//要插入的值比当前节点的值大{parent = cur;cur = cur->_right;//去当前节点的右边}else{return false;//要插入的值已经存在}}//找到了要插入节点的合适位置cur = new Node(key, value);//申请一个键值为key的节点if (parent->_key < 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->_left;}else if (cur->_key < key){cur = cur->_right;}else{return cur;//找到了}}return cur;//没找到}bool Erase(const K& key){Node* parent = nullptr;Node* cur = _root;while (cur){if (cur->_key > key)//比key大，往左找{parent = cur;cur = cur->_left;}else if (cur->_key < key)//比key小，往右找{parent = cur;cur = cur->_right;}else//找到了{if (cur->_left == nullptr)//被删除节点的左为空{if (_root == cur)//删除根且只有右枝没有左枝{_root = cur->_right;//让根指向它的右}else{if (parent->_left == cur)//父亲的左==cur，把cur的右连接到父亲的左{parent->_left = cur->_right;}else//父亲的右==cur，把cur的右连接到父亲的右{parent->_right = cur->_right;}}delete cur;}else if (cur->_right == nullptr)//被删除节点的右为空{if (_root == cur)//删除根且只有左枝没有右枝{_root = cur->_left;//让根指向它的左}else{if (parent->_left == cur)//父亲的左==cur，把cur的左连接到父亲的左{parent->_left = cur->_left;}else{parent->_right = cur->_left;//父亲的右==cur，把cur的右连接到父亲的左}}delete cur;}else//被删除节点的左右都不为空则用替换法删除即找到一个合适的节点来替他被删（左子树最（大）右，或右子树的最（小）左）{Node* rightMinParent = cur;//右子树最（小）左节点的父亲Node* rightMin = cur->_right;//右子树的最左节点while (rightMin->_left){rightMinParent = rightMin;rightMin = rightMin->_left;}swap(cur->_key, rightMin->_key);//右子树左节点与被删节点的值交换if (rightMinParent->_left == rightMin)//如果rightMinParent的左==rightMin{rightMinParent->_left = rightMin->_right;//则把rightMin的右连接到rightMinParent的左}else//如果rightMinParent的右==rightMin{rightMinParent->_right = rightMin->_right;//则把rightMin的右连接到rightMinParent的右}delete rightMin;}return true;}}return false;}void Inorder(){_Inorder(_root);cout << endl;}~BSTree(){Destory(_root);}private:void _Inorder(const Node* _root){if (_root == nullptr){return;}_Inorder(_root->_left);cout << _root->_key << " -> " << _root->_value << endl;_Inorder(_root->_right);}void Destory(Node*& root){if (root == nullptr)return;Destory(root->_left);Destory(root->_right);delete root;root = nullptr;}private:Node* _root = nullptr;//只有一个成员，给一个缺省参数可以不用自己写构造了};
}