LeetCode 1305. 两棵二叉搜索树中的所有元素题解

1305. 两棵二叉搜索树中的所有元素

题目来源：1305. 两棵二叉搜索树中的所有元素

2022.05.01 每日一题

LeetCode 题解持续更新中GitHub仓库地址 CSDN博客地址

今天的题目就蛮简单的，也很多样。

但是具体思路都是差不多的，

法一：DFS搜索+排序

首先，利用 dfs 得到所有的元素，然后将元素放到一个数组中，使用排序，然后进行返回

class Solution
{
public:
    vector<int> getAllElements(TreeNode* root1, TreeNode* root2)
    {
        // 创建一个列表，用于统计树中的元素
        vector<int> list;
        // 分别对 root1 以及 root2 进行递归，进行求解其中的元素
        dfs(list, root1);
        dfs(list, root2);
        // 对得到的数组进行排序
        sort(list.begin(), list.end());
        // 最终返回结果
        return list;
    }

    /**
     * DFS 函数，通过 递归 将 树 中的元素，全部放入 列表之中
     *
     * @param list 用于存放 树中元素的列表
     * @param root 树的节点
     */
    void dfs(vector<int>& list, TreeNode* root)
    {
        // 如果 当前节点为 空 就结束递归即可
        if (root == nullptr)
            return;
        // 如果当前节点不为空，就将节点的值，放入到 统计列表 之中
        list.push_back(root->val);
        // 然后分别对左子树以及右子树进行递归操作
        dfs(list, root->left);
        dfs(list, root->right);
    }
};

class Solution {
    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
        // 创建一个列表，用于统计树中的元素
        ArrayList<Integer> list = new ArrayList<>();
        // 分别对 root1 以及 root2 进行递归，进行求解其中的元素
        dfs(list, root1);
        dfs(list, root2);
        // 对得到的数组进行排序
        list.sort((i1, i2) -> i1 - i2);
        // 最终返回结果
        return list;
    }

    /**
     * DFS 函数，通过 递归 将 树 中的元素，全部放入 列表之中
     *
     * @param list 用于存放 树中元素的列表
     * @param root 树的节点
     */
    public void dfs(List<Integer> list, TreeNode root) {
        // 如果 当前节点为 空 就结束递归即可
        if (root == null) return;
        // 如果当前节点不为空，就将节点的值，放入到 统计列表 之中
        list.add(root.val);
        // 然后分别对左子树以及右子树进行递归操作
        dfs(list, root.left);
        dfs(list, root.right);
    }
}

这个方法简单粗暴，但是没有完全使用到题目之中所给定的条件

法二：中序遍历+归并

题目之中给定的条件是 一颗 BST(二叉搜索树)，我们知道对于一颗二叉搜索树来说，他的中序遍历 就是一个 已经排序好了的非递减数组，因此，我们可以将 两棵二叉搜索树分别进行中序遍历，得到的两个数组，再将得到的两个数组进行 归并操作。

class Solution {
public:
    vector<int> getAllElements(TreeNode *root1, TreeNode *root2) {
        // 创建两个列表，用于统计两个BST中的元素
        vector<int> list1, list2;
        inorder(list1, root1);
        inorder(list2, root2);
        // 创建一个结果数组，用于统计后来的归并操作
        vector<int> list;
        // 创建两个指针，分别指向两个数组的首位，用于判断已经添加到的地方
        auto p1 = list1.begin(), p2 = list2.begin();
        while (true) {
            // 当 两个指针有一个已经到达数组的末尾，
            // 则 将 另一个数组的剩余元素加入到 结果数组之后
            if (p1 == list1.end()) {
                list.insert(list.end(), p2, list2.end());
                break;
            }
            if (p2 == list2.end()) {
                list.insert(list.end(), p1, list1.end());
                break;
            }// 比较当前两个指针所指位置的值，并将较小的一个值，放入结果数组中，并且更新指针的值
            if (*p1 < *p2)  list.push_back(*p1++);
            else    list.push_back(*p2++);
        }
        // 最后返回结果
        return list;
    }

    /**
     * 平平无奇的中序遍历
     * @param list
     * @param root
     */
    void inorder(vector<int> &list, TreeNode *root) {
        if (root == nullptr)
            return;
        inorder(list, root->left);
        list.push_back(root->val);
        inorder(list, root->right);
    }
};

class Solution {
    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
        // 创建两个列表，用于统计两个BST中的元素
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        inorder(list1, root1);
        inorder(list2, root2);
        // 创建一个结果数组，用于统计后来的归并操作
        ArrayList<Integer> list = new ArrayList<>();
        // 创建两个指针，分别指向两个数组的首位，用于判断已经添加到的地方
        int p1 = 0, p2 = 0;
        while (true) {
            // 当 两个指针有一个已经到达数组的末尾，
            // 则 将 另一个数组的剩余元素加入到 结果数组之后
            if (p1 == list1.size()) {
                list.addAll(list2.subList(p2, list2.size()));
                break;
            }
            if (p2 == list2.size()) {
                list.addAll(list1.subList(p1, list1.size()));
                break;
            }
            // 比较当前两个指针所指位置的值，并将较小的一个值，放入结果数组中，并且更新指针的值
            if (list1.get(p1) < list2.get(p2)) list.add(list1.get(p1++));
            else list.add(list2.get(p2++));
        }
        // 最后返回结果
        return list;
    }

    /**
     * 平平无奇的中序遍历
     * @param list
     * @param root
     */
    public void inorder(List<Integer> list, TreeNode root) {
        if (root == null) return;
        inorder(list, root.left);
        list.add(root.val);
        inorder(list, root.right);
    }
}