找到搜索二叉树中两个错误的节点

题目描述
一棵二叉树原本是搜索二叉树,但是其中有两个节点调换了位置,使得这棵二叉树不再是搜索二叉树,请按升序输出这两个错误节点的值。(每个节点的值各不相同)
示例1
输入 {1,2,3}
返回值 [1,2]

思路:中序遍历二叉搜索树,遍历后正常的顺序应该是升序序列,但是由于两个节点交换了位置。因此两个节点所处的位置是不正确的,也就是相当于将数值大的节点与数值小的节点的位置相互交换,那么就会出现两次逆序的位置。此时,第一次逆序数值大的是错误节点,第二次逆序数值小的是错误的节点。

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 the root
     * @return int整型vector
     */
    vector<int> vec; 
    vector<int> findError(TreeNode* root) {
        // write code here
        vector<int> res(2);
        inorder(root);
        int time=0;
        for(int i=0;i+1<vec.size();i++)
        {
            
            if(vec[i+1]<vec[i])
            {
                time++;
                if(time==1) res[1]=vec[i];
                else if(time==2) 
                {
                    res[0]=vec[i+1];
                    break;
                }  
            }
        }
        return res;
    }
    void inorder(TreeNode* cur)
    {
        if (cur == NULL) return;
        inorder(cur->left);  // 左
        vec.push_back(cur->val);    // 中
        inorder(cur->right); // 右
    }
};
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 这里给出一个用 Python 实现的例子,假设有一个二叉树节点定义如下: ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right ``` 可以使用递归的方式来求解任意两个指定节点之间的路径。具体实现如下: ```python class Solution: def findPath(self, root: TreeNode, node1: TreeNode, node2: TreeNode) -> List[int]: path1 = self.findNode(root, node1, []) path2 = self.findNode(root, node2, []) i, j = 0, 0 while i < len(path1) and j < len(path2) and path1[i] == path2[j]: i += 1 j += 1 return path1[:i] + path2[j-1:][::-1] def findNode(self, root: TreeNode, node: TreeNode, path: List[int]) -> List[int]: if not root: return [] path.append(root.val) if root == node: return path if root.left: leftPath = self.findNode(root.left, node, path) if leftPath: return leftPath if root.right: rightPath = self.findNode(root.right, node, path) if rightPath: return rightPath path.pop() return [] ``` 其,`findNode` 函数用于查找指定节点的路径,`findPath` 函数则是用于找到两个节点的路径并进行合并。在 `findNode` 函数,首先将当前节点的值添加到路径,然后递归遍历左右子树,如果找到了目标节点则直接返回路径,否则将当前节点从路径删除并返回空列表。在 `findPath` 函数,先分别找到两个节点的路径,然后使用双指针法将两个路径合并成一条路径。具体来说,从两个路径的开头开始遍历,直到找到第一个不同的节点,然后将第一个节点到该节点的路径添加到结果,再将第二个节点到该节点的路径逆序添加到结果,即可得到最终的路径。 需要注意的是,上述代码假设了输入的节点是存在于树的,如果节点不存在于树,则会返回空列表。另外,上述代码的时间复杂度是 $O(n)$,其 $n$ 是树节点的个数,因为需要遍历整棵树才能找到目标节点。 ### 回答2: 为了输出树任意两个指定节点之间的路径,可以使用深度优先搜索(DFS)算法来遍历整棵树。 首先,我们需要定义一个树的节点类,该类包括一个值属性和左右子节点属性。然后,我们可以用一个列表来表示整棵树的结构。 接下来,我们可以定义一个递归函数来实现DFS算法。该函数需要输入当前节点、目标节点和当前路径。递归的终止条件有两个:如果当前节点为空,表示已经遍历完整棵树,直接返回;如果当前节点和目标节点值相等,表示已经找到了目标节点,输出当前路径。 在每一次递归,我们需要先将当前节点加入路径列表,然后继续递归遍历当前节点的左右子节点。最后,我们需要将当前节点从路径列表移除,以便进行下一次递归。 最后,我们可以调用该递归函数来找到任意两个指定节点之间的路径。我们需要先从根节点开始遍历整棵树,直到找到第一个目标节点。然后,我们可以继续从第一个目标节点开始遍历整棵树,直到找到第二个目标节点。每遍历到一个目标节点,我们都会输出路径。 以下是一个示例代码: ```python class TreeNode: def __init__(self, value): self.value = value self.left = None self.rRight = None def findPath(root, target, path): if not root: return path.append(root.value) if root.value == target: print(path) findPath(root.left, target, path) findPath(root.right, target, path) path.pop() # 构建一棵树 root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) root.left.right = TreeNode(5) root.right.left = TreeNode(6) root.right.right = TreeNode(7) # 找到1到7的路径 path1 = [] findPath(root, 7, path1) # 找到4到5的路径 path2 = [] findPath(root, 5, path2) ``` 以上代码将输出: [1, 3, 7] [2, 5] ### 回答3: 要输出树任意两个指定节点之间的路径,我们可以使用深度优先搜索算法来解决。下面是一个用Python编写的示例代码: ```python class TreeNode: def __init__(self, value): self.value = value self.left = None self.right = None def find_path(root, node1, node2): path1 = find_node_path(root, node1) # 找到节点1的路径 path2 = find_node_path(root, node2) # 找到节点2的路径 i = 0 while i < len(path1) and i < len(path2) and path1[i].value == path2[i].value: i += 1 common_ancestor = path1[i - 1] # 找到最近的公共祖先 path_from_ancestor_to_node1 = path1[i:] # 从最近的公共祖先到节点1的路径 path_from_ancestor_to_node2 = path2[i:] # 从最近的公共祖先到节点2的路径 path_from_ancestor_to_node1.reverse() # 反转路径,使其从根节点到指定节点 path_from_ancestor_to_node2.reverse() # 反转路径,使其从根节点到指定节点 path = path_from_ancestor_to_node1 + [common_ancestor] + path_from_ancestor_to_node2 # 构造结果路径 return [node.value for node in path] # 返回路径上的节点值列表 def find_node_path(root, node): if not root: return [] if root.value == node.value: return [root] left_path = find_node_path(root.left, node) if left_path: return [root] + left_path right_path = find_node_path(root.right, node) if right_path: return [root] + right_path return [] ``` 以上代码定义了一个`TreeNode`类来表示树的节点。`find_path`函数用于找到任意两个指定节点之间的路径。首先,我们通过调用`find_node_path`函数找到节点1和节点2在树的路径。然后,我们遍历这两条路径,直到找到最近的公共祖先节点。接下来,我们从公共祖先节点开始,分别构造从公共祖先节点节点1和节点2的路径。最后,将这两条路径连接起来,并返回结果路径的节点值列表。 希望以上代码可以帮助你解决问题!

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值