LeetCode 99. Recover Binary Search Tree（修复二叉搜索树）

原题网址：https://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?

方法一：发现有错误顺序则交换，知道全部正确。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private List<TreeNode> errors = new ArrayList<>();
    private int min(TreeNode root) {
        if (root.left != null) return min(root.left);
        return root.val;
    }
    private int max(TreeNode root) {
        if (root.right != null) return max(root.right);
        return root.val;
    }
    private TreeNode rightmost(TreeNode root) {
        if (root.right != null) return rightmost(root.right);
        return root;
    }
    private TreeNode leftmost(TreeNode root) {
        if (root.left != null) return leftmost(root.left);
        return root;
    }
    boolean swapped = false;
    private void swap(TreeNode node1, TreeNode node2) {
        int temp = node1.val;
        node1.val = node2.val;
        node2.val = temp;
        swapped = true;
    }
    private void check(TreeNode root) {
        if (root.left != null) {
            if (root.left.val >= root.val) {
                swap(root, root.left);
            }
            check(root.left);
            if (max(root.left) >= root.val) {
                TreeNode rightmost = rightmost(root.left);
                swap(root, rightmost);
            }
        }
        if (root.right != null) {
            if (root.right.val <= root.val) {
                swap(root, root.right);
            }
            check(root.right);
            if (min(root.right) <= root.val) {
                TreeNode leftmost = leftmost(root.right);
                swap(root, leftmost);
            }
        }
    }
    public void recoverTree(TreeNode root) {
        do {
            swapped = false;
            check(root);
        } while (swapped);
    }
}

方法二：分析两种错误。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private void swap(TreeNode n1, TreeNode n2) {
        int t = n1.val;
        n1.val = n2.val;
        n2.val = t;
    }
    
    private TreeNode[] errors = new TreeNode[4];
    private int count;
    private TreeNode prev;
    private void check(TreeNode root) {
        if (count == 4) return;
        if (root.left != null) check(root.left);
        if (prev != null && prev.val > root.val) {
            errors[count++] = prev;
            errors[count++] = root;
        }
        prev = root;
        if (root.right != null) check(root.right);
    }
    
    public void recoverTree(TreeNode root) {
        check(root);
        if (count == 2) swap(errors[0], errors[1]);
        else swap(errors[0], errors[3]);
    }
}

可以把prev作为递归函数参数。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    private TreeNode[] errors = new TreeNode[4];
    private int count = 0;
    private TreeNode traverse(TreeNode prev, TreeNode node) {
        if (count == 4) return node;
        if (node.left != null) prev = traverse(prev, node.left);
        if (prev != null && prev.val > node.val) {
            errors[count++] = prev;
            errors[count++] = node;
        }
        if (node.right == null) return node;
        return traverse(node, node.right);
    }
    public void recoverTree(TreeNode root) {
        if (root == null) return;
        traverse(null, root);
        if (count == 2) {
            int t = errors[0].val;
            errors[0].val = errors[1].val;
            errors[1].val = t;
        } else {
            int t = errors[0].val;
            errors[0].val = errors[3].val;
            errors[3].val = t;
        }
    }
}