[leetcode] 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.

---

分析：题目翻译一下：根据中序遍历，调整二叉树，变成所有的节点都在右子树上。 

思路一：第一个想法，先对树进行中序遍历，保存中序遍历的结果；然后生成一个新树，按照上边的顺序连接起来。

代码如下：

class Solution {
    List<Integer> list = new ArrayList<>();
    public TreeNode increasingBST(TreeNode root){
        zxbl(root);
        TreeNode head = new TreeNode(0);
        TreeNode node = head;
        for ( int n : list ){
            //System.out.println(n);
            head.right = new TreeNode(n);
            head = head.right;
        }
        return node.right;
    }
    private void zxbl(TreeNode root) {
        if ( root == null ) return;
        zxbl(root.left);
        list.add(root.val);
        zxbl(root.right);
    }
}

    运行时间73ms，显然是一个不太好的方法。

思路二：延续上面的思路，之前list中保存的是root 的值，如果直接保存root是不是更快一点呢？

代码如下：

class Solution {
    List<TreeNode> list = new ArrayList<>();
    public TreeNode increasingBST(TreeNode root){
        zxbl(root);
        TreeNode head = new TreeNode(0);
        TreeNode node = head;
        for ( TreeNode n : list ){
            head.right = n;
            head = head.right;
            head.left=null;
            
        }
        return node.right;
    }
    private void zxbl(TreeNode root) {
        if ( root == null ) return;
        zxbl(root.left);
        list.add(root);
        zxbl(root.right);
    }
}

    运行时间36ms，击败74.29%。这里一定要注意红色部分，要给左指针附上null，否则会报错。

思路三：下面想想如何去掉list整个限制呢？也就是在中序遍历的过程中，就实现链接。

代码如下：

class Solution {
    TreeNode head;
    public TreeNode increasingBST(TreeNode root){
        if ( root == null ) return null;
        TreeNode node = new TreeNode(0);
        head = node;
        zxbl(root);
        return node.right;
    }
    private void zxbl(TreeNode root) {
        if ( root == null ) return;
        zxbl(root.left);
        root.left=null;
        head.right = root;
        head = root;
        zxbl(root.right);
    }
}

    运行时间34ms，击败82.92%。这里要注意13行红色代码，我的理解是：这里的root就已经是左孩子为null，右孩子不变的一个节点，然后链接到head上。

    我又尝试了如何划归到上面list版本的形式，代码如下：

class Solution {
    TreeNode head;
    public TreeNode increasingBST(TreeNode root){
        if ( root == null ) return null;
        TreeNode node = new TreeNode(0);
        head = node;
        zxbl(root);
        return node.right;
    }
    private void zxbl(TreeNode root) {
        if ( root == null ) return;
        zxbl(root.left);
        
        head.right = root;
        head = head.right;
        head.left=null;
        
        zxbl(root.right);
    }
}

    基本没什么太大的变化，主要这里就是先下移，然后令左孩子为null；上面的是先令左孩子为null，再下移。一样的。

思路四：虽然上面的解法可以获得答案，但是题目中提示：对树进行rearrange，而不是去新建一棵树。所以下面就是寻找一个新的方法，对原来的树进行操作。

附上discuss中大神的解法：

    public TreeNode increasingBST(TreeNode root) {
        return helper(root, null);
    }

    public TreeNode increasingBST(TreeNode root, TreeNode tail) {
        if (root == null) return tail;
        TreeNode res = increasingBST(root.left, root);
        root.left = null;
        root.right = increasingBST(root.right, tail);
        return res;
    }

    这个方法比较难以理解，我尽量理解并且讲明白：

    这里要注意一点，它的整个思路就是res = inorder(root.left) + root + inorder(root.right)。

    关键来看一下tail这个变量，tail保存的是比当前节点最近最大的一个节点，而且仅仅在左子树的遍历的时候赋值。比如上面的案例，刚开始就已知遍历到1，这个时候tail指向2，然后回到父节点2，tail指向3，因为2没有右孩子，所以指向父节点3，这个时候tail指向5，然后遍历3的右孩子4，然后回到5。在这里就链接好了1-2-3-4-5。在遍历右子树时，tail为null，最后链接在9上。

    感觉过程太玄学，不容易理解，还是之前的方法更形象一点。