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

u013250861

已于 2022-12-04 11:25:50 修改

阅读量203

点赞数

文章标签： leetcode 算法

于 2022-11-30 22:06:12 首次发布

本文链接：https://blog.csdn.net/u013250861/article/details/128123364

版权

102. 二叉树的层序遍历

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

示例 1：

输入：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:

输入: 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