LeetCode-题目详解（二）：树【二叉树】

快来打我* 2023-09-25 13:41 55阅读 0赞

## 102. 二叉树的层序遍历 ##

给你二叉树的根节点 `root` ，返回其节点值的 **层序遍历** 。 （即逐层地，从左到右访问所有节点）。

**示例 1：**

![5aab87e34f11143056bd5fff4b5b3dfe.jpeg][]

输入：root = [3,9,20,null,null,15,7]
    输出：[[3],[9,20],[15,7]]

**示例 2：**

输入：root = [1]
    输出：[[1]]

**示例 3：**

输入：root = []
    输出：[]

**提示：**

*  树中节点数目在范围 `[0, 2000]` 内
 *  `-1000 <= Node.val <= 1000`

--------------------

# Definition for a binary tree node.
    # class TreeNode:
    #     def __init__(self, val=0, left=None, right=None):
    #         self.val = val
    #         self.left = left
    #         self.right = right
    class Solution:
        def levelOrder(self, root: TreeNode) -> List[List[int]]:
            result = []
            # 如果根节点是空，直接结束
            if root is None:
                return result
            
            # 先将根节点放入队列
            queue = [root]
    
            while queue!=[]:
                arr = []    # 存放当前层所有节点
                len_queue = len(queue)  # 当前层所有节点的总数量
                for _ in range(len_queue):  # 循环遍历当前level的所有节点
                    curr = queue.pop(0)
                    arr.append(curr.val)
                    if curr.left is not None:
                        queue.append(curr.left) # 将当前节点的左子节点放入队列
                    if curr.right is not None:
                        queue.append(curr.right)    # 将当前节点的右子节点放入队列
                result.append(arr)  # 将当前层所有节点放入result  
    
            return result

/**
     * 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:
        vector<vector<int>> levelOrder(TreeNode* root) {
            vector <vector <int>> result;
            // 如果根节点是空，直接结束
            if (!root) {
                return result;
            }
    
            queue <TreeNode*> q;
            q.push(root);   // 先将根节点放入队列
            while (!q.empty()) {
                vector<int> curr_level;     // 存放当前层所有节点
                int curr_size = q.size();   // 当前层所有节点的总数量
                for (int i = 0; i < curr_size; ++i) {   // 循环遍历当前level的所有节点
                    TreeNode* node = q.front();
                    q.pop();
                    curr_level.push_back(node->val);
                    if (node->left){
                        q.push(node->left); // 将当前节点的左子节点放入队列
                    }
                    if (node->right){
                        q.push(node->right);    // 将当前节点的右子节点放入队列
                    }
                }
                result.push_back(curr_level);   // 将当前层所有节点放入result     
            }
    
            return result;
        }
    };

/**
     * 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:
        vector<vector<int>> levelOrder(TreeNode* root) {
            vector <vector <int>> result;
            // 如果根节点是空，直接结束
            if (!root) {
                return result;
            }
            result = bfs(root);
            return result;
        }
    
        vector<vector<int>> bfs(TreeNode* node){
            vector<vector<int>> result;
            queue <TreeNode*> q;
            q.push(node);   // 先将根节点放入队列
            while (!q.empty()) {
                vector<int> curr_level;     // 存放当前层所有节点
                int curr_size = q.size();   // 当前层所有节点的总数量
                for (int i = 0; i < curr_size; ++i) {   // 循环遍历当前level的所有节点
                    TreeNode* node = q.front();
                    q.pop();
                    curr_level.push_back(node->val);
                    if (node->left){
                        q.push(node->left); // 将当前节点的左子节点放入队列
                    }
                    if (node->right){
                        q.push(node->right);    // 将当前节点的右子节点放入队列
                    }
                }
                result.push_back(curr_level);   // 将当前层所有节点放入result     
            }
            return result;
        }
    };

## 105. 从前序与中序遍历序列构造二叉树 ##

给定两个整数数组 `preorder` 和 `inorder` ，其中 `preorder` 是二叉树的**先序遍历**， `inorder` 是同一棵树的**中序遍历**，请构造二叉树并返回其根节点。

**示例 1:**

![c074748e10df29e3ea75a3de50f460ef.jpeg][]

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
    输出: [3,9,20,null,null,15,7]

**示例 2:**

输入: preorder = [-1], inorder = [-1]
    输出: [-1]

**提示:**

*  `1 <= preorder.length <= 3000`
 *  `inorder.length == preorder.length`
 *  `-3000 <= preorder[i], inorder[i] <= 3000`
 *  `preorder` 和 `inorder` 均 **无重复** 元素
 *  `inorder` 均出现在 `preorder`
 *  `preorder` **保证** 为二叉树的前序遍历序列
 *  `inorder` **保证** 为二叉树的中序遍历序列

--------------------

### 方法一：递归【O(n)，其中 n 是树中的节点个数】 ###

class Solution:
        def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
            def myBuildTree(preorder_left: int, preorder_right: int, inorder_left: int, inorder_right: int):
                if preorder_left > preorder_right:
                    return None
                
                # 前序遍历中的第一个节点就是根节点
                preorder_root = preorder_left
                # 在中序遍历中定位根节点
                inorder_root = index[preorder[preorder_root]]
                
                # 先把根节点建立出来
                root = TreeNode(preorder[preorder_root])
                # 得到左子树中的节点数目
                size_left_subtree = inorder_root - inorder_left
                # 递归地构造左子树，并连接到根节点
                # 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
                root.left = myBuildTree(preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1)
                # 递归地构造右子树，并连接到根节点
                # 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
                root.right = myBuildTree(preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right)
                return root
            
            n = len(preorder)
            # 构造哈希映射，帮助我们快速定位根节点
            index = {element: i for i, element in enumerate(inorder)}
            return myBuildTree(0, n - 1, 0, n - 1)

### 方法二：递归 ###

二叉树前序遍历的顺序为：

*  先遍历根节点；
 *  随后递归地遍历左子树；
 *  最后递归地遍历右子树。

二叉树中序遍历的顺序为：

*  先递归地遍历左子树；
 *  随后遍历根节点；
 *  最后递归地遍历右子树。

在「递归」地遍历某个子树的过程中，我们也是将这颗子树看成一颗全新的树，按照上述的顺序进行遍历。挖掘「前序遍历」和「中序遍历」的性质，我们就可以得出本题的做法。

对于任意一颗树而言，前序遍历的形式总是

`[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]`

即根节点总是前序遍历中的第一个节点。而中序遍历的形式总是

`[ [左子树的中序遍历结果], 根节点, [右子树的中序遍历结果] ]`

只要我们在中序遍历中**定位**到根节点，那么我们就可以分别知道左子树和右子树中的节点数目。由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有**左右括号**进行定位。

这样以来，我们就知道了左子树的前序遍历和中序遍历结果，以及右子树的前序遍历和中序遍历结果，我们就可以递归地对构造出左子树和右子树，再将这两颗子树接到根节点的左右位置。

# Definition for a binary tree node.
    # class TreeNode:
    #     def __init__(self, val=0, left=None, right=None):
    #         self.val = val
    #         self.left = left
    #         self.right = right
    class Solution:
        def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
            # 递归结束条件
            if not preorder:
                return None
            root_val = preorder[0]
            root_idx = inorder.index(root_val)
            root = TreeNode(root_val)
    
            # 前序遍历中，索引root_idx前的节点为根+左子树，preorder[1: root_idx + 1]为左子树数组
            # 中序遍历中，索引root_idx为根节点，inorder[0: root_idx]为左子树数组
            root.left = self.buildTree(preorder[1:root_idx + 1], inorder[0:root_idx])
    
            # 索引root_idx后的节点为右子树所有节点，preorder[root_idx + 1:]为右子树数组
            # 中序遍历中，索引root_idx为根节点，inorder[root_idx + 1: ]为右子树数组
            root.right = self.buildTree(preorder[root_idx + 1:], inorder[root_idx + 1:])
            return root

/**
     * 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* buildTree(vector<int>& preorder, vector<int>& inorder) {
            // 递归结束条件
            if (!preorder.size()) {
                return nullptr;
            }
            int rootVal = preorder[0];
            int rootIdx = find(inorder.begin(), inorder.end(), rootVal) - inorder.begin();  // 查找vector元素下标
            std::cout << "rootIdx = " << rootIdx << std::endl;
            TreeNode* root = new TreeNode(rootVal);
    
            // 前序遍历中，索引rootIdx前的节点为根+左子树，preorder[1: rootIdx + 1]为左子树数组
            // 中序遍历中，索引rootIdx为根节点，inorder[0: rootIdx]为左子树数组
            vector<int> preorderLeft(preorder.begin() + 1, preorder.begin() + rootIdx + 1); // vector切片【初始化截取】
            vector<int> inorderLeft(inorder.begin(), inorder.begin() + rootIdx);  // vector切片【初始化截取】
            root->left = buildTree(preorderLeft, inorderLeft);
    
            // 索引rootIdx后的节点为右子树所有节点，preorder[rootIdx + 1:]为右子树数组
            // 中序遍历中，索引rootIdx为根节点，inorder[rootIdx + 1: ]为右子树数组
            vector<int> preorderRight(preorder.begin() + rootIdx + 1, preorder.end()); // vector切片【初始化截取】
            vector<int> inorderRight(inorder.begin() + rootIdx + 1, inorder.end()); // vector切片【初始化截取】
            root->right = buildTree(preorderRight, inorderRight);
    
            return root;
        }
    };

### 方法三：迭代【O(n)，其中 n 是树中的节点个数】 ###

class Solution:
        def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
            if not preorder:
                return None
    
            root = TreeNode(preorder[0])
            stack = [root]
            inorderIndex = 0
            for i in range(1, len(preorder)):
                preorderVal = preorder[i]
                node = stack[-1]
                if node.val != inorder[inorderIndex]:
                    node.left = TreeNode(preorderVal)
                    stack.append(node.left)
                else:
                    while stack and stack[-1].val == inorder[inorderIndex]:
                        node = stack.pop()
                        inorderIndex += 1
                    node.right = TreeNode(preorderVal)
                    stack.append(node.right)
    
            return root

[5aab87e34f11143056bd5fff4b5b3dfe.jpeg]: https://img-blog.csdnimg.cn/img_convert/5aab87e34f11143056bd5fff4b5b3dfe.jpeg
[c074748e10df29e3ea75a3de50f460ef.jpeg]: https://img-blog.csdnimg.cn/img_convert/c074748e10df29e3ea75a3de50f460ef.jpeg