【二叉搜索樹】的詳細實現(C++)

二叉搜索樹的概念

　　從前面討論折半搜索的性能中可知，如果每次從搜索序列的中間進行搜索，把區間縮小一半，通過有限次迭代，很快就能通近到所要尋找的元素。進一步，如果我們直接輸入搜索序列，構造出類似於折半搜索的判定樹那樣的樹形結構，就能實現快速搜索。這種樹形結構就是二又搜索樹。

二又搜索樹（binary search tree）或者是一棵空樹，或者是具有下列性質的二又樹：

　　（1）每個結點都有一個作為搜索依據的關鍵碼（key），所有結點的關鍵碼互不相同。

　　（2）左子樹（如果存在）上所有結點的關鍵碼都小於根結點的關鍵碼。

　　（3）右子樹（如果存在）上所有結點的關鍵碼都大於根結點的關鍵碼。

　　（4）左子樹和右子樹也是二又搜索樹。

　　關鍵碼事實上是結點所保存元素中的某個域的值，它能夠唯一地表示這個結點。因此，如果對一棵二又搜索樹進行中序遍歷，可以按從小到大的順序，將各結點關鍵碼排列起來，所以也稱二叉搜索樹為二又排序樹（binary sorting tree）。

二叉搜索樹的建立

　　輸入一系列數據，建立一棵二又搜索樹。它要求從空樹開始建樹，輸入序列以輸入一個結束標志value結束。這個值應當取不可能在輸入序列中出現的值，例如輸入序列的值都是正整數時，取RefValue為0或負數。

    //構造BST
    BST(T value) :root(NULL), RefValue(value)
    {
        T x;
        cin >> x;
        while (x != RefValue)
        {
            Insert(x, root);    //新建一個結點，調用Insert插入到樹中
            cin >> x;
        }
    }

二叉搜索樹的插入

　　為了向二又搜索樹中插入一個新元素，必須先檢查這個元素是否在樹中已經存在。所以在插入之前，先使用搜索算法在樹中檢查要插入元素有還是沒有。如果搜索成功，說明樹中已經有這個元素，不再插入；如果搜索不成功，說明樹中原來沒有關鍵碼等於給定值的結點，把新元素加到搜索操作停止的地方。當ptr!=NULL時，它一定指向一棵子樹的根，可用它所包含的關鍵碼與給定值比較繼續搜索插入位置；如果 ptr=NULL，一定是遞歸到空樹的位置，此時將創建的新結點地址送給ptr，因為ptr是引用，新結點的地址自然送入上述某一個指針域，自動將新結點作為葉結點鏈入二又搜索樹中了。每次結點的插入，都要從根結點出發搜索插入位置，然后把新結點作為時結點插入。這樣不需移動結點，只需修改某個已有樹中結點的一個空指針即可。

    //以ptr為根的二叉搜索樹中插入所含值為e1的結點
    bool Insert(const T& e1, BSTNode<T>* &ptr)    //第二個參數是指針的引用
    {
        if (ptr == NULL)
        {
            ptr = new BSTNode<T>(e1);    //構造新結點
            if (ptr == NULL)
            {
                cout << "Memory allocation failed!" << endl;
                exit(1);
            }
            return true;
        }
        else if (e1 < ptr->data)    //小於，插入左子樹
        {
            Insert(e1, ptr->left);
        }
        else if (e1 > ptr->data)    //大於，插入右子樹
        {
            Insert(e1, ptr->right);
        }
        else    //x已在樹中，不插入
        {
            return false;
        }
    }

二叉搜索樹的遞歸搜索

　　從根結點開始，沿某一個分支逐層向下進行比較判等的過程。它可以是一個遞歸的過程。假設想要在二又搜索樹中搜索關鍵碼為x的元素，搜索過程從根結點開始。如果根指針為NULL，則搜索不成功；否則用給定值x與根結點的關鍵碼進行比較：如果給定值等於根結點的關鍵碼，則搜索成功，返回搜索成功信息，並報告搜索到的結點地址。如果給定值小於根結點的關鍵碼，則繼續遞歸搜索根結點的左子樹，否則，遞歸搜索根結點的右子樹。

    //在ptr為根的二叉搜索樹中搜索含x的結點。若找到，返回該結點地址，否則返回NULL
    BSTNode<T>* Search(T x, BSTNode<T>* ptr)
    {
        if (ptr == NULL)
        {
            return NULL;
        }
        else if (x < ptr->data)
        {
            return Search(x, ptr->left);
        }
        else if (x > ptr->data)
        {
            return Search(x, ptr->right);
        }
        else
        {
            return ptr;
        }
    }

二叉搜索樹的刪除

　　在二又搜索樹中刪除一個結點時，必須將因刪除結點而斷開的二又鏈表重新鏈接起來，同時確保二叉搜索樹的性質不會失去。此外，為了保證在執行刪除后，樹的搜索性能不至於降低，還需要防止重新鏈接后樹的高度不能增加。

　　如果想要刪除葉結點，只需將其父結點指向它的指針清零，再釋放它即可。

　　如果被刪結點右子樹為空，可以拿它的左子女結點頂替它的位置，再釋放它。

　　如果被刪結點左子樹為空，可以拿它的右子女結點頂替它的位置，再釋放它。

　　如果被刪結點左、右子樹都不空，可以在它的右子樹中尋找中序下的第一個結點（關鍵碼最小），用它的值填補到被刪結點中，再來處理這個結點的刪除問題，這是一個遞歸處理。例如，在上圖中想要刪除關鍵碼為78的結點，它的左、右子樹都不空。在它的右子樹中找中序下的第一個結點，其關鍵碼為81。把它的值填補到被刪結點中去，下面的問題就是刪除關鍵碼為81的結點了。這個結點左子樹為空，用它的右子女（關鍵碼為88）代替它的位置就可以了。

 

    //以ptr為根的二叉搜索樹中刪除含x的結點
    bool Remove(T x, BSTNode<T>* &ptr)
    {
        BSTNode<T>* temp;
        if (ptr != NULL) //ptr不為空進行操作
        {
            if (x < ptr->data)
            {
                Remove(x, ptr->left);
            }
            else if (x > ptr->data)
            {
                Remove(x, ptr->right);
            }
            //找到了要刪除的結點
            //1.要刪除的結點ptr同時有左右子樹
            else if (ptr->left != NULL&&ptr->right != NULL)
            {
                temp = ptr->right;    //在右子樹中搜索中序下的第一個結點
                while (temp->left != NULL)
                {
                    temp = temp->left;
                }
                //用右子樹中序下的第一個結點的值填充要刪除的結點
                ptr->data = temp->data;
                //然后再新填充值ptr的右子樹中刪除temp的data值
                Remove(ptr->data, ptr->right);
            }
            else //不同時有左右子樹
            {
                temp = ptr;        //temp記住要刪除的ptr結點
                if (ptr->left == NULL) //只有右子樹
                {
                    ptr = ptr->right;
                }
                else    //只有左子樹
                {
                    ptr = ptr->left;
                }
                delete temp;    //刪除結點
                temp = NULL;
                return true;
            }
        }
        else //ptr為空直接返回false
        {
            return false;
        }
    }

二叉搜索樹的銷毀

　　二叉搜索樹的銷毀與普通二叉樹基本相同。

 

    //銷毀以root為根的二叉樹搜索樹函數
    void Destroy(BSTNode<T>* &root)
    {
        if (root == NULL)
        {
            return;
        }
        if (root->left != NULL)
        {
            Destroy(root->left);
        }
        if (root->right != NULL)
        {
            Destroy(root->right);
        }
        delete root;
        root = NULL;
    }

 

二叉搜索樹的源碼

 

//二叉搜索樹結點類型
template<typename T>
struct BSTNode
{
    T data;    //數據域
    BSTNode<T> *left, *right;    //左子女、右子女
    BSTNode() :left(NULL), right(NULL) {}    //構造函數
    //構造函數
    BSTNode(const T d, BSTNode<T>* L = NULL, BSTNode<T>* R = NULL) :data(d), left(L), right(R) {}
};

//二叉搜索樹的定義
template <class T>
class BST
{
public:
    //普通構造函數
    BST() :root(NULL) {}
    //構造BST
    BST(T value) :root(NULL), RefValue(value)
    {
        T x;
        cin >> x;
        while (x != RefValue)
        {
            Insert(x, root);    //新建一個結點，調用Insert插入到樹中
            cin >> x;
        }
    }
    //析構
    ~BST() { Destroy(root); }

    //插入
    bool Insert(T x) { return Insert(x, root); }

    //刪除
    bool Remove(T x) { return Remove(x, root); }

    //搜索
    bool Search(T x) { return (Search(x, root) != NULL) ? true : false; }

    //中序遍歷
    void InOrder() { InOrder(root); }

protected:

    //以ptr為根的二叉搜索樹中插入所含值為e1的結點
    bool Insert(const T& e1, BSTNode<T>* &ptr)    //第二個參數是指針的引用
    {
        if (ptr == NULL)
        {
            ptr = new BSTNode<T>(e1);    //構造新結點
            if (ptr == NULL)
            {
                cout << "Memory allocation failed!" << endl;
                exit(1);
            }
            return true;
        }
        else if (e1 < ptr->data)    //小於，插入左子樹
        {
            Insert(e1, ptr->left);
        }
        else if (e1 > ptr->data)    //大於，插入右子樹
        {
            Insert(e1, ptr->right);
        }
        else    //x已在樹中，不插入
        {
            return false;
        }
    }

    //以ptr為根的二叉搜索樹中刪除含x的結點
    bool Remove(T x, BSTNode<T>* &ptr)
    {
        BSTNode<T>* temp;
        if (ptr != NULL) //ptr不為空進行操作
        {
            if (x < ptr->data)
            {
                Remove(x, ptr->left);
            }
            else if (x > ptr->data)
            {
                Remove(x, ptr->right);
            }
            //找到了要刪除的結點
            //1.要刪除的結點ptr同時有左右子樹
            else if (ptr->left != NULL&&ptr->right != NULL)
            {
                temp = ptr->right;    //在右子樹中搜索中序下的第一個結點
                while (temp->left != NULL)
                {
                    temp = temp->left;
                }
                //用右子樹中序下的第一個結點的值填充要刪除的結點
                ptr->data = temp->data;
                //然后再新填充值ptr的右子樹中刪除temp的data值
                Remove(ptr->data, ptr->right);
            }
            else //不同時有左右子樹
            {
                temp = ptr;        //temp記住要刪除的ptr結點
                if (ptr->left == NULL) //只有右子樹
                {
                    ptr = ptr->right;
                }
                else    //只有左子樹
                {
                    ptr = ptr->left;
                }
                delete temp;    //刪除結點
                temp = NULL;
                return true;
            }
        }
        else //ptr為空直接返回false
        {
            return false;
        }
    }

    //在ptr為根的二叉搜索樹中搜索含x的結點。若找到，返回該結點地址，否則返回NULL
    BSTNode<T>* Search(T x, BSTNode<T>* ptr)
    {
        if (ptr == NULL)
        {
            return NULL;
        }
        else if (x < ptr->data)
        {
            return Search(x, ptr->left);
        }
        else if (x > ptr->data)
        {
            return Search(x, ptr->right);
        }
        else
        {
            return ptr;
        }
    }

    //中序遍歷
    void InOrder(BSTNode<T>* root)
    {
        if (root != NULL)
        {
            InOrder(root->left);
            cout << root->data << " ";
            InOrder(root->right);
        }
    }

    //銷毀以root為根的二叉樹搜索樹函數
    void Destroy(BSTNode<T>* &root)
    {
        if (root == NULL)
        {
            return;
        }
        if (root->left != NULL)
        {
            Destroy(root->left);
        }
        if (root->right != NULL)
        {
            Destroy(root->right);
        }
        delete root;
        root = NULL;
    }
private:
    BSTNode<T>* root;    //根指針
    T RefValue;    //輸入結束標識
};

int main(int argc, char* argv[])
{
    //g a e d f h j i l k #
    BST<char> tree('#');
    tree.InOrder();
    cout << endl;
    cout << tree.Search('e') << endl;
    cout << tree.Insert('z') << endl;
    tree.InOrder();
    cout << endl;
    cout << tree.Remove('z') << endl;
    cout << tree.Remove('j') << endl;
    tree.InOrder();
    cout << endl;
    return 0;
}