算法04 之二叉樹

在有序數組中，可以快速找到特定的值，但是想在有序數組中插入一個新的數據項，就必須首先找出新數據項插入的位置，然後將比新數據項大的數據項向後移動一位，來給新的數據項騰出空間，刪除同理，這樣移動很費時。顯而易見，如果要做很多的插入和刪除操作和刪除操作，就不該選用有序數組。

        另一方面，鏈表中可以快速添加和刪除某個數據項，但是在鏈表中查找數據項可不容易，必須從頭開始訪問鏈表的每一個數據項，直到找到該數據項爲止，這個過程很慢。

        樹這種數據結構，既能像鏈表那樣快速的插入和刪除，又能想有序數組那樣快速查找。這裏主要實現一種特殊的樹——二叉（搜索）樹。二叉搜索樹有如下特點：一個節點的左子節點的關鍵字值小於這個節點，右子節點的關鍵字值大於或等於這個節點。插入一個節點需要根據這個規則進行插入。

        刪除節點時二叉搜索樹中最複雜的操作，但是刪除節點在很多樹的應用中又非常重要，所以詳細研究並總結下特點。刪除節點要從查找要刪的節點開始入手，首先找到節點，這個要刪除的節點可能有三種情況需要考慮：

         ·該節點是葉節點，沒有子節點

         ·該節點有一個子節點

         ·該節點有兩個子節點

         第一種最簡單，第二種也還是比較簡單的，第三種就相當複雜了。下面分析這三種刪除情況：

        要刪除葉節點，只需要改變該節點的父節點對應子字段的值即可，由指向該節點改爲null就可以了。垃圾回收器會自動回收葉節點，不需要自己手動刪掉；當節點有一個子節點時，這個節點只有兩個連接：連向父節點和連向它唯一的子節點。需要從這個序列中剪斷這個節點，把它的子節點直接連到它的父節點上即可，這個過程要求改變父節點適當的引用（左子節點還是右子節點），指向要刪除節點的子節點即可；第三種情況最複雜，如果要刪除有兩個子節點的節點，就不能只用它的一個子節點代替它，比如要刪除節點25，如果用35取代它，那35的左子節點是15呢還是30？

   

        因此需要考慮另一種方法，尋找它的中序後繼來代替該節點。下圖顯示的就是要刪除節點用它的後繼代替它的情況，刪除後還是有序的。（這裏還有更麻煩的情況，即它的後繼自己也有右子節點，下面再討論。）

        那麼如何找後繼節點呢？首先得找到要刪除的節點的右子節點，它的關鍵字值一定比待刪除節點的大。然後轉到待刪除節點右子節點的左子節點那裏（如果有的話），然後到這個左子節點的左子節點，以此類推，順着左子節點的路徑一直向下找，這個路徑上的最後一個左子節點就是待刪除節點的後繼。如果待刪除節點的右子節點沒有左子節點，那麼這個右子節點本身就是後繼。尋找後繼的示意圖如下：

        找到了後繼節點，現在開始刪除了，先看第一種情況，後繼節點是delNode右子節點的做後代，這種情況要執行以下四個步驟：

         ·把後繼父節點的leftChild字段置爲後繼的右子節點；

         ·把後繼的rightChild字段置爲要刪除節點的右子節點；

         ·把待刪除節點從它父節點的leftChild或rightChild字段刪除，把這個字段置爲後繼；

         ·把待刪除的左子節點移除，將後繼的leftChild字段置爲待刪除節點的左子節點。

        如下圖所示：

        如果後繼節點就是待刪除節點的右子節點，這種情況就簡單了，因爲只需要把後繼爲跟的子樹移到刪除的節點的位置即可。如下圖所示：

        看到這裏，就會發現刪除時相當棘手的操作。實際上，因爲它非常複雜，一些程序員都嘗試着躲開它，他們在Node類中加了一個Boolean字段來標識該節點是否已經被刪除，在其他操作之前會先判斷這個節點是不是已經刪除了，這樣刪除節點不會改變樹的結構，。當然樹中還保留着這種已經刪除的節點，對存儲造成浪費，但是如果沒有那麼多刪除的話，這也不失爲一個好方法。下面是二叉搜索樹的主要代碼：

public class BinaryTree {
    private BNode root; //根節點

    public BinaryTree() {
        root = null;
    }

    //二叉搜索樹查找的時間複雜度爲O(logN)
    public BNode find(int key) { //find node with given key
        BNode current = root;
        while(current.key != key) {
            if(key < current.key) {
                current = current.leftChild;
            }
            else {
                current = current.rightChild;
            }
            if(current == null) {
                return null;
            }
        }
        return current;
    }

    //插入節點
    public void insert(int key, double value) {
        BNode newNode = new BNode();
        newNode.key = key;
        newNode.data = value;
        if(root == null) { //if tree is null
            root = newNode;
        }
        else {
            BNode current = root;
            BNode parent;
            while(true) {
                parent = current;
                if(key < current.data) { //turn left
                    current = current.leftChild;
                    if(current == null) {
                        parent.leftChild = newNode;
                        newNode.parent = parent;
                        return;
                    }
                }
                else { //turn right
                    current = current.rightChild;
                    if(current == null) {
                        parent.rightChild = newNode;
                        newNode.parent = parent;
                        return;
                    }
                }
            }
        }
    }

    //遍歷二叉樹
    public void traverse(int traverseType) {
        switch(traverseType)
        {
        case 1: System.out.println("Preorder traversal:");
                preOrder(root);//前向遍歷
                break;
        case 2: System.out.println("Inorder traversal:");
                inOrder(root);//中向遍歷
                break;
        case 3: System.out.println("Postorder traversal:");
                postOrder(root);//後向遍歷
                break;
        default: System.out.println("Inorder traversal:");
                inOrder(root);
                break;
        }
        System.out.println("");
    }

    //前向遍歷
    private void preOrder(BNode localRoot) {
        if(localRoot != null) {
            System.out.print(localRoot.data + " ");
            preOrder(localRoot.leftChild);
            preOrder(localRoot.rightChild);
        }
    }

    //中向遍歷
    private void inOrder(BNode localRoot) {
        if(localRoot != null) {
            inOrder(localRoot.leftChild);
            System.out.print(localRoot.data + " ");
            inOrder(localRoot.rightChild);
        }
    }

    //後向遍歷
    private void postOrder(BNode localRoot) {
        if(localRoot != null) {
            postOrder(localRoot.leftChild);
            postOrder(localRoot.rightChild);
            System.out.print(localRoot.data + " ");
        }
    }

    //查找最小值
    /*根據二叉搜索樹的存儲規則，最小值應該是左邊那個沒有子節點的那個節點*/
    public BNode minNumber() {
        BNode current = root;
        BNode parent = root;
        while(current != null) {
            parent = current;
            current = current.leftChild;
        }
        return parent;
    }

    //查找最大值
    /*根據二叉搜索樹的存儲規則，最大值應該是右邊那個沒有子節點的那個節點*/
    public BNode maxNumber() {
        BNode current = root;
        BNode parent = root;
        while(current != null) {
            parent = current;
            current = current.rightChild;
        }
        return parent;
    }

    //刪除節點
    /*
     * 刪除節點在二叉樹中是最複雜的，主要有三種情況：
     * 1. 該節點沒有子節點（簡單）
     * 2. 該節點有一個子節點（還行）
     * 3. 該節點有兩個子節點（複雜）
     * 刪除節點的時間複雜度爲O(logN)
     */
    public boolean delete(int key) {
        BNode current = root;
//      BNode parent = root;
        boolean isLeftChild = true;

        if(current == null) {
            return false;
        }
        //尋找要刪除的節點
        while(current.data != key) {
//          parent = current;
            if(key < current.key) {
                isLeftChild = true;
                current = current.leftChild;
            }
            else {
                isLeftChild = false;
                current = current.rightChild;
            }
            if(current == null) {
                return false;
            }
        }

        //找到了要刪除的節點，下面開始刪除
        //1. 要刪除的節點沒有子節點,直接將其父節點的左子節點或者右子節點賦爲null即可
        if(current.leftChild == null && current.rightChild == null) {
            return deleteNoChild(current, isLeftChild);
        }

        //3. 要刪除的節點有兩個子節點
        else if(current.leftChild != null && current.rightChild != null) {
            return deleteTwoChild(current, isLeftChild);
        }

        //2. 要刪除的節點有一個子節點，直接將其砍斷，將其子節點與其父節點連起來即可，要考慮特殊情況就是刪除根節點，因爲根節點沒有父節點
        else {
            return deleteOneChild(current, isLeftChild);
        }

    }

    public boolean deleteNoChild(BNode node, boolean isLeftChild) {
        if(node == root) {
            root = null;
            return true;
        }
        if(isLeftChild) {
            node.parent.leftChild = null;
        }
        else {
            node.parent.rightChild = null;
        }
        return true;
    }

    public boolean deleteOneChild(BNode node, boolean isLeftChild) {
        if(node.leftChild == null) {
            if(node == root) {
                root = node.rightChild;
                node.parent = null;
                return true;
            }
            if(isLeftChild) {
                node.parent.leftChild  = node.rightChild;
            }
            else {
                node.parent.rightChild = node.rightChild;
            }
            node.rightChild.parent = node.parent;
        }
        else {
            if(node == root) {
                root = node.leftChild;
                node.parent = null;
                return true;
            }
            if(isLeftChild) {
                node.parent.leftChild  = node.leftChild;
            }
            else {
                node.parent.rightChild = node.leftChild;
            }
            node.leftChild.parent = node.parent;
        }
        return true;
    }

    public boolean deleteTwoChild(BNode node, boolean isLeftChild) {
        BNode successor = getSuccessor(node);
        if(node == root) {
            successor.leftChild = root.leftChild;
            successor.rightChild = root.rightChild;
            successor.parent = null;
            root = successor;
        }
        else if(isLeftChild) {
            node.parent.leftChild = successor;
        }
        else {
            node.parent.rightChild = successor;
        }
        successor.leftChild = node.leftChild;//connect successor to node's left child
        return true;
    }

    //獲得要刪除節點的後繼節點（中序遍歷的下一個節點）
    public BNode getSuccessor(BNode delNode) {
        BNode successor = delNode;
        BNode current = delNode.rightChild;
        while(current != null) {
            successor = current;
            current = current.leftChild;
        }
        if(successor != delNode.rightChild) {
            successor.parent.leftChild = successor.rightChild;
            if(successor.rightChild != null) {
                successor.rightChild.parent = successor.parent;//刪除後續節點在原來的位置
            }
            successor.rightChild = delNode.rightChild;//將後續節點放到正確位置，與右邊連上
        }
        return successor;
    }
}

class BNode {
    public int key;
    public double data;
    public BNode parent;
    public BNode leftChild;
    public BNode rightChild;

    public void displayNode() {
        System.out.println("{" + key + ":" + data + "}");
    }
}