LeetCode.897-递增搜索树(Increasing Order Search Tree)

这是悦乐书的第346次更新，第370篇原创

01 看题和准备

今天介绍的是LeetCode算法题中Easy级别的第211题（顺位题号是897）。给定一棵树，按中序遍历顺序重新排列树，以便树中最左边的节点现在是树的根，并且每个节点都没有左子节点，只有一个右子节点。例如：

输入:[5,3,6,2,4，null，8,1，null，null，null，7,9]

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

输出:[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

注意：

• 给定树中的节点数将介于1和100之间。

• 每个节点都有一个0到1000的唯一整数值。

02 第一种解法

先对原二叉树通过递归的方式进行中序遍历，将所有的节点值存入一个List中，以List中的第一个元素作为根节点，再遍历List中剩下的其他元素，作为树的右子节点，最后返回新树。

public TreeNode increasingBST(TreeNode root) {
    List<Integer> list = new ArrayList<Integer>();
    inorder(root, list);
    TreeNode result = new TreeNode(list.get(0));
    TreeNode ans = result;
    for (int i=1; i<list.size(); i++) {
        ans.right = new TreeNode(list.get(i));
        ans = ans.right;
    }
    return result;
}

public void inorder(TreeNode node, List<Integer> list){
    if (node == null) {
        return ;
    }
    inorder(node.left, list);
    list.add(node.val);
    inorder(node.right, list);
}

03 第二种解法

思路和第一种解法一样，只是将中序遍历二叉树从递归换成了迭代。

public TreeNode increasingBST2(TreeNode root) {
    List<Integer> list = new ArrayList<Integer>();
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while (root != null || !stack.isEmpty()) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        if (!stack.isEmpty()) {
            root = stack.pop();
            list.add(root.val);
            root = root.right;
        }
    }
    TreeNode result = new TreeNode(list.get(0));
    TreeNode ans = result;
    for (int i=1; i<list.size(); i++) {
        ans.right = new TreeNode(list.get(i));
        ans = ans.right;
    }
    return result;
}

04 第三种解法

我们还可以再简化下，不使用List来存储原二叉树的节点值，直接将得到的节点值作为新二叉树的节点值即可。

public TreeNode increasingBST3(TreeNode root) {
    TreeNode result = new TreeNode(0);
    TreeNode ans = result;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    while (root != null || !stack.isEmpty()) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        if (!stack.isEmpty()) {
            root = stack.pop();
            // 直接处理节点，作为新树的右子节点
            ans.right = new TreeNode(root.val);
            ans = ans.right;
            root = root.right;
        }
    }
    return result.right;
}

05 第四种解法

针对上面的第三种解法，我们也可以使用递归来解。

TreeNode ans;
public TreeNode increasingBST4(TreeNode root) {
    TreeNode result = new TreeNode(0);
    ans = result;
    helper(root);
    return result.right;
}

public void helper(TreeNode root) {
    if (root == null) {
        return ;
    }
    helper(root.left);
    ans.right = new TreeNode(root.val);
    ans = ans.right;
    helper(root.right);
}

06 小结

算法专题目前已连续日更超过六个月，算法题文章214+篇，公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词，获取系列文章合集。

以上就是全部内容，如果大家有什么好的解法思路、建议或者其他问题，可以下方留言交流，点赞、留言、转发就是对我最大的回报和支持！