leetcode 1305. All Elements in Two Binary Search Trees

Given two binary search trees root1 and root2.

Return a list containing all the integers from both trees sorted in ascending order.

Example 1:

Input: root1 = [2,1,4], root2 = [1,0,3]
Output: [0,1,1,2,3,4]

Example 2:

Input: root1 = [0,-10,10], root2 = [5,1,7,0,2]
Output: [-10,0,0,1,2,5,7,10]

Example 3:

Input: root1 = [], root2 = [5,1,7,0,2]
Output: [0,1,2,5,7]

Example 4:

Input: root1 = [0,-10,10], root2 = []
Output: [-10,0,10]

Example 5:

Input: root1 = [1,null,8], root2 = [8,1]
Output: [1,1,8,8]

Constraints:

• Each tree has at most 5000 nodes.
• Each node's value is between [-10^5, 10^5].

题目大意：给定两颗二叉搜索树，返回一个升序的列表，列表中的元素是两棵树的节点值。

思路：二叉搜索树的中序遍历是非减的序列，因此可以先对两个二叉搜索树进行中序遍历得到两个非减序列，再合并两个序列。

class Solution {
    //中序遍历并保存
    void traverse(TreeNode *root, vector<int> &v){
        if (root == nullptr)
            return;
        traverse(root->left, v);
        v.push_back(root->val);
        traverse(root->right, v);
    }
    //合并两个vector
    vector<int> merge(vector<int> v1, vector<int> v2) {
        vector<int> v(v1.size()+v2.size());
        int i = 0, j = 0, index = 0;
        while (i < v1.size() || j < v2.size()) {
            if ((j == v2.size()) || (i < v1.size() && v1[i] <= v2[j])) 
                v[index++] = v1[i++];
            else
                v[index++] = v2[j++];
        }
        return v;
    }
public:
    vector<int> getAllElements(TreeNode* root1, TreeNode* root2) {
        // ios_base::sync_with_stdio(false);
        ios::sync_with_stdio(false);
        cin.tie(NULL);
        
        vector<int> v1, v2;
        traverse(root1, v1);
        traverse(root2, v2);
        
        return merge(v1, v2);
    }
};

时间复杂度：O(n),

空间复杂度：O(n)

python3:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def dfs(self, root, arr):
        if not root:
            return 
        self.dfs(root.left, arr)
        arr.append(root.val)
        self.dfs(root.right, arr)
            
    def getAllElements(self, root1: TreeNode, root2: TreeNode) -> List[int]:
        # def dfs(root, ans):
        #     if not root:
        #         return
        #     dfs(root.left, ans)
        #     ans.append(root.val)
        #     dfs(root.right, ans)
        
        list1, list2 = [], []
        self.dfs(root1, list1)
        self.dfs(root2, list2)
        list1.extend(list2)
        list1.sort()
        return list1
        # i, j = 0, 0
        # res = []
        # while i < len(list1) or j < len(list2):
        #     if (j >= len(list2) or (i < len(list1) and (list1[i] <= list2[j]))):
        #         res.append(list1[i])
        #         i += 1
        #     else:
        #         res.append(list2[j])
        #         j += 1
        # return res