二叉查找樹（五）

　　接上一篇，繼續講二叉查找樹的操作，之前的博客都講得差不多了，本篇就講一下刪除操作，以及求最矮公共父結點（LCA：lowest common ancestor）的操作吧。

• 刪除

　　將一個結點從二叉查找樹中刪除之后，剩下的結點可能會不滿足二叉查找樹的性質，因此，在刪除結點之后要對樹進行調整，使其滿足二叉查找樹的性質。根據結點的孩子的數量，將刪除操作分為三種情況，我們記要刪除的結點為z，實際上刪除的結點為y。

　　1. z結點沒有孩子。

　　如下圖a所示，我們要刪除值為13的結點，因為結點沒有孩子，所以刪除之后不會影響到二叉樹的整體性質，也就是說，直接將13這個結點刪除即可，如圖a所示，從左邊的二叉樹刪除13這個點之后變到右邊的二叉樹。

 　　2. z結點有一個孩子。

　　如下圖b所示，要刪除的值為16的結點有一個孩子，而且是右孩子，那么從圖上來看，如果，我們將16去掉，然后把以20為結點的子樹作為15的右子樹，那么整棵樹還是符合二叉查找樹的性質的，因此，有一個孩子的結點的刪除操作，就是要將其孩子作為其父結點的孩子即可。如圖b所示。

 　　3. z結點有兩個孩子。

　　如下圖c所示，要刪除的值為5的結點，有兩個孩子，刪除之后肯定整棵樹就不符合二叉查找樹的性質了，因此要進行調整，我們發現，將5的后繼，值為6的結點來放到5的位置，然后將6的孩子7作為6的父結點10的孩子，如下圖c所示，我們要刪除的是z結點，而我們實際要刪除y結點，並替換z結點。這里需要注意的一點是，如果一個結點有右孩子，則該結點的后繼，至多有一個子女，而且是右孩子。因為假如該結點的后繼有左孩子和右孩子，那么其左孩子的值肯定是介於該結點和其后繼之間的，那么按照二叉查找樹的性質，這個左孩子就應該是該結點的后繼，所以，這與原先的后繼相互矛盾，因此，結論成立。

　　好了，分析完了刪除的三種情況，我們來完成我們的程序吧。

/**
     * 刪除二叉查找樹中的結點z
     * @author Alfred
     * @param z 要刪除的結點
     * @return 刪除或者替換的結點
     */
    public TreeNode treeDelete(TreeNode z){
        TreeNode x = null, y = null;
        if(z.getLeft() == null || z.getRight() == null){
            //對應第1和第2種情況
            y = z;
        }else{
            //對應第3種情況
            y = treeSuccessor(z);
        }
        //將x置為y的非null子女，或者當y無子女時置為null
        if(y.getLeft() != null){
            x = y.getLeft();
        }else{
            x = y.getRight();
        }
        //通過修改x和y的父結點的引用，將y刪除
        if(x != null){
            x.setParent(y.getParent());
        }
        if(y.getParent() == null){
            //x成為樹根
            rootNode = x;
        }else if(y == y.getParent().getLeft()){
            //y是其父結點的左孩子
            y.getParent().setLeft(x);
        }else{
            //y是其父結點的右孩子
            y.getParent().setRight(x);
        }
        //如果y和z不是同一個結點，說明是第3種情況
        if(y != z){
            //內容替換
            z.setKey(y.getKey());
            z.setDataNum(y.getDataNum());
        }
        return y;
    }

　　上面的程序完整的搞定了上面分析的三種情況。

• LCA

　　LCA問題對於二叉查找樹來說是非常簡單的。因為二叉查找樹滿足其特有的性質。給定樹中的兩個結點x和y，求其最低公共父結點。我們把這個算法分為三種情況。對於一棵二叉查找樹來說：

　　1. 如果x和y分別位於某結點z的左右子樹上，那么結點z就是x和y的lca。

　　2. 如果x和y位於某結點z的左子樹或者右子樹上，那么x和y的lca也必然位於其所處的左子樹或者右子樹上。

　　3. 如果x或者y中，有一個結點是另外一個結點的父結點，那么lca就是它們中的父結點。即如果有一個點和某結點重合，則重合的點就是lca。

　　那么，我們就從根結點開始，按照從上往下的順序查找lca吧，比較根結點與兩結點的關系，然后再進行下一步的操作。代碼如下：

/**
     * 求兩個結點的最低公共父結點
     * @author Alfred
     * @param x 結點
     * @param y 結點
     * @return 最低公共父結點
     */
    public TreeNode lca(TreeNode x, TreeNode y){
        TreeNode tmpNode = rootNode;
        //獲取兩個key值
        int xKey = x.getKey();
        int yKey = y.getKey();
        //給兩個元素按從小到大排下序，使得x<y
        if(xKey > yKey){
            int tmpKey = xKey;
            xKey = yKey;
            yKey = tmpKey;
        }
        while(true){
            if(tmpNode.getKey() < xKey){
                //這種情況下，lca在其右子樹上
                tmpNode = tmpNode.getRight();
            }else if(tmpNode.getKey() > yKey){
                //這種情況下，lca在其左子樹上
                tmpNode = tmpNode.getLeft();
            }else{
                return tmpNode;
            }
        }
    }

　　代碼比較簡單，就是按照上面的三種情況按照從上到下的順序來分類處理的。其他還有一些lca算法，如離線算法(Tarjan)和在線算法(RMQ)等，暫時先不討論了，以后有時間了再補上吧。為了方便想學習的童鞋來測試，我把整個代碼就貼到下面了（木有找到更好地方法來分享。。）。

package com.alfred.bstree;

/**
 * 二叉查找樹結點
 * @author Alfred
 */
public class TreeNode {
    //key值
    private int key;
    //記錄相同的key值的結點個數
    private int dataNum;
    //下面三個大家都懂得！
    private TreeNode parent;
    private TreeNode left;
    private TreeNode right;
    public TreeNode(int key){
        this.key = key;
        this.dataNum = 1;
    }
    public String toString(){
        return ""+key+"*"+dataNum+"  ";
    }
    /**
     * 偷個懶...自加方法
     * @author Alfred
     */
    public void incNumByOne(){
        this.dataNum++;
    }
    
    /**
     * @return the key
     */
    public int getKey() {
        return key;
    }
    /**
     * @param key the key to set
     */
    public void setKey(int key) {
        this.key = key;
    }
    /**
     * @return the dataNum
     */
    public int getDataNum() {
        return dataNum;
    }
    /**
     * @param dataNum the dataNum to set
     */
    public void setDataNum(int dataNum) {
        this.dataNum = dataNum;
    }
    /**
     * @return the parent
     */
    public TreeNode getParent() {
        return parent;
    }
    /**
     * @param parent the parent to set
     */
    public void setParent(TreeNode parent) {
        this.parent = parent;
    }
    /**
     * @return the left
     */
    public TreeNode getLeft() {
        return left;
    }
    /**
     * @param left the left to set
     */
    public void setLeft(TreeNode left) {
        this.left = left;
    }
    /**
     * @return the right
     */
    public TreeNode getRight() {
        return right;
    }
    /**
     * @param right the right to set
     */
    public void setRight(TreeNode right) {
        this.right = right;
    }
}

package com.alfred.bstree;

import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;

/**
 * 二叉查找樹
 * @author Alfred
 */
public class BSTree {
    //隨機化的構造二叉查找樹
    private Random rand = null;
    //根結點
    private TreeNode rootNode = null;
    
    /**
     * 以int數組A來創建二叉查找樹
     * @param A int數組
     */
    public BSTree(int[] A){
        rand = new Random();
        createBSTree(A);
    }
    
    /**
     * 創建二叉查找樹
     * @param A int數組
     */
    private void createBSTree(int[] A){
        //先構建一個存儲數組下標的List
        List<Integer> index = new LinkedList<Integer>();
        int i = 0;
        for(i = 0; i < A.length; i++){
            index.add(i);
        }
        //隨機構造二叉樹
        for(i = 0; i < A.length; i++){
            int j = 0;
            if(index.size() > 1){
                //隨機產生一個數組下標值
                j = rand.nextInt(index.size() - 1);
            }
            //插入二叉樹
            TreeInsert(A[index.get(j)]);
            //移除下標
            index.remove(j);
        }
    }
    
    /**
     * 插入一個整數
     * @param z 整數
     */
    public void TreeInsert(int z){
        TreeNode parentNode = null;
        TreeNode searchNode = rootNode;
        TreeNode insertNode = new TreeNode(z);
        //while循環找到要插入的點的父結點
        while(searchNode != null){
            parentNode = searchNode;
            if(insertNode.getKey() < searchNode.getKey()){
                searchNode = searchNode.getLeft();
            }else if(insertNode.getKey() == searchNode.getKey()){
                //如果是key值相同的話，直接插入，偷懶在這里...
                searchNode.incNumByOne();
                return;
            }else{
                searchNode = searchNode.getRight();
            }
        }
        
        insertNode.setParent(parentNode);
        if(parentNode == null){
            rootNode = insertNode;
        }else if(insertNode.getKey() < parentNode.getKey()){
            //插入左結點
            parentNode.setLeft(insertNode);
        }else if(insertNode.getKey() == parentNode.getKey()){
            //因為上面插入了，所以這里就不會執行了。
            parentNode.incNumByOne();
            System.out.println("this is not supposed to be executed.");
        }else{
            //插入右結點
            parentNode.setRight(insertNode);
        }
    }
    
    /**
     * 遞歸前序遍歷以x為根的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void preOrderTreeWalk(TreeNode x){
        if(x != null){
            System.out.print(x);//訪問形式為打印輸出一下
            preOrderTreeWalk(x.getLeft());
            preOrderTreeWalk(x.getRight());
        }
    }
    
    public void preOrderTreeWalk(){
        preOrderTreeWalk(rootNode);
    }
    
    /**
     * 非遞歸前序遍歷以x為根結點的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void preOrderTreeWalkNonrecursive1(TreeNode x){
        //借助棧來實現。
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(x != null || !stack.empty()){
            if(x != null){
                System.out.print(x);//遍歷輸出
                stack.push(x);//壓棧
                x = x.getLeft();
            }else{
                x = stack.pop();//出棧
                x = x.getRight();
            }
        }
    }
    
    /**
     * 非遞歸前序遍歷以x為根結點的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void preOrderTreeWalkNonrecursive2(TreeNode x){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        if(x != null){
            stack.push(x);
            while(!stack.empty()){
                TreeNode tmpNode = stack.pop();
                System.out.print(tmpNode);//遍歷輸出
                if(tmpNode.getRight() != null){
                    stack.push(tmpNode.getRight());
                }
                if(tmpNode.getLeft() != null){
                    stack.push(tmpNode.getLeft());
                }
            }
        }
    }
    
    public void preOrderTreeWalkNonrecursive(){
        System.out.println("方法1：");
        preOrderTreeWalkNonrecursive1(rootNode);
        System.out.println("\n方法2：");
        preOrderTreeWalkNonrecursive2(rootNode);
    }
    
    /**
     * 遞歸中序遍歷以x為根的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void inOrderTreeWalk(TreeNode x){
        if(x != null){
            inOrderTreeWalk(x.getLeft());
            System.out.print(x);
            inOrderTreeWalk(x.getRight());
        }
    }
    
    public void inOrderTreeWalk(){
        inOrderTreeWalk(rootNode);
    }
    
    /**
     * 非遞歸中序遍歷以x為根結點的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void inOrderTreeWalkNonrecursive(TreeNode x){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(x != null || !stack.empty()){
            if(x != null){
                stack.push(x);
                x = x.getLeft();
            }else{
                x = stack.pop();
                System.out.print(x);//遍歷輸出
                x = x.getRight();
            }
        }
    }
    
    public void inOrderTreeWalkNonrecursive(){
        inOrderTreeWalkNonrecursive(rootNode);
    }
    
    /**
     * 遞歸后序遍歷以x為根的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void postOrderTreeWalk(TreeNode x){
        if(x != null){
            postOrderTreeWalk(x.getLeft());
            postOrderTreeWalk(x.getRight());
            System.out.print(x);
        }
    }
    
    public void postOrderTreeWalk(){
        postOrderTreeWalk(rootNode);
    }
    /**
     * 非遞歸后序遍歷以x為根結點的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void postOrderTreeWalkNonrecursive1(TreeNode x){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode prev = null;
        TreeNode curr = null;
        if(x != null){
            stack.push(x);
        }
        while(!stack.empty()){
            curr = stack.peek();
            if(prev == null || prev.getLeft() == curr || prev.getRight() == curr){
                if(curr.getLeft() != null){
                    stack.push(curr.getLeft());//壓左孩子
                }else if(curr.getRight() != null){
                    stack.push(curr.getRight());//壓右孩子
                }
            }else if(curr.getLeft() == prev){
                if(curr.getRight() != null){
                    stack.push(curr.getRight());//壓右孩子
                }
            }else{
                System.out.print(curr);//遍歷輸出
                stack.pop();
            }
            prev = curr;
        }
    }
    
    /**
     * 非遞歸后序遍歷以x為根結點的二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void postOrderTreeWalkNonrecursive2(TreeNode x){
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<TreeNode> output = new Stack<TreeNode>();
        TreeNode curr = null;
        if(x != null){
            stack.push(x);
        }
        while(!stack.empty()){
            curr = stack.pop();
            output.push(curr);//存放到輸出地棧里面
            if(curr.getLeft() != null){
                stack.push(curr.getLeft());//壓左孩子
            }
            if(curr.getRight() != null){
                stack.push(curr.getRight());//壓右孩子
            }
        }
        while(!output.empty()){
            TreeNode tmpNode = output.pop();
            System.out.print(tmpNode);//打印輸出
        }
    }
    
    public void postOrderTreeWalkNonrecursive(){
        System.out.println("方法1：");
        postOrderTreeWalkNonrecursive1(rootNode);
        System.out.println("\n方法2：");
        postOrderTreeWalkNonrecursive2(rootNode);
    }
    /**
     * 層序遍歷二叉樹
     * @author Alfred
     * @param x 根結點
     */
    public void levelOrderTreeWalk(TreeNode x){
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode tmpNode = null;
        if(x != null){
            queue.offer(x);
        }
        while(!queue.isEmpty()){
            tmpNode = queue.poll();
            System.out.print(tmpNode);//打印輸出
            if(tmpNode.getLeft() != null){
                queue.offer(tmpNode.getLeft());//左孩子入隊
            }
            if(tmpNode.getRight() != null){
                queue.offer(tmpNode.getRight());//右孩子入隊
            }
        }
    }
    public void levelOrderTreeWalk(){
        levelOrderTreeWalk(rootNode);
    }
    
    
    /**
     * 查找以x為根結點的樹中key的值為k的結點，返回找到的結點或者null
     * @author Alfred
     * @param x 根結點
     * @param k 要查找的整數
     * @return 找到的結點或者null
     */
    private TreeNode treeSearch(TreeNode x, int k){
//        System.out.println("treeSearch:"+x);
        if(x == null || k == x.getKey()){
            return x;
        }
        if(k < x.getKey()){
            return treeSearch(x.getLeft(), k);//查左子樹
        }else{
            return treeSearch(x.getRight(), k);//查右子樹
        }
    }
    /**
     * 非遞歸地查找以x為根結點的樹中key的值為k的結點，返回找到的結點或者null
     * @author Alfred
     * @param x 根結點
     * @param k 要查找的整數
     * @return 找到的結點或者null
     */
    private TreeNode treeSearchNonrecursive(TreeNode x, int k){
        while(x != null && k != x.getKey()){
            if(k < x.getKey()){
                x = x.getLeft();
            }else{
                x = x.getRight();
            }
        }
        return x;
    }
    
    public TreeNode treeSearch(int k){
        return treeSearch(rootNode, k);
    }
    public TreeNode treeSearchNonrecursive(int k){
        return treeSearchNonrecursive(rootNode, k);
    }
    /**
     * 找以x為根結點的二叉查找樹中的最小值
     * @author Alfred
     * @param x 根結點
     * @return 最小值結點或者null
     */
    public TreeNode treeMin(TreeNode x){
        while(x.getLeft() != null){
            x = x.getLeft();
        }
        return x;
    }
    
    public TreeNode treeMin(){
        return treeMin(rootNode);
    }
    /**
     * 找以x為根結點的二叉查找樹中的最大值
     * @author Alfred
     * @param x 根結點
     * @return 最大值結點或者null
     */
    public TreeNode treeMax(TreeNode x){
        while(x.getRight() != null){
            x = x.getRight();
        }
        return x;
    }
    
    public TreeNode treeMax(){
        return treeMax(rootNode);
    }
    /**
     * 找結點x的后繼結點
     * @author Alfred
     * @param x 結點
     * @return x的后繼結點或者null
     */
    public TreeNode treeSuccessor(TreeNode x){
        //第一種情況
        if(x.getRight() != null){
            return treeMin(x.getRight());
        }
        //第二種情況
        TreeNode tmpNode = x.getParent();
        while(tmpNode != null && x == tmpNode.getRight()){
            x = tmpNode;
            tmpNode = tmpNode.getParent();
        }
        return tmpNode;
    }
    
    /**
     * 找結點x的前趨結點
     * @author Alfred
     * @param x 結點
     * @return x的前趨結點或者null
     */
    public TreeNode treePredecessor(TreeNode x){
        //第一種情況
        if(x.getLeft() != null){
            return treeMax(x.getLeft());
        }
        //第二種情況
        TreeNode tmpNode = x.getParent();
        while(tmpNode != null && x == tmpNode.getLeft()){
            x = tmpNode;
            tmpNode = tmpNode.getParent();
        }
        return tmpNode;
    }
    
    /**
     * 刪除二叉查找樹中的結點z
     * @author Alfred
     * @param z 要刪除的結點
     * @return 刪除或者替換的結點
     */
    public TreeNode treeDelete(TreeNode z){
        TreeNode x = null, y = null;
        if(z.getLeft() == null || z.getRight() == null){
            //對應第1和第2種情況
            y = z;
        }else{
            //對應第3種情況
            y = treeSuccessor(z);
        }
        //將x置為y的非null子女，或者當y無子女時置為null
        if(y.getLeft() != null){
            x = y.getLeft();
        }else{
            x = y.getRight();
        }
        //通過修改x和y的父結點的引用，將y刪除
        if(x != null){
            x.setParent(y.getParent());
        }
        if(y.getParent() == null){
            //x成為樹根
            rootNode = x;
        }else if(y == y.getParent().getLeft()){
            //y是其父結點的左孩子
            y.getParent().setLeft(x);
        }else{
            //y是其父結點的右孩子
            y.getParent().setRight(x);
        }
        //如果y和z不是同一個結點，說明是第3種情況
        if(y != z){
            //內容替換
            z.setKey(y.getKey());
            z.setDataNum(y.getDataNum());
        }
        return y;
    }
    
    /**
     * 求兩個結點的最低公共父結點
     * @author Alfred
     * @param x 結點
     * @param y 結點
     * @return 最低公共父結點
     */
    public TreeNode lca(TreeNode x, TreeNode y){
        TreeNode tmpNode = rootNode;
        //獲取兩個key值
        int xKey = x.getKey();
        int yKey = y.getKey();
        //給兩個元素按從小到大排下序，使得x<y
        if(xKey > yKey){
            int tmpKey = xKey;
            xKey = yKey;
            yKey = tmpKey;
        }
        while(true){
            if(tmpNode.getKey() < xKey){
                //這種情況下，lca在其右子樹上
                tmpNode = tmpNode.getRight();
            }else if(tmpNode.getKey() > yKey){
                //這種情況下，lca在其左子樹上
                tmpNode = tmpNode.getLeft();
            }else{
                return tmpNode;
            }
        }
    }
}

package com.alfred.bstree;

public class testMain {

    public static void main(String[] args) {
        int[] A = new int[]{15,6,18,3,7,17,20,2,4,13,9,3,18,8,8,8,8,8};
        BSTree bsTree = new BSTree(A);
        System.out.println("前序遍歷遞歸方法：");
        bsTree.preOrderTreeWalk();
        System.out.println("\n前序遍歷非遞歸方法：");
        bsTree.preOrderTreeWalkNonrecursive();
        System.out.println("\n中序遍歷遞歸方法：");
        bsTree.inOrderTreeWalk();
        System.out.println("\n中序遍歷非遞歸方法：");
        bsTree.inOrderTreeWalkNonrecursive();
        System.out.println("\n后序遍歷遞歸方法：");
        bsTree.postOrderTreeWalk();
        System.out.println("\n后序遍歷非遞歸方法：");
        bsTree.postOrderTreeWalkNonrecursive();
        System.out.println("\n層序遍歷方法：");
        bsTree.levelOrderTreeWalk();
        
        System.out.println("\n遞歸查找：");
        System.out.println(bsTree.treeSearch(8));
        System.out.println("非遞歸查找：");
        System.out.println(bsTree.treeSearchNonrecursive(8));
        
        System.out.println("\n最大值：");
        System.out.println(bsTree.treeMax());
        System.out.println("最小值：");
        System.out.println(bsTree.treeMin());
        System.out.println("8的后繼：");
        System.out.println(bsTree.treeSuccessor(bsTree.treeSearch(8)));
        System.out.println("8的前驅：");
        System.out.println(bsTree.treePredecessor(bsTree.treeSearch(8)));
        System.out.println("\n最大最小值的LCA：");
        System.out.println(bsTree.lca(bsTree.treeMin(), bsTree.treeMax()));
        
        System.out.println("刪除8之后：");
        TreeNode eight = bsTree.treeSearch(8);
        bsTree.inOrderTreeWalk();
        System.out.println();
        bsTree.treeDelete(eight);
        bsTree.inOrderTreeWalk();
    }
}

　　ps：關於二叉查找樹的一些操作先寫到這里吧，有不對的地方，請廣大博友指正啊。

　　pss：畫圖好累啊。。轉載請注明。。。