目录

一、什么是搜索二叉树

二、搜索二叉树如何删除数据 

删除的是叶子结点的情况

删除的结点下面仅有一个子节点（托孤）（要删除的结点只有一个孩子）

替换法删除  （要删除的结点有两个个孩子）

三、写一棵搜索二叉树

递归版本的插入

测试代码

四、查找某一个数是否存在于我们的二叉搜索树中

测试代码

递归版本的查找

测试代码

 五、二叉搜索树中删除某一个结点

测试代码

递归版本

测试代码

六、拷贝构造

析构函数

拷贝构造（深拷贝）

测试代码​​​​​​​

赋值

 测试代码

七、搜索二叉树的分析

八、Key的模型和Key/Value模型

1.英文翻译为中文 

 测试代码（简单英翻译中词典）

2.统计出现次数

一、什么是搜索二叉树

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

（每一棵子树都满足上面的特征）

（这样我们的搜索二叉树就非常利于我们的搜索）

比方说我们查找8,8比6大，找右子树，8比9小，找9的左子树，7比8小，找7的右子树，找到了。 

最多的查找次数是树的高度！ 

这样就不是暴力查找了，而是利用了二叉树的特性 

二叉搜索树又被称为是二叉排序树或二叉查找树。  

二、搜索二叉树如何删除数据 

删除的是叶子结点的情况

对于上面的二叉树，如果我们想要删除0,2,4,7,13，其实都是可以直接删除的，不会破坏我们的搜索二叉树的性质。

删除的结点下面仅有一个子节点（托孤）（要删除的结点只有一个孩子）

假如我们要删除14，由于我们的14下面只有一个13，所以我们其实可以将13和14的结点中的数据相互交换，此时我们的14也就被换到了叶子结点的位置，然后我们再直接将当前14的这个结点删除掉就可以了。

（删除的结点左为空，让父亲结点指向我的右子树，删除结点右为空，让父亲结点指向我的左子树）

其实我们上一种情况也可以归纳到我们当前这种情况，也就是我们要删除的是叶子结点的话，比方说我们要删除14下面的13，因为13的左子树为空，我们就直接将13的右子树挂载到我们的14的左子树下面，也就是nullptr，那么我们也是能够将13删掉的

替换法删除  （要删除的结点有两个个孩子）

如果我们想要删除3

（3的位置的数要满足比左子树的最大值大，比右子树的最小值小）

1.左子树的最大节点--2（左子树最右结点）

2.或者右子树的最小节点--4（右子树的最左节点）

与3进行替换，然后将3删除。

替换结点赋值给删除结点后，删除替换节点，替换节点要么没有孩子，要么只有一个孩子（如果我们上面的二叉树的4的右子树中还有一个5），可以直接删除。

三、写一棵搜索二叉树

下面是按照我们上面两个部分的思路写出来的二叉搜索树的主要实现的代码

namespace zhuyuan
{templatestruct BSTreeNode{BSTreeNode* _left;BSTreeNode* _right;K _key;BSTreeNode(const K& key):_left(nullptr),_right(nullptr),_key(key){}};
//这里的k，因为我们在搜索二叉树中将我们判断的依据称之为keytemplateclass BSTree{typedef BSTreeNode 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_right;}else if(cur->_key>key){parent=cur;cur=cur->_left;}else{//如果这个插入的值在这棵树里面已经存在了，就会插入失败。return false;}}//cur只是一个局部变量，处理这个作用域就消失了//所以我们先应该将其父节点挂载当前结点。所以我们在上面的代码中加入了cur的父节点，同步向下移动cur=new Node(key);if(parent->_key_right=cur;}else{parent->_left=cur;}return true;}//套一层无参的去调用有参的，这样我们的_root就不会暴露给外部了。//这里我们的类私有的函数一般都是在名称前面加上“_”，然后如果是共有的函数的话就不加//比方是我们瞎买的呢InOrder()就是共有的，外部可以调用//但是下面的_InOrder就是私有的，外部不可以调用void InOrder(){_InOrder(_root);}private://递归必须要显式地传子树，但是我们的这里的_root又是私有的//所以我们这里将其设置为是私有的，然后我们类内部再给出一个方法去调用中序遍历void _InOrder(Node* root){if(root== nullptr){return;}_InOrder(root->_left);cout<_key<<" ";_InOrder(root->_right);}private:Node * _root= nullptr;};}

测试代码

void TestBSTree1(){BSTree  t;int a[]={8,3,1,10,6,4,7,14,13,4,3,4,4};for(auto e:a){t.Insert(e);}//排序+去重t.InOrder();}

调用测试代码

#include 
#include 
using namespace std;
#include "BinarySearchTree.h"int main()
{zhuyuan::TestBSTree1();return 0;
}

我们观察到我们的二叉搜索树不但中序是有序的，并且还帮助我们完成了去重 

递归版本的插入

    //封装一层，人为将带_的方法放在private属性里面，用不带_的去调用//下面带_其实是在private里面的bool InsertR(const K& key){return _InsertR(_root, key);}//思考这里的root前为啥要加上&bool _InsertR(Node*& root, const K& key){//找到了插入的位置，将我们的结点插入if (root == nullptr){//这个root仅仅是一个局部变量，是一个形参，并没有帮助我们完成插入//还是需要将其和其父亲结点链接在一起//但是我们这里没有父亲怎么办？//是将这里的父亲随着二叉的链条一直往下传。//但是我们只要在我们上面的Node*& root这里加一个引用，//这里取引用的意义就是假设我们现在root的值是空//但是这个root同时也是我们上一层的父节点的子节点的别名//也就是我们直接修改的就是上一层父节点的子节点//所以就成功实现了插入root = new Node(key);return true;}//要插入的结点的值要是比我们当前的结点的key值小，就转换到我们当前结点的左子树去插入if (root->_key < key)return _InsertR(root->_right, key);//要插入的结点的值要是比我们当前的结点的key值大，就转换到我们当前结点的右子树去插入else if (root->_key > key)return _InsertR(root->_left, key);//如果要插入的数据已经存在了，就不插入了，插入失败elsereturn false;}

测试代码

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

    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;}

    void TestBSTree1(){BSTree  t;int a[]={8,3,1,10,6,4,7,14,13,4,3,4,4};for(auto e:a){t.Insert(e);}//        //排序+去重
//        t.InOrder();cout<

    //封装一层，人为将带_的方法放在private属性里面，用不带_的去调用//下面带_其实是在private里面的bool FindR(const K& key){return _FindR(_root, key);}bool _FindR(Node* root, const K& key){//查找不到返回falseif (root == nullptr)return false;//如果我们当前root的_key小于我们的key值，我们就到我们当前结点的右子树中去查找if (root->_key < key)return _FindR(root->_right, key);//如果我们当前root的_key大于我们的key值，我们就到我们当前结点的左子树中去查找else if (root->_key > key)return _FindR(root->_left, key);//找到了我们的想要查找的结点elsereturn true;}

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

    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;}//这里的情况就是cur->_key==key//找到了，开始尝试删除else{// 开始删除// 1、左为空// 2、右为空// 3、左右都不为空//要删除的结点左为空if (cur->_left == nullptr){//如果要删除的是根节点//当前的根节点的左子树是nullptr//所以我们就将根节点变成我们的原先的根节点的右子树if (cur == _root){_root = cur->_right;}else{//如果我要删除的结点是父亲的左节点（要删除的结点左为空）//那么我们就将要删除的结点的右挂载到父亲的左节点if (cur == parent->_left){parent->_left = cur->_right;}else{parent->_right = cur->_right;}}delete cur;cur = nullptr;}//如果要删除的结点右为空else if (cur->_right == nullptr){//如果要删除的是根节点//当前的根节点的右子树是nullptr//所以我们就将根节点变成我们的原先的根节点的左子树if (_root == cur){_root = cur->_left;}else{//如果我要删除的结点为父亲的左节点//将要删除的结点的左节点挂载到父亲的左节点if (cur == parent->_left){parent->_left = cur->_left;}else{//将要删除的结点的左节点挂载到父亲的右节点parent->_right = cur->_left;}}delete cur;cur = nullptr;}//如果要删除的结点左右都不为空//替换法删除//用右子树的最小结点else{// 找到右子树最小节点进行替换//类似于上面的写法//我们的minParent是我们的min的父节点//为了防止我们删除的是根节点的情况，所以我们的minParent不能初始化为nullptr//应该初始化为curNode* minParent = cur;Node* min = cur->_right;while (min->_left){minParent = min;min = min->_left;}//将当前的要删除的位置的结点的值和右子树的最大值进行交换swap(cur->_key, min->_key);//如果我们右子树的最小值的结点是其父节点的左结点//那么我们这里就直接进行（托孤）操作//因为我们这里min已经是当前右子树中数值最小的结点了，那么其不可能还有左子树，因为左子树的结点会比我们的根节点要小！//所以我们的min只可能是右子树还有结点//和我们上面的操作方案一样，就是将min结点的右子树挂载到我们的父节点左结点上if (minParent->_left == min)minParent->_left = min->_right;//如果我们的min结点是其父节点的右结点，那么我们就将我们min的右子树挂载到我们的父节点的右子树上elseminParent->_right = min->_right;//将我们的min结点删除掉。delete min;}//删除成功return true;}}//删除失败return false;}

    void TestBSTree1(){BSTree  t;int a[]={8,3,1,10,6,4,7,14,13,4,3,4,4};for(auto e:a){t.Insert(e);}//        //排序+去重t.InOrder();cout<

        bool EraseR(const K& key){return _EraseR(_root, key);}//递归版本的删除//思考这里的root前为啥要加上引用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{//root就是我们要删除的结点Node* del = root;//root的左子树为空，就将当前root的右子树挂载到上层的root的子树上if (root->_left == nullptr)//由于我们上面的定义的时候我们的root前有&，所以我们这里//这的root是上一层root的孩子指针的别名//所以修改的话，就可以直接修改//不需要再像我们的非递归版本一样再设置一个父节点用来挂载子节点root = root->_right;//root的右子树为空，就将当前root的左子树挂载到上层的root的子树上else if (root->_right == nullptr)root = root->_left;else{// 找右树的最左节点替换删除Node* min = root->_right;while (min->_left){min = min->_left;}//交换要删除的节点的值和其右子树的值最小结点的值swap(root->_key, min->_key);//下面这种写法是错的//return EraseR(key);  错的//因为我们在交换过之后，我们原先的整一棵搜索二叉树已经不满足搜索二叉树的结构了，很可能这里就找不到了！//（我们当前要删除的结点的值已经大于其右子树的值最小的结点的值了！）//递归删除我们的交换过之后的结点//因为我们当前的要删掉的位置是我们的交换过之后的原先要被删除的结点的右子树当中的最小值的结点，//右子树的最小值的结点是不可能有左子树的，因为左子树一定会比当前的位置的节点的值小//所以我们这里将右子树传进去//然后这个key也就是我们原先要删除的结点的值//交换过之后我们的这个key值也被交换到了我们的原先的结点的右子树的值最小的结点//并且这里我们递归调用的话，我们root->right的这棵子树还是满足二叉搜索树的结构的！//因为我们的要删除的结点原本就是要比其右子树中的值最小的结点小的！//所以我们将要删除的结点值和其右子树最小的值进行交换值的话，我们的要删除的结点的右子树依旧满足搜索二叉树的结构！//并且这里我们由于引用的原因，我们不用再设置一个父节点去挂载我们的子节点//所以我们这里直接按照下面这样写就可以了return _EraseR(root->_right, key);}delete del;return true;}}

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

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

    ~BSTree(){_Destory(_root);}void _Destory(Node*& root){if (root == nullptr){return;}//    先销毁左节点，然后销毁右节点，最后销毁root结点，后序_Destory(root->_left);_Destory(root->_right);delete root;root = nullptr;}

    // C++的用法：强制编译器生成默认的构造BSTree() = default;BSTree(const BSTree& t){_root = _Copy(t._root);}//按照树形结构去拷贝Node* _Copy(Node* root){//如果是空，就直接return空if (root == nullptr){return nullptr;}//插入同样的值，顺序不同我们的树的形状就会发生变化//所以我们这里需要采用先序遍历的形式去拷贝我们的搜索二叉树//为copy树创建新的结点//遇到左子树拷贝左子树，遇到右子树拷贝左子树Node* copyRoot = new Node(root->_key);copyRoot->_left = _Copy(root->_left);copyRoot->_right = _Copy(root->_right);//返回拷贝的结点return copyRoot;}

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

        // t2 = t1BSTree& operator=(BSTree t){swap(_root, t._root);return *this;}

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

//在树里面将K和V绑定存到一起去templatestruct BSTreeNode{BSTreeNode* _left;BSTreeNode* _right;K _key;V _value;BSTreeNode(const K& key, const V& value):_left(nullptr), _right(nullptr), _key(key), _value(value){}};templateclass BSTree{typedef BSTreeNode 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 = 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){//...return true;}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);}private:Node* _root = nullptr;};

void TestBSTree1(){//string对象也是支持比较大小的，就是按照字符串的ASC码进行比较BSTree dict;dict.Insert("sort", "排序");dict.Insert("left", "左边");dict.Insert("right", "右边");dict.Insert("string", "字符串");dict.Insert("insert", "插入");dict.Insert("erase", "删除");string str;//输入一个单词进行查找//用英文查找中文//只要有输入就会执行while (cin >> str){BSTreeNode* ret = dict.Find(str);if (ret){cout << "对应的中文:" << ret->_value << endl;}else{cout << "对应的中文->无此单词" << endl;}}}

void TestBSTree2(){string arr[] = { "香蕉", "苹果", "香蕉", "草莓", "香蕉", "苹果", "苹果", "苹果" };BSTree countTree;for (auto& str : arr){//BSTreeNode* ret = countTree.Find(str);auto ret = countTree.Find(str);if (ret){ret->_value++;}else{countTree.Insert(str, 1);}}countTree.InOrder();}