递归-深度优先遍历-99. 恢复二叉搜索树

最新推荐文章于 2025-11-04 20:41:43 发布

原创最新推荐文章于 2025-11-04 20:41:43 发布 · 206 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#深度优先 #算法 #leetcode

数据结构与算法同时被 2 个专栏收录

59 篇文章

订阅专栏

java

45 篇文章

订阅专栏

本文介绍了一种通过中序遍历找到并交换二叉搜索树中两个错误节点的方法，确保树的有效性。针对不同错误节点位置的情况进行了详细讨论。

Leetcode 恢复二叉搜索树
在这里插入图片描述

分析：
首先题目寿命恰好存在两个错误节点；因为二叉搜索树的中序遍历一定是有序的，那么原有问题就转化为该有序的数组，一定存在两个点是错误的，我们只需要找出这两个点，并且交换对应的值就可以解决这个问题。

那么我们要如何找到这两个错误位置呢？它会存在如下三种情况：

情况1：这两个错误的位置在左子树
情况2：这两个错误的位置在右子树
情况3：这两个错误的位置横叉在两边

根据这种方式：我们按照如下的思路进行题解编码：
（1）首先按照递归深度优先遍历，将二叉树转为List数组
（2）找出根节点的索引位置
（3）声明LLeft,LRight,RLeft,RRight，分别代表左子树的待交换的值，以及右子树待交换的值。根据根节点索引计算出这四个值出来
（4）针对这4个值得逻辑判断：

if (LLeft != -1 && RRight != -1) {
                swap(LLeft,RRight, nodesList);
            } else if (LLeft != -1 && RRight == -1) {
                swap(LLeft,LRight,nodesList);
            } else if (RRight != -1 && LLeft == -1) {
                swap(RLeft,RRight, nodesList);
            }

那么最终的代码实现如下：

/**
 * 题目Id：99
 * 题目：恢复二叉搜索树
 * 内容: //给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树 。
 * //
 * //
 * //
 * // 示例 1：
 * //
 * //
 * //输入：root = [1,3,null,null,2]
 * //输出：[3,1,null,null,2]
 * //解释：3 不能是 1 的左孩子，因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。
 * //
 * //
 * // 示例 2：
 * //
 * //
 * //输入：root = [3,1,4,null,null,2]
 * //输出：[2,1,4,null,null,3]
 * //解释：2 不能在 3 的右子树中，因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。
 * //
 * //
 * //
 * // 提示：
 * //
 * //
 * // 树上节点的数目在范围 [2, 1000] 内
 * // -2³¹ <= Node.val <= 2³¹ - 1
 * //
 * //
 * //
 * //
 * // 进阶：使用 O(n) 空间复杂度的解法很容易实现。你能想出一个只使用 O(1) 空间的解决方案吗？
 * // Related Topics 树 深度优先搜索 二叉搜索树 二叉树 👍 771 👎 0
 * <p>
 * 日期：2022-08-28 21:54:42
 */
//给你二叉搜索树的根节点 root ，该树中的 恰好 两个节点的值被错误地交换。请在不改变其结构的情况下，恢复这棵树 。
//
//
//
// 示例 1：
//
//
//输入：root = [1,3,null,null,2]
//输出：[3,1,null,null,2]
//解释：3 不能是 1 的左孩子，因为 3 > 1 。交换 1 和 3 使二叉搜索树有效。
//
//
// 示例 2：
//
//
//输入：root = [3,1,4,null,null,2]
//输出：[2,1,4,null,null,3]
//解释：2 不能在 3 的右子树中，因为 2 < 3 。交换 2 和 3 使二叉搜索树有效。
//
//
//
// 提示：
//
//
// 树上节点的数目在范围 [2, 1000] 内
// -2³¹ <= Node.val <= 2³¹ - 1
//
//
//
//
// 进阶：使用 O(n) 空间复杂度的解法很容易实现。你能想出一个只使用 O(1) 空间的解决方案吗？
// Related Topics 树 深度优先搜索 二叉搜索树 二叉树 👍 771 👎 0

package leetcode.editor.cn;

import common.TreeNode;

import java.util.ArrayList;
import java.util.List;

public class P99RecoverBinarySearchTreeV2 {
    public static void main(String[] args) {
        Solution solution = new P99RecoverBinarySearchTreeV2().new Solution();
        System.out.println("Hello world");
    }
    //leetcode submit region begin(Prohibit modification and deletion)

    /**
     * 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 {
        public void recoverTree(TreeNode root) {
            List<TreeNode> nodesList = new ArrayList<>();
            traversalNodeTree(root, nodesList);
            int rootIndex = -1;
            for (int i = 0; i < nodesList.size(); i++) {
                if (nodesList.get(i).val == root.val) {
                    rootIndex = i;
                    break;
                }
            }
            int LLeft = -1;
            int LRight = rootIndex;
            for (int i = 0; i < rootIndex; i++) {
                if (nodesList.get(i).val > nodesList.get(i + 1).val) {
                    LLeft = i;
                    break;
                }
            }
            for (int j = rootIndex; j >= 1; j--) {
                if (nodesList.get(j).val < nodesList.get(j - 1).val) {
                    LRight = j;
                    break;
                }
            }
            int RLeft = rootIndex;
            int RRight = -1;
            for (int i = rootIndex; i < nodesList.size() - 1; i++) {
                if (nodesList.get(i).val > nodesList.get(i + 1).val) {
                    RLeft = i;
                    break;
                }
            }
            for (int j = nodesList.size() - 1; j >= rootIndex + 1; j--) {
                if (nodesList.get(j).val < nodesList.get(j - 1).val) {
                    RRight = j;
                    break;
                }
            }
            if (LLeft != -1 && RRight != -1) {
                swap(LLeft,RRight, nodesList);
            } else if (LLeft != -1 && RRight == -1) {
                swap(LLeft,LRight,nodesList);
            } else if (RRight != -1 && LLeft == -1) {
                swap(RLeft,RRight, nodesList);
            }
        }

        private void swap(int leftNotValidIndex, int rightNotValidIndex, List<TreeNode> nodesList) {
            int temp = nodesList.get(leftNotValidIndex).val;
            nodesList.get(leftNotValidIndex).val = nodesList.get(rightNotValidIndex).val;
            nodesList.get(rightNotValidIndex).val = temp;
        }


        private void traversalNodeTree(TreeNode root, List<TreeNode> nodesList) {
            if (root == null) {
                return;
            }
            if (root.left != null) {
                traversalNodeTree(root.left, nodesList);
            }
            nodesList.add(root);

            if (root.right != null) {
                traversalNodeTree(root.right, nodesList);
            }
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}