锟斤拷锟斤拷位锟矫ｏ拷锟斤拷页 > 锟斤拷锟斤拷锟教筹拷 > 锟教筹拷 > BST 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 BinarySearchTree C++实锟斤拷(锟捷癸拷/锟角递癸拷)

BST 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 BinarySearchTree C++实锟斤拷(锟捷癸拷/锟角递癸拷)

锟斤拷源锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷|锟斤拷时锟戒：2024-08-21 10:22:09 |锟斤拷锟侥讹拷锟斤拷192锟斤拷|锟斤拷锟斤拷签锟斤拷 a T S C in AR 锟斤拷锟斤拷 EA c++ 锟斤拷 |锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷

锟斤拷锟斤拷锟斤拷戏

目录锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟筋常锟矫斤拷锟斤拷锟斤拷途锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟杰凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥诧拷锟斤拷锟斤拷锟揭诧拷锟斤拷删锟斤拷锟斤拷锟斤拷实锟斤拷BSTree.hpptest.cc 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷(BST,Binary Search Tree) 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟街称讹拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷一锟矫匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟角撅拷锟斤拷锟斤拷锟斤拷锟斤拷锟绞的讹拷锟斤拷锟斤拷: 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为锟斤拷

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷

锟斤拷锟斤拷锟斤拷锟斤拷

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷(BST,Binary Search Tree)

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟街称讹拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷一锟矫匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟角撅拷锟斤拷锟斤拷锟斤拷锟斤拷锟绞的讹拷锟斤拷锟斤拷:

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为锟秸ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫节碉拷锟街碉拷锟叫★拷诟锟斤拷诘锟斤拷值
锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为锟秸ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫节碉拷锟街碉拷锟斤拷锟斤拷诟锟斤拷诘锟斤拷值
锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷也锟街憋拷为锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷

BST 二叉搜索树 BinarySearchTree C++实现(递归/非递归)

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷/锟斤拷锟斤拷锟斤拷锟斤拷锟揭诧拷贫锟斤拷锟斤拷锟斤拷锟斤拷锟�,锟斤拷为锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷

锟斤拷锟矫斤拷锟斤拷

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷一锟斤拷小锟节革拷,锟斤拷锟斤拷锟斤拷一锟斤拷锟斤拷锟节革拷, 锟斤拷隙锟斤拷锟捷癸拷锟斤拷锟斤拷 锟斤拷锟皆得碉拷

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭节碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟节碉拷,锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭节碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟节碉拷.
锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诘锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫★拷诘锟�,锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诘锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫★拷诘锟�.
锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷诘锟�,锟斤拷锟节碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭节碉拷

锟斤拷途

实锟斤拷锟斤拷锟斤拷锟斤拷锟街憋拷锟绞癸拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�,锟斤拷锟角革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥革拷效锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷锟斤拷锟斤拷为实锟矫的高斤拷锟斤拷锟捷结构,锟斤拷锟斤拷平锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�(AVL锟斤拷,锟斤拷锟斤拷锟�)锟斤拷...

K模锟酵ｏ拷K模锟酵硷拷只锟斤拷key锟斤拷为锟截硷拷锟诫，锟结构锟斤拷只锟斤拷要锟芥储Key锟斤拷锟缴ｏ拷锟截硷拷锟诫即为锟斤拷要锟斤拷锟斤拷锟斤拷锟斤拷值锟斤拷( 锟节诧拷锟斤拷 锟斤拷锟斤拷锟斤拷)
锟斤拷锟界：锟斤拷一锟斤拷锟斤拷锟斤拷word锟斤拷锟叫断该碉拷锟斤拷锟角凤拷拼写锟斤拷确锟斤拷锟斤拷锟藉方式锟斤拷锟铰ｏ拷
锟皆词匡拷锟斤拷锟斤拷锟叫碉拷锟绞硷拷锟斤拷锟叫碉拷每锟斤拷锟斤拷锟斤拷锟斤拷为key锟斤拷锟斤拷锟斤拷一锟矫讹拷锟斤拷锟斤拷锟斤拷锟斤拷
锟节讹拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫硷拷锟斤拷锟矫碉拷锟斤拷锟角凤拷锟斤拷冢锟斤拷锟斤拷锟斤拷锟狡葱达拷锟饺凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟狡葱达拷锟斤拷锟�

锟斤拷锟斤拷锟斤拷:锟脚斤拷系统,锟斤拷锟斤拷系统锟斤拷...

KV模锟酵ｏ拷每一锟斤拷锟截硷拷锟斤拷key锟斤拷锟斤拷锟斤拷锟斤拷之锟斤拷应锟斤拷值Value锟斤拷锟斤拷锟侥硷拷值锟皆★拷锟斤拷锟街凤拷
式锟斤拷锟斤拷实锟斤拷锟斤拷锟叫非筹拷锟斤拷锟斤拷锟斤拷 ( 通锟斤拷一锟斤拷值锟斤拷锟斤拷锟斤拷一锟斤拷值 )
锟斤拷锟斤拷英锟斤拷锟绞碉拷锟斤拷锟接拷锟斤拷锟斤拷锟斤拷牡亩锟接︼拷锟较碉拷锟酵拷锟接拷目锟斤拷钥锟斤拷锟斤拷业锟斤拷锟斤拷锟斤拷应锟斤拷锟斤拷锟侥ｏ拷英
锟侥碉拷锟斤拷锟斤拷锟斤拷锟接︼拷锟斤拷锟斤拷锟�锟酵癸拷锟斤拷一锟街硷拷值锟皆ｏ拷
锟劫憋拷锟斤拷统锟狡碉拷锟绞达拷锟斤拷锟斤拷统锟狡成癸拷锟襟，革拷锟斤拷锟斤拷锟绞就可匡拷锟斤拷锟揭碉拷锟斤拷锟斤拷值拇锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
锟街达拷锟斤拷锟斤拷锟斤拷锟酵癸拷锟斤拷一锟街硷拷值锟皆★拷

锟斤拷锟斤拷锟斤拷:通讯录

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟杰凤拷锟斤拷

锟斤拷锟斤拷锟缴撅拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷炔锟斤拷遥锟斤拷锟斤拷锟叫э拷蚀锟斤拷锟斤拷硕锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷懈锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷堋锟�

锟斤拷锟斤拷n锟斤拷锟斤拷锟侥讹拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷每锟斤拷元锟截诧拷锟揭的革拷锟斤拷锟斤拷龋锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷平锟斤拷锟斤拷锟揭筹拷锟斤拷锟角斤拷锟斤拷诙锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟饺的猴拷锟斤拷锟斤拷锟斤拷锟斤拷锟皆斤拷睿拷锟饺较达拷锟斤拷越锟洁。
锟斤拷锟斤拷锟斤拷同一锟斤拷锟截硷拷锟诫集锟较ｏ拷锟斤拷锟斤拷锟斤拷丶锟斤拷锟斤拷锟斤拷拇锟斤拷锟酵拷锟斤拷锟斤拷艿玫锟斤拷锟酵拷峁癸拷亩锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�

BST 二叉搜索树 BinarySearchTree C++实现(递归/非递归)

锟斤拷锟斤拷锟斤拷锟斤拷拢锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟轿拷锟饺拷锟斤拷锟斤拷锟�(锟斤拷锟竭接斤拷锟斤拷全锟斤拷锟斤拷锟斤拷)锟斤拷锟斤拷平锟斤拷锟饺较达拷锟斤拷为锟斤拷$log_2 N$ ( $log_2 N$ )
锟斤拷锟斤拷锟斤拷锟铰ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟剿伙拷为锟斤拷支锟斤拷(锟斤拷锟斤拷锟斤拷锟狡碉拷支)锟斤拷锟斤拷平锟斤拷锟饺较达拷锟斤拷为锟斤拷$\frac{N}{2}$ ( $\frac{N}{2}$ )

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥诧拷锟斤拷

锟斤拷锟斤拷

锟接革拷锟斤拷始锟饺较ｏ拷锟斤拷锟揭ｏ拷锟饺革拷锟斤拷锟斤拷锟斤拷锟揭憋拷锟竭诧拷锟揭ｏ拷锟饺革拷小锟斤拷锟斤拷锟斤拷锟斤拷卟锟斤拷摇锟�
锟斤拷锟斤拷锟揭高度次ｏ拷锟竭碉拷锟斤拷锟秸ｏ拷锟斤拷没锟揭碉拷锟斤拷锟斤拷锟街碉拷锟斤拷锟斤拷凇锟�

锟斤拷锟斤拷

锟斤拷为锟秸ｏ拷锟斤拷直锟斤拷锟斤拷锟斤拷锟节点，锟斤拷值锟斤拷root指锟斤拷(锟斤拷一锟斤拷锟节碉拷锟斤拷锟絩oot)
锟斤拷锟斤拷锟秸ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟绞诧拷锟揭诧拷锟斤拷位锟矫ｏ拷锟斤拷锟斤拷锟铰节碉拷

BST 二叉搜索树 BinarySearchTree C++实现(递归/非递归)

锟截憋拷锟�

同锟斤拷一锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷顺锟斤拷同,锟矫碉拷锟侥讹拷锟斤拷锟斤拷也锟斤拷同
锟斤拷锟斤拷锟斤拷锟街碉拷汛锟斤拷锟绞�,锟斤拷锟斤拷失锟斤拷(锟斤拷锟斤拷锟斤拷multi)

删锟斤拷

锟斤拷锟饺诧拷锟斤拷元锟斤拷锟角凤拷锟节讹拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷冢锟斤拷蚍祷锟�.

锟斤拷锟斤拷,锟斤拷锟斤拷锟斤拷锟侥结构锟斤拷锟斤拷,锟斤拷锟皆得碉拷3锟斤拷锟斤拷锟�

要删锟斤拷锟侥斤拷锟斤拷藓锟斤拷咏锟斤拷
要删锟斤拷锟侥斤拷锟街伙拷锟斤拷锟斤拷踊锟斤拷液锟斤拷锟绞�
要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷液锟斤拷咏锟斤拷

锟斤拷锟斤拷锟斤拷锟叫达拷删锟斤拷锟节碉拷锟斤拷4锟斤拷锟斤拷锟斤拷锟绞碉拷锟斤拷锟斤拷:

要删锟斤拷锟侥斤拷锟斤拷藓锟斤拷咏锟斤拷时,直锟斤拷删锟斤拷
要删锟斤拷锟侥斤拷锟街伙拷锟斤拷锟斤拷踊锟斤拷液锟斤拷锟绞�,锟斤拷锟斤拷锟接伙拷锟揭猴拷锟接革拷锟斤拷锟斤拷
1. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟角革拷锟阶碉拷锟斤拷锟接伙拷锟斤拷锟斤拷锟揭猴拷锟斤拷,锟斤拷2*2锟斤拷锟斤拷锟�(要删锟斤拷锟侥斤拷锟斤拷歉锟斤拷椎锟斤拷锟斤拷踊锟斤拷液锟斤拷锟�)
2. 锟斤拷锟揭猴拷锟接讹拷锟角匡拷时,也锟斤拷锟斤拷锟斤拷锟�,锟斤拷丝锟斤拷院喜锟斤拷藓锟斤拷咏锟斤拷锟斤拷锟�
3. 锟斤拷1锟斤拷前锟斤拷锟斤拷,恰锟斤拷锟角革拷锟节碉拷,也锟斤拷一锟斤拷锟斤拷锟�(锟斤拷锟斤拷锟斤拷一锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷)
要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷液锟斤拷锟�(锟斤拷锟斤拷)时,锟斤拷要锟斤拷一锟斤拷锟斤拷要锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷也要锟斤拷锟斤拷锟斤拷锟斤拷小锟侥节碉拷锟斤拷锟斤拷锟斤拷.

锟斤拷锟斤拷 锟捷归定锟斤拷 锟斤拷知,只锟斤拷锟斤拷锟接碉拷锟斤拷锟揭斤拷锟斤拷锟揭猴拷锟接碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�,锟斤拷选一锟斤拷锟斤拷

锟斤拷选锟斤拷使锟斤拷锟揭猴拷锟接碉拷锟斤拷锟斤拷锟斤拷时,锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�(锟斤拷锟角诧拷锟角革拷锟睫癸拷)
1. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟角★拷锟斤拷锟揭撅拷锟斤拷锟斤拷锟斤拷液锟斤拷锟�.
2. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟矫伙拷锟斤拷液锟斤拷锟�.
3. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟斤拷锟斤拷液锟斤拷锟�
  
  (锟斤拷图锟斤拷锟斤拷锟斤拷锟斤拷)

锟斤拷锟斤拷实锟斤拷

BSTree.hpp

template
struct BSTreeNode {
    BSTreeNode* _left;
    BSTreeNode* _right;
    K _key;

    BSTreeNode(K key) 
    :_key(key),_left(nullptr),_right(nullptr)
    {}
};

template
class BSTree {
public:
    using Node = BSTreeNode;
    BSTree() = default;
    BSTree(const BSTree& bst) {
        _root = Copy(bst._root);
    }
    BSTree& operator=(BSTree bst) { //锟斤拷锟斤拷锟斤拷锟斤拷
        swap(_root,bst.root);
        return *this;
    }
    ~BSTree() {
        Destroy(_root);
    }

public:
    bool Insert(const K& key) {
        if (_root == nullptr) {
            _root = new Node(key);
            _root->_key = key;
            return true;
        }
        BSTreeNode* cur = _root;
        BSTreeNode* parent = _root;
        while (cur) {
            if (key < cur->_key) {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key) {
                parent = cur;
                cur = cur->_right;
            }
            else {
                return false;
            }
        }
        //锟竭筹拷循锟斤拷,说锟斤拷锟斤拷锟叫诧拷锟斤拷锟节该节碉拷, 锟斤拷锟皆诧拷锟斤拷
        cur = new BSTreeNode(key);
        if (key < parent->_key) {

            parent->_left = cur;
        }
        else {
            parent->_right = cur;
        }
        return true;
    }

    bool Find(const K& key) {
        if (_root == nullptr) return false;

        Node* cur = _root;
        while (cur) {
            if (key < cur->_key) {
                cur = cur->_left;
            }
            else if (key > cur->_key) {
                cur = cur->_right;
            }
            else {
                return true;
            }
        }
        // 锟斤拷循锟斤拷锟斤拷锟斤拷,说锟斤拷没锟斤拷锟斤拷
        return false;
    }

    bool Erase(const K& key) {
        if (_root == nullptr) return false;

        Node* cur = _root;
        Node* parent = _root;

        while (cur) {
            if (key < cur->_key) {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key) {
                parent = cur;
                cur = cur->_right;
            }
            else {
                //没锟斤拷锟斤拷锟斤拷
                if (cur->_left == nullptr) {
                    if (cur == _root) {
                        _root = cur->_right;
                    }
                    else if (parent->_left == cur) {
                        parent->_left = cur->_right;
                    }
                    else {
                        parent->_right = cur->_right;
                    }
                    delete cur;
                    return true;
                }
                //没锟斤拷锟揭猴拷锟斤拷
                else if (cur->_right == nullptr) {
                    if (cur == _root) {
                        _root = cur->_left;
                    }
                    if (parent->_left == cur) {
                        parent->_left = cur->_left;
                    }
                    else {
                        parent->_right = cur->_left;
                    }
                    delete cur;
                    return true;
                }
                //锟斤拷锟斤拷锟揭猴拷锟斤拷
                else {
                    //锟斤拷锟揭猴拷锟斤拷(锟斤拷锟斤拷)锟斤拷锟斤拷小锟斤拷锟�/锟斤拷锟斤拷锟斤拷
                    Node* rightMin = cur->_right;  //锟斤拷确锟斤拷为锟斤拷
                    Node* rightMinParent = cur;
                    while (rightMin->_left) {
                        rightMinParent = rightMin;
                        rightMin = rightMin->_left;
                    }
                    // 删锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟斤拷锟�3锟斤拷锟斤拷锟�(锟斤拷锟角诧拷锟角革拷锟睫癸拷)
                    //1. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫★拷锟斤拷恰锟斤拷锟斤拷锟皆硷拷锟斤拷锟揭猴拷锟斤拷.
                    //2. 要删锟斤拷锟侥斤拷锟斤拷锟揭猴拷锟接碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷没锟斤拷锟揭猴拷锟斤拷.
                    //3. 要删锟斤拷锟侥斤拷锟斤拷锟揭猴拷锟接碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟揭猴拷锟斤拷.
                    //锟斤拷锟桔斤拷锟斤拷: 锟斤拷锟斤拷删锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷,锟斤拷锟斤拷删锟斤拷rightMin锟斤拷锟斤拷
                    K tmp = rightMin->_key;
                    Erase(rightMin->_key); //只锟杰从革拷锟斤拷始锟斤拷锟斤拷,锟斤拷锟斤拷锟斤拷失,锟斤拷锟角讹拷锟街诧拷锟揭很匡拷,锟斤拷失锟斤拷锟斤拷(锟斤拷锟斤拷锟斤拷锟�,BST只学习锟斤拷)
                    cur->_key = tmp;
                    return true;
                } //锟斤拷锟斤拷锟揭猴拷锟接碉拷锟斤拷锟� 
            } //锟揭碉拷锟斤拷_锟斤拷锟斤拷锟斤拷锟斤拷锟侥癸拷锟斤拷
        }//循锟斤拷锟揭的癸拷锟斤拷
        //循锟斤拷锟斤拷锟斤拷,说锟斤拷没锟揭碉拷
        return false;
    }//Erase [end]

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

    bool InsertR(const K& key) {
        _InsertR(_root, key);
    }

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

private:

    //锟剿达拷锟斤拷锟斤拷值锟斤拷锟斤拷使锟斤拷指锟斤拷锟斤拷锟斤拷,锟斤拷然一锟斤拷锟斤拷锟斤拷驴锟斤拷锟绞癸拷锟�(锟斤拷锟狡硷拷),锟斤拷锟斤拷目前锟斤拷锟斤拷锟斤拷锟矫匡拷值.
    Node* Copy(const 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;
    }

    //锟矫诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷谓,锟斤拷习锟斤拷锟斤拷锟斤拷锟斤拷
    //(锟斤拷锟斤拷锟接节碉拷时,锟斤拷锟节碉拷锟斤拷锟斤拷锟斤拷员锟斤拷锟轿拷锟斤拷锟街革拷锟�,锟斤拷锟角斤拷锟斤拷锟斤拷锟斤拷锟斤拷也要锟斤拷锟斤拷锟斤拷,指锟斤拷锟斤拷锟揭诧拷锟街拷锟斤拷锟�)
    void Destroy(Node*&root) {
        if (root == nullptr) {
            return ;
        }
        Destroy(root->_left);
        Destroy(root->_right);

        std::cout<_key<<" ";
        delete root; //锟酵放硷拷锟皆讹拷锟矫匡拷
    }

    //锟斤拷习锟捷癸拷+锟斤拷锟斤拷 -- 锟斤拷锟斤拷锟斤拷蛹锟斤拷
    bool _EraseR(Node*& root, const K&key) {
        //锟竭碉拷锟斤拷,说锟斤拷没锟揭碉拷,锟斤拷锟斤拷false
        if (root == nullptr) {
            return false;
        }

        //锟斤拷锟斤拷锟斤拷锟揭憋拷,小锟斤拷锟斤拷锟斤拷锟�
        if (key > root->_key) {
            return _EraseR(root->_right,key);
        }
        else if(key_key) {
            return _EraseR(root->_left,key);
        }
        //锟揭碉拷锟斤拷
        else {
            if (root->_left == nullptr) {
                Node* del = root;
                root = root->_right;
                delete del;
                return true;
            }
            else if (root->_right == nullptr) {
                Node* del = root;
                root = root->_left;
                delete del;
                return true;
            }
            //锟斤拷锟斤拷锟揭猴拷锟斤拷
            else {
                Node* leftMax = root->_left;
                //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
                while (leftMax->_right) {
                    leftMax = leftMax->_right;
                }
                std::swap(root->_key, leftMax->_key);
                return _EraseR(root->_left, key);    //直锟接达拷锟斤拷锟接匡拷始锟捷癸拷删锟斤拷.
            }
        }

    }

    //锟斤拷习锟捷癸拷+锟斤拷锟斤拷指锟斤拷锟斤拷娣�,锟斤拷锟斤拷习
    bool _InsertR(Node*& root, const K& key) { //锟斤拷锟矫碉拷锟斤拷锟斤拷,锟斤拷栈帧直锟接凤拷锟斤拷实锟斤拷
        if (root == nullptr) {
            root == new Node(key);
            return true;
        }
        if (key == root->_key) return false;
        return (key > root->_key) ? _InsertR(root->_right, key) : _InsertR(root->_left, key);
    }

    void _InOrder(Node* root) {
        if (root == nullptr)  return;
        _InOrder(root->_left);
        std::cout << root->_key << " ";
        _InOrder(root->_right);
    }

private:
    BSTreeNode* _root = nullptr;
};

test.cc

void test() {
    int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    BSTree bst;
    for (int i : a) {
        bst.Insert(i);
    }
    bst.InOrder();

    ////Find
    //std::cout << std::boolalpha << bst.Find(8) << std::endl; //true
    //std::cout << std::boolalpha << bst.Find(9) << std::endl; //false

    BSTree cp(bst);
    cp.InOrder();

    //锟斤拷锟斤拷锟斤拷锟斤拷锟接碉拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
    bst.Erase(8);  //1. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟角★拷锟斤拷锟揭撅拷锟斤拷锟斤拷锟斤拷液锟斤拷锟�.
    bst.Erase(10); //2. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟矫伙拷锟斤拷液锟斤拷锟�
    bst.Insert(5); //锟斤拷锟斤拷锟斤拷锟揭猴拷锟接碉拷锟斤拷小锟斤拷锟�
    bst.Erase(3);  //3. 要删锟斤拷锟侥斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷小锟斤拷锟斤拷锟斤拷液锟斤拷锟�
    bst.Erase(4);
    bst.Erase(7);
    bst.Erase(1);
    bst.Erase(14);
    bst.Erase(13);
    bst.Erase(6);
    bst.Erase(5);
    bst.InOrder();

    //锟斤拷止锟斤拷式锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 --> 双锟斤拷锟酵凤拷
    //bst.~BSTree();
    //cp.~BSTree();
    
}

int main() {
    test();
}

小锟斤拷锟狡硷拷锟侥讹拷

锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥斤拷为锟斤拷锟斤拷锟斤拷息锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷同锟斤拷锟睫观碉拷锟街な碉拷锟斤拷锟斤拷锟斤拷锟�

a 1.0: 锟斤拷锟酵ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷营状态锟斤拷锟斤拷式锟斤拷营锟斤拷锟斤拷锟斤拷锟皆ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷; 锟斤拷戏锟斤拷锟斤拷

锟斤拷戏锟斤拷锟�

锟斤拷戏锟斤拷频

锟斤拷戏锟斤拷锟斤拷

锟斤拷戏锟筋动; 锟斤拷alittletotheleft锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷一锟筋备锟杰伙拷迎锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷戏锟斤拷锟斤拷业锟斤拷锟斤拷锟斤拷嵌锟斤拷粘锟斤拷锟斤拷锟斤拷械母锟斤拷锟斤拷锟斤拷锟斤拷锟�