Binary_Seach_Tree(BST) C++

Wiki：二叉查找树（英语：Binary Search Tree），也称为二叉搜索树、有序二叉树（ordered binary tree）或排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
2. 若任意节点的右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值；
3. 任意节点的左、右子树也分别为二叉查找树

总的来说：《c++ primr 5th》每次看都觉得厉害

1、shared_ptr 是真的香

2、template 友元用的时候在看

3、函数传递：指针形参属于传值（拷贝），shared_ptr引用传递 没必要：动态内存（猜测）

4、cosnt 成员函数适用：不能把this指针 绑定到常量对象（如const double pi = 3.14）:return pi;

具体学习到什么 看code注释

#pragma once
//编译器需要掌握函数模板或模板成员函数的定义：成员函数定义 也在头文件中
//成员函数定义在类外使用默认实参 报错：不允许使用默认参数（原因还未知）
//原因：非静态数据成员不能作为默认实参：因为它的值本身属于对象的一部分，
//这么做的结果是：无法真正提供一个对象以便从中获取成员的值

 /*
 指针传递：形参是指针的拷贝，两个指针是不同的指针 但是可以间接修改所指向对象的值
 尽量使用引用传递：避免拷贝的效率和空间
 尽量使用值初始化：避免多余默认初始化
 type* & ：指向指针的引用 ：引用本身不是对象所以不能定义指向引用的指针
 =运算符在结点上的意义是什么？ 指针之间的赋值操作：所以不需要定义赋值运算符不是类之间操作
 类的行为像指针：共享状态 最好的方法是使用shared_ptr
 */

#include<iostream>
#include<memory> //shared_ptr
template<typename T> class BST;//前置声明：友元所需要
template<typename T>
//在Tree_Note类内：直接使用模板名而不提供实参：Tree_Note = Tree_Note<T>
class Tree_Note
{
    friend class BST<T>;//每个Tree_Note实例将访问权限授予用相同类型实例化的BST
public:
    //构造函数
    Tree_Note(const T& _key = T())
        :left(nullptr), right(nullptr), parent(nullptr),key(_key){}
    /*
    stack overflow why??? 
    答：make_shared 调用Tree_Note构造函数则造成无线循环
        而用内置已经存在构造函数的则不会 ：data(make_shared<vector<string>>()):data = ""
        :left(std::make_shared<Tree_Note>()),
        right(std::make_shared<Tree_Note>()), parent(std::make_shared<Tree_Note>()),key(_key) {}
    */
    /* 没用上拷贝构造
    //为了与内置运算符一致：返回指向左侧运算对象的引用:
    decltype(auto) operator=(std::make_ptr<Tree_Note> right)
    {//decltype(auto)详见：《Effective Modern C++》P31
        key = right.key;
        return maked_shared<Tree_Note>(*this);
    }
    */
private:
    T key;
    std::shared_ptr<Tree_Note> left;
    std::shared_ptr<Tree_Note> right;
    std::shared_ptr<Tree_Note> parent;
};

template<typename T>
class BST
{
public:
    //若root(nullptr) 则：报错访问内存受限
    BST() :root(nullptr) {} //若使用构造函数则 root.key = 0
    //中序遍历
    void Iorder_Tree_Walk(const std::shared_ptr<Tree_Note<T>> x);
    void Iorder_Tree_Walk() {Iorder_Tree_Walk(root);}
    //递归查找
    std::shared_ptr<Tree_Note<T>> Tree_Search(const T& key,const std::shared_ptr<Tree_Note<T>> x);
    bool Tree_Seach(const T& key)
    {
        auto p = Tree_Search(key, root);
        if (p != nullptr)
            return true;
        else
            return false;
    }
    //迭代查找:对于大多数计算机，迭代版本的效率要高的多 ：调用函数开销
    std::shared_ptr<Tree_Note<T>> Iterative_Tree_Search(const T& key,std::shared_ptr<Tree_Note<T>> x);
    bool Iterative_Tree_Search(const T& key)
    {
        auto p = Iterative_Tree_Search(key, root);
        if (p != nullptr)
            return true;
        else
            return false;
    }

    //最小值
    std::shared_ptr<Tree_Note<T>> Tree_Minimum(std::shared_ptr<Tree_Note<T>> x);
    T Tree_Minimum()
    {
        auto p = Tree_Minimum(root);
        return p->key;
    }
    //最大值
    std::shared_ptr<Tree_Note<T>> Tree_Maximum(std::shared_ptr<Tree_Note<T>> x);
    T Tree_Maximum() 
    {
        auto p = Tree_Maximum(root);
        return p->key;
    }

    //后继和前驱:最接近（大小）该节点的大、小节点
    std::shared_ptr<Tree_Note<T>> Tree_Successor(std::shared_ptr<Tree_Note<T>> x);
    std::shared_ptr<Tree_Note<T>> Tree_Predecessor(std::shared_ptr<Tree_Note<T>> x);

    //插入和删除
    void Tree_Insert(std::shared_ptr<Tree_Note<T>> z); //当为空树是z要赋值给root 而root不能是const,所以z不是const
    void Tree_Insert(const T& key)
    {
        auto z = std::make_shared<Tree_Note<T>>(key);
        Tree_Insert(z);
    }
    void Tree_Delete(std::shared_ptr<Tree_Note<T>> z);
    void Tree_Delete(const T& key)
    {
        auto z = Iterative_Tree_Search(key, root);
        if (z == nullptr)
            std::cerr << "nodata!";
        Tree_Delete(z);
    }
private:
    std::shared_ptr<Tree_Note<T>> root;
    //移植节点 :u = v(不包括左右孩子)
    void Transplant(std::shared_ptr<Tree_Note<T>> u, std::shared_ptr<Tree_Note<T>> v)
    {
        //指针给指针赋值：右侧地址赋值给左侧地址（指针存储的是地址） 
        if (u->parent == nullptr) //如果u是根节点
            root = v;
        //都用 v替代u了 u的父节点不也被替代了么?---属于指针的赋值而不是类所以不用定于赋值运算符
        else if (u == u->parent->left) //如果U是左孩子
            u->parent->left = v;
        else
            u->parent->right = v;        
        if (v->parent != nullptr)
            v->parent = u->parent;//不改变被替换树的上层
    }
};

//成员函数定义在类外使用默认实参 报错：不允许使用默认参数
//原因(P271 《c++ prime 5th》)：非静态数据成员不能作为默认实参：因为它的值本身属于对象的一部分，
//这么做的结果是：无法真正提供一个对象以便从中获取成员的值

//递归查找
template<typename T>
std::shared_ptr<Tree_Note<T>> 
BST<T>::Tree_Search(const T& key,const std::shared_ptr<Tree_Note<T>> x)
{
    if (x == nullptr || key == x->key)
        return x;
    if (key < x->key)//在左侧子树
        return Tree_Search(key,x->left);
    else//右侧子树
        return Tree_Search(key,x->right);
}
//迭代查找:对于大多数计算机，迭代版本的效率要高的多 ：调用函数开销
template<typename T>
std::shared_ptr<Tree_Note<T>>
BST<T>::Iterative_Tree_Search(const T& key,std::shared_ptr<Tree_Note<T>> x)
{
    while (x != nullptr && key != x->key)
    {
        if (key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    return x;
}
//中序遍历
template<typename T>
void BST<T>::Iorder_Tree_Walk(const std::shared_ptr<Tree_Note<T>> x)
{
    if (x != nullptr)
    {
        Iorder_Tree_Walk(x->left);
        std::cout << x->key << " ";
        Iorder_Tree_Walk(x->right);
    }
}
//最小值
template<typename T>
std::shared_ptr<Tree_Note<T>>
BST<T>::Tree_Minimum(std::shared_ptr<Tree_Note<T>> x)
{
    while (x->left != nullptr)
        x = x->left;
    return x;
}
//最大值
template<typename T>
std::shared_ptr<Tree_Note<T>>
BST<T>::Tree_Maximum(std::shared_ptr<Tree_Note<T>> x)
{
    while (x->right != nullptr)
        x = x->right;
    return x;
}
//后继和前驱
template<typename T>
std::shared_ptr<Tree_Note<T>>
BST<T>::Tree_Successor(std::shared_ptr<Tree_Note<T>> x)
{
    if (x->right != nullptr) // 对接近大于x的节点 处在右子树中最小值
        return Tree_Minimum(x->right);
    //从x开始向上寻找节点：该结点不是父节点的右孩子 （如果是右孩子则x.right不会为空）
    auto y(x->parent);
    while (y != nullptr && x == y->right)
    {
        x = y;
        y = y->parent;
    }
    return y;//第一个不是右孩子的节点
}
template<typename T>
std::shared_ptr<Tree_Note<T>> 
BST<T>::Tree_Predecessor(std::shared_ptr<Tree_Note<T>> x)
{
    if (x->left != nullptr)
        return Tree_Maximum(x->right);
    auto y = x->parent;
    while (y != nullptr && x == y->left)
    {
        x = y;
        y = y->parent;
    }
    return y;
}

//插入和删除
template<typename T>
void BST<T>::Tree_Insert(std::shared_ptr<Tree_Note<T>> z)
{
    //临时量用于确定z位置：不要调用make_shared 则不满足 !=nullptr 为空树时条件
    std::shared_ptr<Tree_Note<T>> y = nullptr;
//    auto y = std::make_shared<Tree_Note<T>>();
    auto x(root);
    //当x为空时，x就是待插入的位置
    while (x != nullptr) 
    {
        y = x;
        if (z->key < x->key)
            x = x->left;
        else//包括相等的情况 具有稳定性：后插入的在右边
            x = x->right;
    }
    z->parent = y;
    if (y == nullptr)
        root = z;
    else if (z->key < y->key)
        y->left = z;
    else
        y->right = z;
}

template<typename T>
void BST<T>::Tree_Delete(std::shared_ptr<Tree_Note<T>> z)
{
    if (z->left == nullptr) //(a)
        Transplant(z, z->right);
    else if (z->right == nullptr) //(b)
        Transplant(z, z->left);
    else
    {
        auto y = Tree_Minimum(z->right);
        if (y->parent != z) //(c):y不是z的右孩子 
        {
            Transplant(y, y->right);
            y->right = z->right;
            y->right->parent = y;
        }
        //(d):y是z的右孩子 且y,left == nullptr 如果y的左孩子不是空则 y不是z的后继
        Transplant(z, y);
        y->left = z->left; //y的左孩子（拼接）指向被删除点z的左孩子
        y->left->parent = y; //相当于 z = y
    }
}

main

#include<iostream>
#include<vector>
#include"Binary_Seach_Tree.h"
using namespace std;

void BSTree()
{
    vector<int> vi{ 1,2,5,8,6,9,6 };
    BST<int> t;
    //插入
    for (auto i = 0;i != vi.size();++i)
        t.Tree_Insert(vi[i]);
    cout << "中序遍历" << endl;
    t.Iorder_Tree_Walk();
    cout << endl;
    cout << "最大值" << endl;
    cout << t.Tree_Maximum() << endl;
    cout << "最小值" << endl;
    cout << t.Tree_Minimum() << endl;
    cout << "查找" << endl;
    cout << boolalpha << t.Tree_Seach(8) << endl;
    cout << "删除" << endl;
    t.Tree_Delete(8);
    cout << boolalpha << t.Iterative_Tree_Search(8) << endl;
}


int main()
{
    BSTree();
    return 0;
}

删除：form 《算法导论》 P167

关于其他操作请看二叉查找树(二)之 C++的实现