[LeetCode] Recover Binary Search Tree

原题地址：https://oj.leetcode.com/problems/recover-binary-search-tree/

Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

Note:
A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?

思路，这道题就是需要找到逆序的两个点。显然我们能想到是对BST进行中序遍历，因为中序二叉搜索数遍历的结果是按顺序排列的，比如书 1234567。找到逆序对，如果只有一对相邻逆序对，比如 1324567，只需将相邻的两个节点记住，在交换即可，若是不是相邻的两个点位置对调，比如 1534267，中序遍历的过程中会发现两个相邻逆序对 53 和 42，只需交换第一个逆序对的前一个点和第二个逆序对的后一个点即可恢复二叉搜索数，总结起来就是交换第一个逆序对的第一个点和最后一个逆序对的后一个节点。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void recoverTree(TreeNode root) {
        if (root == null) {
            return;
        }
        
        List<TreeNode> pre = new ArrayList<TreeNode>();
        List<TreeNode> res = new ArrayList<TreeNode>();
        
        helper(root, pre, res);
        
        if (res.size() > 0) {
            int temp = res.get(0).val;
            res.get(0).val = res.get(1).val;
            res.get(1).val = temp;
        }
    }
    
    private void helper(TreeNode node, List<TreeNode> pre, List<TreeNode> res) {
        if (node == null) {
            return;
        }
        
        helper(node.left, pre, res);
        if (pre.size() > 0 && pre.get(0).val > node.val) {
            if (res.size() < 1) {
                res.add(pre.get(0));
                res.add(node);
            } else {
                res.set(1, node);
            }
        }
        if (pre.size() > 0) {
            pre.set(0, node);
        } else {
            pre.add(node);
        }
        
        
        helper(node.right, pre, res);
    }

}

以上方法遍历一次时间复杂度 O(n)，但是递归栈空间为 O(logn)。题目需要常数空间，常数空间O（n）时间复杂度只能想到Morris遍历。故也可采用Morris遍历，思路也是一样的。