leetcode 99. 恢复二叉搜索树

二叉搜索树中的两个节点被错误地交换。请在不改变其结构的情况下，恢复这棵树。

 

题解：

1.二叉搜索树

2.输入交换了两个结点的数值

3.恢复二叉树大小关系

4.只改变结点值，不是改变结点

 

示例 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) 空间复杂度的解法很容易实现。

• 你能想出一个只使用常数空间的解决方案吗？

 

解题思路：

• 因为只交换两个错误结点的数值，所以可以单独设置两个结点记录二叉搜索树被交换的两个结点，然后做一次值的交换

• 搜索二叉树可以中序遍历二叉树，从而只需判断一个左子

• 二叉搜索树结点值的关系满足：左子结点值小于根节点值，右子结点值大于根结点值，在判断左子中不满足左子结点值小于根节点值，即为错误结点，继续找到第二个错误结点

C/C++题解：

/*** 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:

    TreeNode *t1=nullptr, *t2=nullptr, *pre = new TreeNode(INT_MIN);

    void recoverTree(TreeNode* root) {

        inOrder(root);

        //只交换两个结点的数值

        int temp = t1->val;

        t1->val = t2->val;

        t2->val = temp;}

   void inOrder(TreeNode* root){

        if(!root) return;//空结点不检查

        inOrder(root->left);

        //中序遍历，左序遍历找到第一个不符合二叉搜索树不符合大小关系的结点

        if(!t1 && pre->val > root->val) t1 = pre;

        //找到第一个后t1被赋值，再找到第二个不符合大小关系的结点

        if(t1 && pre->val > root->val) t2 = root;

        //只有两个结点

        pre = root;

        inOrder(root->right);}};

Debug结果：

Java题解：

/*** Definition for a binary tree node.

 * public class TreeNode {

 *     int val;

 *     TreeNode left;

 *     TreeNode right;

 *     TreeNode() {}

 *     TreeNode(int val) { this.val = val; }

 *     TreeNode(int val, TreeNode left, TreeNode right) {

 *         this.val = val;

 *         this.left = left;

 *         this.right = right;

 *     }}*/

 

class Solution {

    TreeNode t1=null, t2=null, pre = new TreeNode(Integer.MIN_VALUE);

    public void recoverTree(TreeNode root) {

        inOrder(root);

        //只交换两个结点的数值

        int temp = t1.val;

        t1.val = t2.val;

        t2.val = temp; }

    private void inOrder(TreeNode root){

        if(root == null) return;//空结点不检查

        inOrder(root.left);

        //中序遍历，左序遍历找到第一个不符合二叉搜索树不符合大小关系的结点

        if(t1 == null && pre.val > root.val) t1 = pre;

        //找到第一个后t1被赋值，再找到第二个不符合大小关系的结点

        if(t1 != null && pre.val > root.val) t2 = root;

        //只有两个结点

        pre = root;

        inOrder(root.right);}}

Debug结果：

Python题解：

# Definition for a binary tree node.

# class TreeNode(object):

#     def __init__(self, val=0, left=None, right=None):

#         self.val = val

#         self.left = left

#         self.right = right

class Solution(object):

    def recoverTree(self, root):

        """:type root: TreeNode

        :rtype: None Do not return anything, modify root in-place instead."""

        self.t1 ,self.t2 ,self.pre = None, None, TreeNode(-sys.maxint)

        def inOrder(root):

            if not root: return #空结点不检查

            inOrder(root.left)

            #中序遍历，左序遍历找到第一个不符合二叉搜索树不符合大小关系的结点

            if not self.t1 and self.pre.val > root.val: self.t1 = self.pre

            #找到第一个后t1被赋值，再找到第二个不符合大小关系的结点

            if self.t1 and self.pre.val > root.val: self.t2 = root

            #只有两个结点

            self.pre = root

            inOrder(root.right)

        inOrder(root)

        #只交换两个结点的数值

        temp = self.t1.val

        self.t1.val = self.t2.val

        self.t2.val = temp

Debug结果：

更多题解移步公众号免费获取