LeetCode：二叉树刷题（篇章一）

二叉树LeetCode刷题集合

篇章一

篇章二

篇章三

前言

  本人刷小题小白，参考 labuladong 的算法小抄的刷题指南，开启《二插树》的刷题之路，解题方法并非原创，使用C++和Python进行实现，写个系列博客鞭策自己，并时常复习。

一、二叉树解题框架

  二叉树相关的题目，无外乎两类解法：第一类是遍历一遍二叉树得出答案，第二类是通过分解问题计算出答案，这两类思路分别对应着回溯算法核心框架和动态规划核心框架。 labuladong算法小抄的刷题指南为我们总结了二叉树的解题框架，如下所示：

void traverse(TreeNode* root) {
    if (root == nullptr) {
        return;
    }
    // 前序位置
    traverse(root->left);
    // 中序位置
    traverse(root->right);
    // 后序位置
}

  我们只需要阅读题目要求，确定在前、中、后序哪个位置添加计算代码即可解题，下面给出练手题目。

二、相关题目

1.二叉树的前、中、后遍历

前序LeetCode144
中序LeetCode94
后序LeetCode145

1.1 二叉树的前序遍历

题目要求：

给你二叉树的根节点 root ，返回它节点值的前序遍历。

示例：

输入：root = [1,null,2,3]
输出：[1,2,3]

思路： 结合二叉树的解题框架和前序遍历的原理（跟左右），便可以解出，只需在模板前序的位置打印输出即可，下面给出C++和Python的代码。

C++代码实现：

class Solution {
public:
    void traverse(TreeNode* root, vector<int> &res) {
        if(root == nullptr){
            return;
        }
        res.push_back(root->val);
        traverse(root->left, res);
        traverse(root->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }
};

Python代码实现：

class Solution:
    def traverse(self, root: Optional[TreeNode], res: List[int]) :
        if not root:
            return []
        res.append(root.val)
        self.traverse(root.left, res)
        self.traverse(root.right, res)
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        self.traverse(root, res)
        return res

注意： 中序、后序解题思路一致，下面不在给解题思路，直接上代码。

1.2 二叉树的中序遍历

示例：

输入：root = [1,null,2,3]
输出：[1,3,2]

C++代码实现：

class Solution {
public:
    void inorder(TreeNode* root, vector<int>& res){
        if(!root){
            return;
        }
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        return res;
    }
};

Python代码实现：

class Solution:
    def traverse(self, root: Optional[TreeNode], res):
        if not root:
            return
        self.traverse(root.left, res)
        res.append(root.val)
        self.traverse(root.right, res)
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:       
        res = []
        self.traverse(root, res)
        return res

1.3 二叉树的后序遍历

示例：

输入：root = [1,null,2,3]
输出：[3,2,1]

C++代码实现：

class Solution {
public:
    void traverse(TreeNode* root, vector<int> &res) {
        if(root == nullptr) {
            return;
        }
        traverse(root->left, res);
        traverse(root->right, res);
        res.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        traverse(root, res);
        return res;
    }
};

Python代码实现：

class Solution:
    def traverse(self, root: Optional[TreeNode], res: List[int]):
        if not root:
            return []
        self.traverse(root.left, res)
        self.traverse(root.right, res)
        res.append(root.val)
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        self.traverse(root, res)
        return res

2. 其他入门题目

2.1 LeetCode104. 二叉树的最大深度

LeetCode104. 二叉树的最大深度
题目要求：

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
**说明:**叶子节点是指没有子节点的节点。

示例：

思路： 显然遍历一遍二叉树，用一个外部变量记录每个节点所在的深度，取最大值就可以得到最大深度，结合二叉树遍历框架，下面给出C++和Python的代码。

C++代码实现：

class Solution {
public:
    int res=0;
    int depth=0;

    int maxDepth(TreeNode* root) {
        traverse(root);
        return res;
    }
    void traverse(TreeNode* root) {
        if (root == nullptr) {
            return ;
        }
        depth++;
        res = max(res, depth);
        traverse(root->left);
        traverse(root->right);
        depth--;
    }
};

Python代码实现：

class Solution:
    def maxDepth(self, root):
        if root is None: 
            return 0 
        else: 
            left_height = self.maxDepth(root.left) 
            right_height = self.maxDepth(root.right) 
            return max(left_height, right_height) + 1

2.2 LeetCode543. 二叉树的直径

LeetCode543. 二叉树的直径
题目要求：

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
**说明:**叶子节点是指没有子节点的节点。

示例：

思路： 现在让我求整棵树中的最长「直径」，那直截了当的思路就是遍历整棵树中的每个节点，然后通过每个节点的左右子树的最大深度算出每个节点的「直径」，最后把所有「直径」求个最大值即可 ，思路来源labuladong 的算法小抄。下面给出C++和Python的代码。

C++代码实现：

class Solution {
public:
    int maxDiameter=0;
    int diameterOfBinaryTree(TreeNode* root) {
        maxDepth(root);
        return maxDiameter;
    }
    int maxDepth(TreeNode* root) {
        if(root==nullptr) {
            return 0;
        }
        int leftMax = maxDepth(root->left);
        int rightMax = maxDepth(root->right);
        maxDiameter = max(maxDiameter, leftMax + rightMax);
        return 1 + max(leftMax, rightMax);
    }
};

Python代码实现：
代码来源：LeetCode官方题解

class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.ans = 1
        def depth(root):
            if not root: return 0
            L = depth(root.left)
            R = depth(root.right)
            self.ans = max(self.ans, L + R + 1)
            return max(L, R) + 1
        depth(root)
        return self.ans - 1

总结

  本篇主要是回顾二叉树解题框架，并简单地应用，后续章节会继续进行二叉树的题目练习，目的是加深自己的框架思维，第一篇笔记先到这里，感兴趣的朋友可以期待一下后续的笔记总结。