LeetCode 力扣 99. 恢复二叉搜索树 recoverTree

大家觉得写还可以，可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn

---

99. 恢复二叉搜索树

二叉搜索树中的两个节点被错误地交换。

请在不改变其结构的情况下，恢复这棵树。

示例 1:

输入: [1,3,null,null,2]

   1
  /
 3
  \
   2

输出: [3,1,null,null,2]

   3
  /
 1
  \
   2

示例 2:

输入: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

输出: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3

进阶:

使用 O(n) 空间复杂度的解法很容易实现。
你能想出一个只使用常数空间的解决方案吗？

分析

朴素二叉树定义方法分析

题目中是二叉顺序树两个节点互换，那么就有5种交换可能。

1. 根结点与左子树上的某个节点互换
2. 根结点与右子树上的某个节点互换
3. 左子树上的某个节点与右子树上的某个节点互换
4. 左子树上的两个节点互换
5. 右子树的两个节点互换

• 对于互换1，找到左子树中的最大节点的值与根结点的值比较，若是左子树中的最大节点的值大于根结点的值，则两个节点的值进行交换。
• 对于互换2，同上。把左子树中的最大节点的值换成右子树中的最小节点的值，大于换成小于。
• 对于互换3，若左子树中的最大节点的值 > 根结点的值 > 右子树中的最小节点的值,左右两节点进行交换。
• 对于互换4、5，可把根结点的左右子树看成一颗新树，进行递归。

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
   /*  求左子树中val最大的节点，用于和根结点比较，适用于互换1 */
    void max(TreeNode* root,TreeNode* &big){
        if(!root) return ;
        if(root->val > big ->val){
            big = root;
        }
        max(root->left,big);
        max(root->right,big);
        
    }
   /*  求右子树中val最小的节点，用于和根结点比较 ，适用于互换2*/
    void min(TreeNode* root,TreeNode* &small){
        if(!root) return ;
        if(root->val < small ->val){
            small = root;
        }
        min(root->left,small);
        min(root->right,small);
    }
    void recoverTree(TreeNode* root) {
        if(!root) return;
        TreeNode* r = root;
        TreeNode *left = root->left ;
        TreeNode *right =  root->right ;
        max(root->left,left);// 求左子树中val最大的节点
        min(root->right,right);//求右子树中val最小的节点
        //互换3，左右互换
        if((left != NULL) && (right != NULL) && (root->val < left->val) && (root->val > right->val) ){
            int val = left->val;
            left->val = right->val;
            right->val = val;
        }
        else if((left != NULL) && (root->val < left->val)){//互换1
            int val = left->val;
            left->val = root->val;
            root->val = val;
        }
        else if( (right != NULL) && (root->val > right->val)){//互换2
            int val = right->val;
            right->val = root->val;
            root->val = val;
        }
        else{//互换4和5
            recoverTree(r->left);
            recoverTree(r->right);
        }
    }
};

栈思路分析

我们只关心中序遍历的值序列中每个相邻的位置的大小关系是否满足条件，且错误交换后最多两个位置不满足条件，因此在中序遍历的过程我们只需要维护当前中序遍历到的最后一个节点 $pred$，然后在遍历到下一个节点的时候，看两个节点的值是否满足前者小于后者即可，如果不满足说明找到了一个交换的节点，且在找到两次以后就可以终止遍历。

这样我们就可以在中序遍历中直接找到被错误交换的两个节点 x 和 y，不用显式建立 nums 数组。

中序遍历的实现有迭代和递归两种等价的写法，在本方法中提供迭代实现的写法。使用迭代实现中序遍历需要手动维护栈。

复杂度分析

时间复杂度：最坏情况下（即待交换节点为二叉搜索树最右侧的叶子节点）我们需要遍历整棵树，时间复杂度为 O(N)，其中 N 为二叉搜索树的节点个数。
空间复杂度：O(H)，其中 H 为二叉搜索树的高度。中序遍历的时候栈的深度取决于二叉搜索树的高度。

代码实现

class Solution {
    public void recoverTree(TreeNode root) {
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        TreeNode x = null, y = null, pred = null;

        while (!stack.isEmpty() || root != null) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (pred != null && root.val < pred.val) {
                y = root;
                if (x == null) {
                    x = pred;
                } else {
                    break;
                }
            }
            pred = root;
            root = root.right;
        }

        swap(x, y);
    }

    public void swap(TreeNode x, TreeNode y) {
        int tmp = x.val;
        x.val = y.val;
        y.val = tmp;
    }
}

提交结果

2020年8月8日更

大家觉得写还可以，可以点赞、收藏、关注一下吧！
也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn

---