查找（二叉排序树）

【1】二叉排序树

二叉排序树，又称为二叉查找树。

它或者是一棵空树，或者具有下列性质：

1. 若它的左子树不空，则左子树上所有的结点的值均小于它的根结点的值；

2. 若它的右子树不空，则右子树上所有的结点的值均大于它的根结点的值；

3. 它的左右子树也分别为二叉排序树。

【2】二叉排序树的代码实现

结合下图以及实现代码分析

（1）构建二叉排序树

（2）实现代码

#include <iostream>
using namespace std;

template<class Type>   class BST;

template<class Type>
class BstNode
{
    friend  class BST<Type>;
    Type  data;
    BstNode<Type> *leftChild, *rightChild;
    public:
        BstNode():leftChild(NULL), rightChild(NULL)
        {}
        BstNode(const Type &x,BstNode<Type> *left = NULL, BstNode<Type> *right = NULL)
            : data(x)
            , leftChild(left)
            , rightChild(right)
        {}
        ~BstNode()
        {}
        Type & GetData() { return data;}
        const Type & GetData() const { return data;}
        BstNode<Type> *&GetLeft() { return leftChild;}
        BstNode<Type> * const&GetLeft() const { return leftChild;}
        BstNode<Type> * &GetRight() { return rightChild;}
        BstNode<Type> * const &GetRight() const { return rightChild;}
};
template<class Type>  
class BST
{
private:
    BstNode<Type>  *root;
private:
    ///////////////////////////////////私有方法部分
    bool insert(BstNode<Type> *&ptr, const Type &x);
    bool insertElem(BstNode<Type> *&ptr, const Type &x);
    BstNode<Type>* find(BstNode<Type> * ptr, const Type &x);
    BstNode<Type>* findRecursive(BstNode<Type> * ptr, const Type &x);
    BstNode<Type>* findPre(BstNode<Type> *ptr, const Type &x);
    BstNode<Type>* max(BstNode<Type> *ptr) const;
    BstNode<Type>* min(BstNode<Type> *ptr) const;
    bool remove(BstNode<Type> *&ptr, const Type &x);
    bool removeRecursive(BstNode<Type> *&ptr, const Type &x);
    void InOrder(BstNode<Type> *ptr) const;
    void LevelOrder(BstNode<Type> *t) const;
public:
    BST(): root(NULL)
    { }
    BST(Type x): root(NULL)
    { }
    ~BST()
    { }    
    BstNode<Type>* GetRoot()
    {
        return root;
    }
    void SetRoot(BstNode<Type>* pRoot)
    {
        root = pRoot;
    }
    int Insert(const Type &x)
    {
        return insert(root, x);
    }
    BstNode<Type>* Find(const Type &x)
    {
        return find(root, x);
    }
    void InOrder()
    {
        InOrder(root);
        cout << endl;
    }
    BstNode<Type>* Min() const  
    {
        return min(root);
    }
    BstNode<Type> * Max() const
    {
        return max(root);
    }
    int Remove(const Type &x)
    {
        return remove(root, x);
    }
    void LevelOrder()
    {
        LevelOrder(root);
    }
};
// 插入数据元素方法1 (递归实现)
template<class Type>
bool  BST<Type>::insert(BstNode<Type> *&ptr, const Type &x)
{
    if (NULL == ptr)
    {    // 为空时就需要创建新节点
        ptr = new BstNode<Type>(x);
        if (NULL == ptr)
        {
            cerr << "out of space" << endl;
            return false;
        }
        return true;
    }
    else if (x < ptr->data)   
    {    // 小, 插入其左边
        return insert(ptr->leftChild, x);
    }
    else if (x > ptr->data)
    {    // 大, 插入其右边
        return insert(ptr->rightChild, x);
    }
    else
    {    // 两者相等
        cout << "数据" << x << "重复,请重新输入..." << endl;
        return false;
    }
}
// 插入数据元素方法2 （非递归实现）
template<class Type>
bool BST<Type>::insertElem(BstNode<Type> *&ptr, const Type &x)
{
    if (NULL == ptr)
    {
        ptr = new BstNode<Type>(x);
        if (NULL == ptr)
        {
            cout << "out of space !" << endl;
            return false;
        }
        return true;
    }
    BstNode<Type>* p = ptr, *q = NULL;
    while (p != NULL)
    {
        q = p;
        if (x == p->data)
        {
            cout << "数据重复" << endl;
            return false;
        }
        if (x > p->data)
        {
            p = p->rightChild;
        }
        else if (x < p->data)
        {
            p = p->leftChild;
        }
    }
    p = new BstNode<Type>(x);
    if (x < q->data)
        q->leftChild = p;
    if (x > q->data)
        q->rightChild = p;
    return true;
}
// 查找某个数据元素的节点指针 （递归实现）
template<class Type>
BstNode<Type>* BST<Type>::findRecursive(BstNode<Type> *ptr, const Type &x)
{
    if (NULL == ptr)
        return NULL;
    else if (x < ptr->data)
        return find(ptr->leftChild, x);
    else if (x > ptr->data)
        return find(ptr->rightChild, x);
    else
        return ptr;
}
// 查找某个数据元素的节点指针 (非递归实现)
template<class Type>
BstNode<Type>* BST<Type>::find(BstNode<Type> *ptr, const Type &x)
{
    while (ptr != NULL)
    {
        if (x == ptr->data)  
            return ptr;
        else if (ptr->data > x)
            ptr = ptr->leftChild;
        else
            ptr = ptr->rightChild;
    }
    return  NULL;
}
// 查找某个数据元素的父节点指针 (非递归实现)
// 记录父节点，当孩子值与查找的数据元素值相同，返回父节点即可。
template<class Type>
BstNode<Type>* BST<Type>::findPre(BstNode<Type> *ptr, const Type &x)
{
    BstNode<Type>* q = NULL;
    while (ptr != NULL)
    {
        if (x == ptr->data)  
        {
            return q;
        }
        else if (ptr->data > x)
        {
            q = ptr;
            ptr = ptr->leftChild;
        }
        else
        {
            q = ptr;
            ptr = ptr->rightChild;
        }
    }
    return  NULL;
}
// 按元素值删除某个节点 （递归实现）
// 具体删除思路请参考注释
template<class Type>    
bool BST<Type>::removeRecursive(BstNode<Type> *&ptr, const Type &x)
{
    BstNode<Type>* tmp = NULL;
    if (ptr != NULL)
    { 
        if (x < ptr->data)      // 小于，转向左子树
            return remove(ptr->leftChild, x);
        else if (x > ptr->data) // 大于，转向右子树
            return remove(ptr->rightChild, x);
        // 相等时即找到  然后判断左右子树情况
        else if (ptr->leftChild != NULL && ptr->rightChild != NULL)  
        {    
            // 1. 左右均不空
            tmp = min(ptr->rightChild); // 找到右子树的最小值结点
            ptr->data = tmp->data;        // 数值更换
            return remove(ptr->rightChild, ptr->data); // 递归再删除那个最小值结点
        }
        else 
        {    // 2. 左为空 || 右为空 || 左右子树均为空
            tmp = ptr;
            if (NULL == ptr->leftChild)     // 先考虑左子树
                ptr = ptr->rightChild;   // 衔接其右节点
            else if (NULL == ptr->rightChild) // 再考虑右子树
                ptr = ptr->leftChild;          // 衔接其左节点

            delete tmp;
            tmp = NULL;  
            return true;
        }
    }
    return false;
}
// 按元素值删除某个节点 （非递归实现）
// 具体删除思路请参考注释
template<class Type>    
bool BST<Type>::remove(BstNode<Type> *&ptr, const Type &x)
{
    BstNode<Type>* pself = find(ptr, x); // 欲删除结点自身
    BstNode<Type>* parent = findPre(ptr, x); // 欲删除结点的父节点
    BstNode<Type>* pDelete = pself; // 最终删除结点
    if (NULL == pself)
    {
        cout << "删除数据不存在！" << endl;
        return false;
    }
    // 满足以下情况时需要转换一下实际删除节点
    if (pself->leftChild != NULL && pself->rightChild != NULL)  
    {    
        pDelete = min(pself->rightChild);    // 找到右子树的最小值结点，将来删除它即可
        pself->data = pDelete->data;         // 数值更换
        parent = findPre(pself->rightChild, pself->data); // 重新确定实际删除对象的父节点
        if (NULL == parent)
        {
            // 当删除右子树的根节点 (只有可能右子树存在)
            ptr->rightChild = pDelete->rightChild; // 衔接右子树即可
            // 执行删除 释放内存
            delete pDelete;
            pDelete = NULL;
            return true;
        }
    }
    // 当欲删除父节点  且其孩子为空
    if (NULL == parent)
    {
        if (NULL == pself->leftChild && 
            NULL == pself->rightChild)
        {    // 当树只有一个根节点 两孩子都为空
            delete ptr;
            ptr = NULL;
            return true;
        }
        else if (NULL == pself->leftChild)
        {    // 右孩子存在
            ptr = pself->rightChild;
        }
        else if (NULL == pself->rightChild)
        {    // 左孩子存在
            ptr = pself->leftChild;
        }
    }
    else
    {
        // 衔接结点
        if (parent->data < pDelete->data)
        {    // 右孩子
            if (NULL == pDelete->leftChild)    
                parent->rightChild = pDelete->rightChild;
            else if (NULL == pDelete->rightChild) 
                parent->rightChild = pDelete->leftChild;         
        }
        else
        {    // 左孩子
            if (NULL == pDelete->leftChild)    
                parent->leftChild = pDelete->rightChild; 
            else if (NULL == pDelete->rightChild) 
                parent->leftChild = pDelete->leftChild;
        }
    }
    // 执行删除 释放内存
    delete pDelete;
    pDelete = NULL;
    return true;
}
// 打印二叉搜索树的数据 (中序遍历)
// 思路分析：
// 先遍历左子树
// 再遍历根节点
// 最后遍历右子树
template<class Type>
void BST<Type>::InOrder(BstNode<Type> *ptr) const
{
    if (ptr != NULL)
    {
        InOrder(ptr->leftChild);
        cout << ptr->data << " ";
        InOrder(ptr->rightChild);
    }
}
// 求二叉搜索树某一个子树的最小元素指针
// 思路分析：
// 一直向左子树递进即为最小
template<class Type>
BstNode<Type>* BST<Type>::min(BstNode<Type> *ptr) const
{
    BstNode<Type> *p = ptr;
    while (p != NULL && p->leftChild != NULL)
    {
        p = p->leftChild;
    }
    return p;
}
// 求二叉搜索树某一个子树的最大元素指针
// 思路分析：
// 一直向右子树递进即为最大
template<class Type>
BstNode<Type>* BST<Type>::max(BstNode<Type> *ptr) const
{
    BstNode<Type> *p = ptr;
    while (p != NULL && p->rightChild != NULL)  // 保证p不等于空!
    {
        p = p->rightChild;
    }
    return p;
}

void main()
{
    BST<int> bst;
    int a[12] = {53,17,9,45,23,40,38,78,65,87,81,94};
    for (int i = 0; i < 12; ++i)
    {
        bst.Insert(a[i]);
    }
    cout << "中序遍历的结果如下：" << endl;
    bst.InOrder();

    int data = 0;
    cout << "请输入要查找的数据:";
    cin >> data;
    if (bst.Find(data) != NULL)
        cout << "查找成功！" << endl;
    else
        cout << "未查找到！" << endl;

    cout << "请输入要删除的数据:";
    for (; ;)
    {
        int num = 0;
        while (cin >> num, num != -1)
        {
            if (-1 == num)  
                break;
            bst.Remove(num);
            cout << "删除后数据打印：" << endl;
            bst.InOrder();
            cout << "请输入要删除的数据(-1结束):";
        }
        break;
    }
}

Good  Good  Study, Day  Day  Up.

顺序  选择  循环  总结