897. Increasing Order Search Tree

897. Increasing Order Search Tree

Given a tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only 1 right child.

Example 1:
Input: [5,3,6,2,4,null,8,1,null,null,null,7,9]

       5
      / \
    3    6
   / \    \
  2   4    8
 /        / \ 
1        7   9

Output: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]

 1
  \
   2
    \
     3
      \
       4
        \
         5
          \
           6
            \
             7
              \
                8
                \
                 9 

Note:

1. The number of nodes in the given tree will be between 1 and 100.
2. Each node will have a unique integer value from 0 to 1000.

题目大意：
输入一棵二叉树，然后中序遍历这棵二叉树，得到一个中序序列。按照这个序列，把这棵树转成一棵只有右子树的树。

思路：
核心思路是树的中序遍历，可以写一个递归程序。
以Example1为例，对于节点5来说：

1. 首先通过递归，求得它的左子树序列【1、2、3、4】，返回这个序列的头结点1
2. 然后通过头结点1，依次向后遍历，找到序列【1、2、3、4】的尾节点4，并设置4.right = 5
3. 接着通过递归，求得它的右子树序列【6、7、8、9】，并设置5.right = 6

如果觉得上面的文字描述不容易理解，结合下面的示意图和代码，可能会更好理解。

代码，别看它长，核心也就20行

package com.example.demo.utils;


import java.util.ArrayList;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class Solution {

    /**
     * 树的中序遍历，递归
     * 对于一个树节点root，首先递归求得左子树的头结点father
     * 然后通过father，找到尾节点temp，并设temp.right = root
     * 接着递归求得右子树的头结点
     */
    private static TreeNode increasingBST(TreeNode root) {
        if(root == null) {
            return null;
        }
        // 1、首先递归求得左子树的头结点father
        TreeNode father = increasingBST(root.left);
        // 2、如果father不为空，说明root左子树不为空
        // 则通过father向后遍历 找到尾节点
        if(father != null) {
            TreeNode temp = father;
            while(temp.right != null) {
                temp = temp.right;
            }
            temp.right = root;
        }else {
            // 如果father为空，说明root的左子树为空，这是一棵没有左子树的树
            // 则头结点可以直接设置为root
            father = root;
        }
        root.left = null;
        // 3、递归求得右子树的头结点
        root.right = increasingBST(root.right);
        return father;
    }

    /**
     * 用广搜打印一棵树，用来验证结果是否正确
     */
    private static void printTree(TreeNode root) {
        ArrayList<TreeNode> list = new ArrayList<>();
        list.add(root);
        while(!list.isEmpty()) {
            int size = list.size();
            for(int i = 0; i < size; i++) {
                TreeNode node = list.get(0);
                System.out.print(node.val+" ");
                if(node.left != null) {
                    list.add(node.left);
                }
                if(node.right != null) {
                    list.add(node.right);
                }
                list.remove(node);
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        // Test Case1
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        TreeNode node6 = new TreeNode(6);
        TreeNode node7 = new TreeNode(7);
        TreeNode node8 = new TreeNode(8);
        TreeNode node9 = new TreeNode(9);

        node5.left = node3;
        node5.right = node6;
        node3.left = node2;
        node3.right = node4;
        node2.left = node1;
        node6.right = node8;
        node8.left = node7;
        node8.right = node9;

        TreeNode root = increasingBST(node5);
        printTree(root);
    }
}

程序有点不大好写，用IDEA进行了调试，代码中使用广搜打印树，这是我个人的编程习惯，打印结果如下：

最后也是比较幸运，通过了所有测试用例~