二叉搜索树

是一种特殊的二叉树

比父亲节点值大的在右，小的在左用于查找。

实现

#pragma once

template<class K>//身体
struct BSNode {
	K _key;
	BSnode<K>* _left;
	BSnode<k>* _right;
	BSnod(const K& key) 
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};
template<class K>
class BStree {
	typedef BSNode<K> Node;//using node=BSnode<K>
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);
		if (parent->_key > key) {
			parent->_left=newnode;
		}
		else{
			parent->_right=newnode;
		}
		return true;
	}
private:
	node* _root = nullptr;
};

插入

先判断是否是空树

不是空树不断下找到空位；

删除

bool Erase(const K& key) {
    if (_root == nullptr) {
        return false;
    }
    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 {
            // 找到了目标节点 cur，开始删除
            // 情况1：左子树为空（包含左右都为空的叶子节点）
            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;
            }
            // 情况2：右子树为空（此时左子树一定不为空）
            else if (cur->_right == nullptr) {
                if (cur == _root) {
                    _root = cur->_left;
                }
                else {
                    if (parent->_left == cur) {
                        parent->_left = cur->_left;
                    }
                    else {
                        parent->_right = cur->_left;
                    }
                }
                delete cur;
            }
            // 情况3：左右子树都不为空
            else {
                // 寻找右子树的最左节点（后继节点）
                Node* Rparent = cur;
                Node* R = cur->_right;
                while (R->_left) {
                    Rparent = R;
                    R = R->_left;
                }

                // 替换值
                cur->_key = R->_key;
                // Rparent 的左孩子指向 R 的右孩子（R 一定没有左孩子）
                if (Rparent->_left == R) {
                    Rparent->_left = R->_right;
                }
                else {
                    // 处理 R 刚好就是 cur->_right 的情况
                    Rparent->_right = R->_right;
                }
                delete R;
            }
            return true;
        }
    }
    return false;
}