二叉树的左右双旋和右左双旋

• 上节我们有讲到用单旋构建平衡树，但是单旋存在局限情况，现在我们来探讨双旋（左右双旋|右左双旋） 。
  如下图，一颗较为特殊二叉排序树：
  
  利用单旋的方式构建一下：
  
  最后的结果我们会发现并没有达到平衡效果。
  然后我们我们使用双旋的方式来构建一下：
  
  可以看到成功构建成平衡二叉树了。

  • 双旋（左右双旋|右左双旋）

  • 代码实现：

  /**
   * 二叉树结点
   */
  public class TreeNode {
      public int val;
      public TreeNode left;
      public TreeNode right;
  
      public TreeNode(int val, TreeNode left, TreeNode right) {
          this.val = val;
          this.left = left;
          this.right = right;
      }
  
      public TreeNode(int val) {
          this.val = val;
      }
  }
  

      //求二叉树的深度
      public static int getDeep(TreeNode root){
          if(root == null) return 0;
          int leftDeep = getDeep(root.left);
          int rightDeep = getDeep(root.right);
          return leftDeep>rightDeep?leftDeep+1:rightDeep+1;
      }
  
      //判断二叉树是否平衡的
      public static boolean isBalance(TreeNode root){
          if(root == null) return true;
          int leftDeep = getDeep(root.left);
          int rightDeep = getDeep(root.right);
          if(Math.abs(leftDeep - rightDeep) > 1) return false;
          return isBalance(root.left) && isBalance(root.right);
      }
  
      //构建平衡二叉树
      public static TreeNode toBalanceTree(TreeNode root){
          if(root == null) return null;
          root.left = toBalanceTree(root.left);
          root.right = toBalanceTree(root.right);
          int leftDeep = getDeep(root.left);
          int rightDeep = getDeep(root.right);
          if(leftDeep - rightDeep > 1){//不平衡 左边深，需要右旋
              System.out.println("不平衡 左边深，需要右旋");
              int lld = getDeep(root.left.left);
              int lrd = getDeep(root.left.right);
              if(lrd > lld) root.left = leftRotate(root.left);
              return rightRotate(root);
          }else if(rightDeep - leftDeep > 1){//不平衡 右边深， 需要左旋
              System.out.println("不平衡 右边深， 需要左旋");
              int rld = getDeep(root.right.left);
              int rrd = getDeep(root.right.right);
              if(rld < rrd) root.right = leftRotate(root.right);
              return leftRotate(root);
          }
          return root;
      }
  
      //左旋
      public static TreeNode leftRotate(TreeNode root){
          TreeNode originRoot = root;
          TreeNode newRoot = root.right;
          TreeNode tempBranch = newRoot.left;
          newRoot.left = originRoot;
          originRoot.right = tempBranch;
          return newRoot;
      }
  
      //右旋
      public static TreeNode rightRotate(TreeNode root){
          TreeNode originRoot = root;
          TreeNode newRoot = root.left;
          TreeNode tempBranch = newRoot.right;
          newRoot.right = originRoot;
          originRoot.left = tempBranch;
          return newRoot;
      }
  

  public class Main {
      public static void main(String[] args) {
  
          TreeNode node1 = new TreeNode(4);
          TreeNode node2 = new TreeNode(5);
          TreeNode node3 = new TreeNode(6);
          TreeNode node4 = new TreeNode(7);
          TreeNode node5 = new TreeNode(8);
  
          node5.left = node4;
          node4.left = node3;
          node3.left = node2;
          node2.left = node1;
  
          System.out.println(isBalance(node5));//fasle
          TreeNode newRoot = toBalanceTree(node5);
          System.out.println(isBalance(newRoot));//true debug
          System.out.println("构建完成");// debug一下
      }
  
  

  查看结果：
  
  可以看到构建成功了。