二叉查找树（五）

　　接上一篇，继续讲二叉查找树的操作，之前的博客都讲得差不多了，本篇就讲一下删除操作，以及求最矮公共父结点（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：画图好累啊。。转载请注明。。。