AVL平衡树

左 旋 :
原数组: [4,3,6,5,7,8]
1.创建一个新节点值等于根节点
newNode = root;
2.把新节点的左子数设置成当前节点的左子树
newNode.left = root.left;
3.把新节点的右子树设置成当前节点的右子树的左子树
newNode.right=root.right.left;
4.把当前节点的值换为右子节点的值
root.value = root.right.value
5.把当前节点的右子树设置成右子树的右子树
root.right= root.right.right
6.把当前节点的左子树设置成新节点
root.left = newNode
右旋降低左子树高度
1.创建一个新的节点 newNode值等于当前节点
2.把新的节点的右子树设置为当前节点的右子树
newNode.right = root.right;
3.把新的节点左子树,设置为当前节点的左子树的右子树
newNode.left=root.left.right
4.把当前节点的值换成左子树的节点的值
root.value = root.left.value
5.把当前节点的左子树设置成左子树的左子树
root.left=root.left.left
6.把当前节点的右子树设置成为新的节点
root.right=newNode
**

双旋转1 :

/**
* 双旋转
* 1.当符合右旋的条件时,
* 2.如果他的左子树的右子树的高度大于他的左子树子树
* 3先对当前节点左节点进行左旋转
* 4再对当前节点进行右旋转
*/

双旋转2 :
/**
* 如果当前节点右子树的左子树的高度大于当前节点的右子树的右子树的高度
* 1.先对当前节点的右子树进行右旋转
* 2.再对当前节点进行左旋转
*/

package com.example.demo.code50;

/**
 * @author ming
 * @create 2022/6/2
 * @description:
 */
public class AVLBinaryTree {
    private static Node root;
    static class Node{
       int value;
       Node left;
       Node right;

        public Node(int value) {
            this.value = value;
        }
        public  Node createSortTree(int [] arr) {
            if(arr.length<1)return null;
            Node root = new Node(arr[0]);
            for (int i = 1; i < arr.length; i++) {
                root.createSortTree(new Node(arr[i]));
            }
            return root;
        }
        //左旋
        public  void leftCircle(Node node){
            Node newNode = new Node(node.value);
            newNode.left = node.left;
            newNode.right = node.right.left;
            node.value = node.right.value;
            node.right = node.right.right;
            node.left=newNode;
        }
        //右旋
        public void rightCircle(Node node){
            Node newNode = new Node(node.value);
            newNode.right = node.right;
            newNode.left = node.left.right;
            node.value = node.left.value;
            node.left = node.left.left;
            node.right = newNode;

        }
        public  void createSortTree(Node node) {
           if(node==null)return;
           if(node.value<this.value){
               if(this.left==null){
                   this.left = node;
               }else{
                   this.left.createSortTree(node);
               }
           }else{
               if(this.right==null){
                   this.right = node;
               }else{
                   this.right.createSortTree(node);
               }
           }
       }
        public  int getHeight(Node node){
            if(node==null) return 0;
            int leftHight = getHeight(node.left);
            int rightHight = getHeight(node.right);
            return Math.max(leftHight, rightHight)+1;
        }
        public  void infixOrder(Node node){
            if(node==null)return ;
            infixOrder(node.left);
            System.out.print(node.value+" ");
            infixOrder(node.right);

        }
   }




    public static void main(String[] args) {
       int[] arr = {10,11,7,6,8,9};
        //int[] arr = {10,9,8,7,6,5,4,3,2,1};
        Node root = new Node(0);
        Node node = root.createSortTree(arr);
        node.infixOrder(node);
        System.out.println();
        System.out.println("旋转之前"+node.getHeight(node));
        System.out.println("**************");


            /**
             * 双旋转
             * 1.当符合右旋的条件时,
             * 2.如果他的左子树的右子树的高度大于他的左子树子树
             * 3先对当前节点左节点进行左旋转
             * 4再对当前节点进行右旋转
             */
        System.out.println("旋转之前左边的高度"+node.getHeight(node.left));
        System.out.println("旋转之前的右边的高度"+node.getHeight(node.right));
          while(node.getHeight(node.left)-node.getHeight(node.right)>1){
            //如果他的左子树的右子树的高度大于他的左子树的高度
            if((node.left!=null)&&(node.getHeight(node.left.right)>node.getHeight(node.left.left))){
                 //先对这个节点的左节点先进行左旋转
                node.leftCircle(node.left);
                //在对当前节点进行右旋转
                node.rightCircle(node);
            }else{
                node.rightCircle(node);
            }

        }
        /**
         * 如果当前节点右子树的左子树的高度大于当前节点的右子树的右子树的高度
         * 1.先对当前节点的右子树进行右旋转
         * 2.再对当前节点进行左旋转
         */
        //while (node.getHeight(node.right)-node.getHeight(node.right)>1){
        //    if(node.right!=null&&node.getHeight(node.right.left)>node.getHeight(node.right.right)){
        //        node.rightCircle(node.right);
        //    }else{
        //        node.rightCircle(node);
        //    }
        //}
        System.out.println(node.left.value);
        System.out.println("旋转后左"+node.getHeight(node.left));
        System.out.println("旋转后右"+node.getHeight(node.right));
        System.out.println("旋转后左子节点"+node.left.value);
        System.out.println("旋转后右子节点"+node.right.value);
    }

}