平衡二叉树的实现 java

平衡二叉树的实现：

程序输出结果为：

前序遍历结果：

8   5   2   7   6   9   69   

中序遍历结果

2    5    6    7    8    9    69

 

两种遍历结果可以唯一确定一颗二叉树，从而得出二叉树如下图所示：为一颗平衡二叉树。 

代码如下所示：

package AlgorithmTest;

/**
 * Created by dell on 2016/12/14.
 */
import java.util.ArrayList;
import java.util.Collections;

/**
 *
 * 平衡二叉树编写的有两个突破口，
 * 1、一个假设这颗二叉树已经是一个平衡二叉树，加入一个节点之后，不平衡了需要调整的也只有最末的那颗不平衡的树
 * 2、插入一个节点时如果这个节点,只有这个节点经过的节点有影响平衡因子，
 * 如果这个节点应该插入某个节点的左子树则，平衡因子+1，假设平衡因为=左子树高度-右子数高度
 * 3、最末的各个不平衡书的所有节点，要记录，调整完之后，这些节点的平衡因子要减一；
 *  @author  liyiwen1
 *  @date  2016/12/11
 */
public class AVLTree  {
    public static void main(String[] args) {
        AVLTree avlTree =  new AVLTree();
        Integer[] integers =  new Integer[]{ 8, 9, 2, 7, 5, 2, 69, 7, 2, 6};
        for (Integer i : integers){
            avlTree.insert(i);
        }
        System. out.println( "前序遍历结果：");
        avlTree.preOrder(avlTree.getRoot());
        System. out.println();
        System. out.println( "中序遍历结果");
        avlTree.midOrder(avlTree.getRoot());
    }
    private static class AVLTreeNode  implements Comparable<AVLTreeNode>{
        private Comparable  value;
        private int  balanceUnit =  0;
        private AVLTreeNode  left;
        private AVLTreeNode  rigtht;

        @Override
        public int compareTo(AVLTreeNode a){
            return  value.compareTo(a.getValue());
        }
        public Comparable getValue() {
            return  value;
        }

        public void setValue(Comparable value) {
            this. value = value;
        }

        public int getBalanceUnit() {
            return  balanceUnit;
        }

        public void setBalanceUnit( int balanceUnit) {
            this. balanceUnit = balanceUnit;
        }

        public AVLTreeNode getLeft() {
            return  left;
        }

        public void setLeft(AVLTreeNode left) {
            this. left = left;
        }

        public AVLTreeNode getRigtht() {
            return  rigtht;
        }

        public void setRigtht(AVLTreeNode rigtht) {
            this. rigtht = rigtht;
        }

        public AVLTreeNode(Comparable value) {
            this. value = value;
        }
    }

    private AVLTreeNode  root;



    public AVLTree() {
    }

    private void insert(Comparable value){
        if ( root ==  null){
            root =  new AVLTreeNode(value);
            root.setBalanceUnit( 0);
            root.setLeft( null);
            root.setRigtht( null);
            return;
        }

        if (find(value)){
            return; //如果相等则直接返回，不存储value相同的节点
        }
        AVLTreeNode needRotationTreeRoot =  null;
        AVLTreeNode treeNode =  this. root;
        ArrayList<AVLTreeNode> avlTreeNodes =  new ArrayList<AVLTreeNode>();
        while ( true){
            avlTreeNodes.add(treeNode); //所经过的父节点都保存起来
            if (value.compareTo(treeNode.getValue()) >  0){
                treeNode. balanceUnit--; //如果插入值大于父节点则平衡因子减一
                if (treeNode. balanceUnit >=  2 || treeNode. balanceUnit <= - 2 ){
                    needRotationTreeRoot = treeNode; //记录最后一个不平衡的节点
                }
                if (treeNode.getRigtht() ==  null){
                    treeNode.setRigtht( new AVLTreeNode(value));
                    break;
                } else{
                    treeNode = treeNode.getRigtht(); //继续往右边走
                }
             } else if (value.compareTo(treeNode.getValue()) <  0){
                treeNode. balanceUnit++; //如果插入的值小于父节点的值，则父节点的平衡因子加一
                if (treeNode. balanceUnit >=  2 || treeNode. balanceUnit <= - 2){
                    needRotationTreeRoot = treeNode; //记录最后一个不平衡的节点
                }
                if (treeNode.getLeft() ==  null){
                    treeNode.setLeft( new AVLTreeNode(value));
                    break;
                } else{
                    treeNode = treeNode.getLeft();
                }
            }
        }
        if (needRotationTreeRoot ==  null){
            return ; //没有半个失去平衡的节点，则返回
        } else{
            for ( int i =  0; i < avlTreeNodes.size() -  2 ; i++){ //后两个父节点由于处于调节的范畴，不进行平衡因子绝对值的调整
                if (avlTreeNodes.get(i). balanceUnit >  0){
                    avlTreeNodes.get(i). balanceUnit--;
                } else if (avlTreeNodes.get(i). balanceUnit <  0){
                    avlTreeNodes.get(i). balanceUnit++;
                }
            }
            if (avlTreeNodes.size() >=  3){
                rotation(needRotationTreeRoot, avlTreeNodes.get(avlTreeNodes.size() -  3)); //父节点只有3个已上
            } else{
                rotation(needRotationTreeRoot,  null); //父节点只有两个
            }
        }
    }

    public boolean find(Comparable value){
        AVLTreeNode node = getRoot();
        while (node !=  null){
            if (node.getValue().compareTo(value) ==  0){
                return true;
            } else if (node.getValue().compareTo(value) >  0){
                node = node.getLeft();
            } else{
                node = node.getRigtht();
            }
        }
        return false;
    }

    public void preOrder(AVLTreeNode node){
        if (node !=  null){
            System. out.print(node.getValue() +  "   ");
            preOrder(node.getLeft());
            preOrder(node.getRigtht());
        }
    }

    public void midOrder(AVLTreeNode node){
        if (node !=  null){
            midOrder(node.getLeft());
            System. out.print(node.getValue() +  "    ");
            midOrder(node.getRigtht());
        }
    }

    //needRotationTreeRootFather表示最末端的不平衡二叉树的根节点的父节点，这里有个特例即needRotationTreeRootFather为null
    private void rotation(AVLTreeNode needRotationTreeRoot, AVLTreeNode needRotationTreeRootFather){
        ArrayList<AVLTreeNode> nodes =  new ArrayList<AVLTreeNode>();
        transase(needRotationTreeRoot, nodes);
        Collections. sort(nodes);
        for (AVLTreeNode node: nodes){
            node.setLeft( null);
            node.setRigtht( null);
            node.setBalanceUnit( 0);
        }
        nodes.get( 1).setLeft(nodes.get( 0));
        nodes.get( 1).setRigtht(nodes.get( 2));
        if (needRotationTreeRootFather ==  null){
            this. root = nodes.get( 1);
            return ; //处理needRotationTreeRootFather为null的情况
        }
        if (needRotationTreeRootFather.getLeft() == needRotationTreeRoot){
            needRotationTreeRootFather.setLeft(nodes.get( 1));
        } else if (needRotationTreeRootFather.getRigtht() == needRotationTreeRoot){
            needRotationTreeRootFather.setRigtht(nodes.get( 1));
        } else{
            throw new RuntimeException();
        }
    }

    private void transase(AVLTreeNode root, ArrayList<AVLTreeNode> nodes){
        if (root !=  null){
            nodes.add(root);
            transase(root.getLeft(), nodes);
            transase(root.getRigtht(), nodes);
        }
    }

    private AVLTreeNode getRoot() {
        return  root;
    }

    private void setRoot(AVLTreeNode root) {
        this. root = root;
    }
}