题目描述（困难难度）

99. Recover Binary Search Tree - 图1

依旧是二分查找树的题，一个合法的二分查找树随机交换了两个数的位置，然后让我们恢复二分查找树。不能改变原来的结构，只是改变两个数的位置。二分查找树定义如下：

  1. 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
  2. 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
  3. 任意节点的左、右子树也分别为二叉查找树；
  4. 没有键值相等的节点。

解法一 递归

和 98 题有些像。这里的思路如下：

让我们来考虑交换的位置的可能：

  1. 根节点和左子树的某个数字交换 -> 由于根节点大于左子树中的所有数，所以交换后我们只要找左子树中最大的那个数，就是所交换的那个数

  2. 根节点和右子树的某个数字交换 -> 由于根节点小于右子树中的所有数，所以交换后我们只要在右子树中最小的那个数，就是所交换的那个数

  3. 左子树和右子树的两个数字交换 -> 找左子树中最大的数，右子树中最小的数，即对应两个交换的数

  4. 左子树中的两个数字交换
  5. 右子树中的两个数字交换

思想有了，代码很好写了。

  1. public void recoverTree2(TreeNode root) {
  2.     if (root == null) {
  3.         return;
  4.     }
  5.     //寻找左子树中最大的节点
  6.     TreeNode maxLeft = getMaxOfBST(root.left);
  7.     //寻找右子树中最小的节点
  8.     TreeNode minRight = getMinOfBST(root.right);
  10.     if (minRight != null && maxLeft != null) {
  11.         //左边的大于根节点，右边的小于根节点，对应情况 3，左右子树中的两个数字交换
  12.         if ( maxLeft.val > root.val && minRight.val < root.val) {
  13.             int temp = minRight.val;
  14.             minRight.val = maxLeft.val;
  15.             maxLeft.val = temp;
  16.         }
  17.     }
  19.     if (maxLeft != null) {
  20.         //左边最大的大于根节点，对应情况 1，根节点和左子树的某个数做了交换
  21.         if (maxLeft.val > root.val) {
  22.             int temp = maxLeft.val;
  23.             maxLeft.val = root.val;
  24.             root.val = temp;
  25.         }
  26.     }
  28.     if (minRight != null) {
  29.         //右边最小的小于根节点，对应情况 2，根节点和右子树的某个数做了交换
  30.         if (minRight.val < root.val) {
  31.             int temp = minRight.val;
  32.             minRight.val = root.val;
  33.             root.val = temp;
  34.         }
  35.     }
  36.     //对应情况 4，左子树中的两个数进行了交换
  37.     recoverTree(root.left);
  38.     //对应情况 5，右子树中的两个数进行了交换
  39.     recoverTree(root.right);
  41. }
  42. //寻找树中最小的节点
  43. private TreeNode getMinOfBST(TreeNode root) {
  44.     if (root == null) {
  45.         return null;
  46.     }
  47.     TreeNode minLeft = getMinOfBST(root.left);
  48.     TreeNode minRight = getMinOfBST(root.right);
  49.     TreeNode min = root;
  50.     if (minLeft != null && min.val > minLeft.val) {
  51.         min = minLeft;
  52.     }
  53.     if (minRight != null && min.val > minRight.val) {
  54.         min = minRight;
  55.     }
  56.     return min;
  57. }
  59. //寻找树中最大的节点
  60. private TreeNode getMaxOfBST(TreeNode root) {
  61.     if (root == null) {
  62.         return null;
  63.     }
  64.     TreeNode maxLeft = getMaxOfBST(root.left);
  65.     TreeNode maxRight = getMaxOfBST(root.right);
  66.     TreeNode max = root;
  67.     if (maxLeft != null && max.val < maxLeft.val) {
  68.         max = maxLeft;
  69.     }
  70.     if (maxRight != null && max.val < maxRight.val) {
  71.         max = maxRight;
  72.     }
  73.     return max;
  74. }

解法二

参考 这里。

如果记得 98 题，我们判断是否是一个合法的二分查找树是使用到了中序遍历。原因就是二分查找树的一个性质，左孩子小于根节点，根节点小于右孩子。所以做一次中序遍历，产生的序列就是从小到大排列的有序序列。

回到这道题，题目交换了两个数字，其实就是在有序序列中交换了两个数字。而我们只需要把它还原。

交换的位置的话就是两种情况。

  • 相邻的两个数字交换

    [ 1 2 3 4 5 ] 中 2 和 3 进行交换，[ 1 3 2 4 5 ]，这样的话只产生一组逆序的数字（正常情况是从小到大排序，交换后产生了从大到小），3 2。

    我们只需要遍历数组，找到后，把这一组的两个数字进行交换即可。

  • 不相邻的两个数字交换

    [ 1 2 3 4 5 ] 中 2 和 5 进行交换，[ 1 5 3 4 2 ]，这样的话其实就是产生了两组逆序的数字对。5 3 和 4 2。

    所以我们只需要遍历数组，然后找到这两组逆序对，然后把第一组前一个数字和第二组后一个数字进行交换即完成了还原。

所以在中序遍历中，只需要利用一个 pre 节点和当前节点比较，如果 pre 节点的值大于当前节点的值，那么就是我们要找的逆序的数字。分别用两个指针 first 和 second 保存即可。如果找到第二组逆序的数字，我们就把 second 更新为当前节点。最后把 first 和 second 两个的数字交换即可。

中序遍历，参考 94 题 ，有三种方法，递归，栈，Morris 。这里的话，我们都改一下。

1. 递归版中序遍历

  1. TreeNode first = null;
  2. TreeNode second = null;
  3. public void recoverTree(TreeNode root) {
  4.     inorderTraversal(root);
  5.     int temp = first.val;
  6.     first.val = second.val;
  7.     second.val = temp;
  8. }
  9. TreeNode pre = null;
  10. private void inorderTraversal(TreeNode root) {
  11.     if (root == null) {
  12.         return;
  13.     }
  14.     inorderTraversal(root.left); 
  15.     /*******************************************************/
  16.     if(pre != null && root.val < pre.val) {
  17.         //第一次遇到逆序对
  18.         if(first==null){
  19.             first = pre;
  20.             second = root;
  21.         //第二次遇到逆序对
  22.         }else{
  23.             second = root;
  24.         }
  25.     }
  26.     pre = root; 
  27.     /*******************************************************/
  28.     inorderTraversal(root.right);
  29. }

2. 栈版中序遍历

  1. TreeNode first = null;
  2. TreeNode second = null;
  4. public void recoverTree(TreeNode root) {
  5.     inorderTraversal(root);
  6.     int temp = first.val;
  7.     first.val = second.val;
  8.     second.val = temp;
  9. }
  11. public void inorderTraversal(TreeNode root) {
  12.     if (root == null)
  13.         return;
  14.     Stack<TreeNode> stack = new Stack<>();
  15.     TreeNode pre = null;
  16.     while (root != null || !stack.isEmpty()) {
  17.         while (root != null) {
  18.             stack.push(root);
  19.             root = root.left;
  20.         }
  21.         root = stack.pop();
  22.         /*******************************************************/
  23.         if (pre != null && root.val < pre.val) {
  24.             if (first == null) {
  25.                 first = pre;
  26.                 second = root;
  27.             } else {
  28.                 second = root;
  29.             }
  30.         }
  31.         pre = root;
  32.         /*******************************************************/
  33.         root = root.right;
  34.     }
  35. }

3. Morris 版中序遍历

因为之前这个方法中用了 pre 变量，为了方便，这里也需要 pre 变量，我们用 pre_new 代替。具体 Morris 遍历算法参见 94 题 。利用 Morris 的话，我们的空间复杂度终于达到了 O（1）。

  1. public void recoverTree(TreeNode root) {
  2.     TreeNode first = null;
  3.     TreeNode second = null;
  4.     TreeNode cur = root;
  5.     TreeNode pre_new = null;
  6.     while (cur != null) {
  7.         // 情况 1
  8.         if (cur.left == null) {
  9.             /*******************************************************/
  10.             if (pre_new != null && cur.val < pre_new.val) {
  11.                 if (first == null) {
  12.                     first = pre_new;
  13.                     second = cur;
  14.                 } else {
  15.                     second = cur;
  16.                 }
  17.             }
  18.             pre_new = cur;
  19.             /*******************************************************/
  20.             cur = cur.right;
  21.         } else {
  22.             // 找左子树最右边的节点
  23.             TreeNode pre = cur.left;
  24.             while (pre.right != null && pre.right != cur) {
  25.                 pre = pre.right;
  26.             }
  27.             // 情况 2.1
  28.             if (pre.right == null) {
  29.                 pre.right = cur;
  30.                 cur = cur.left;
  31.             }
  32.             // 情况 2.2
  33.             if (pre.right == cur) {
  34.                 pre.right = null; // 这里可以恢复为 null
  35.                 /*******************************************************/
  36.                 if (pre_new != null && cur.val < pre_new.val) {
  37.                     if (first == null) {
  38.                         first = pre_new;
  39.                         second = cur;
  40.                     } else {
  41.                         second = cur;
  42.                     }
  43.                 }
  44.                 pre_new = cur;
  45.                 /*******************************************************/
  46.                 cur = cur.right;
  47.             }
  48.         }
  49.     }
  51.     int temp = first.val;
  52.     first.val = second.val;
  53.     second.val = temp;
  54. }

总

自己开始看到二分查找树，还是没有想到中序遍历，而是用了递归的思路去分析。可以看到如果想到中序遍历，题目会简单很多。

windliang wechat

添加好友一起进步~

如果觉得有帮助的话，可以点击 这里 给一个 star 哦 ^^

如果想系统的学习数据结构和算法，强烈推荐一个我之前学过的课程，可以点击 这里 查看详情