leetcode中的二叉树

 

二叉树的中序遍历

给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

示例 1：
image

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

输入：root = []
输出：[]
示例 3：

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

提示：

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

/**
 * 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<int> ans;
    void dfs(TreeNode *root){
        if(!root){
            return ;
        }
        if(root->left!=nullptr) dfs(root->left);
        ans.push_back(root->val);
        if(root->right!=nullptr) dfs(root->right);
    }
    vector<int> inorderTraversal(TreeNode* root) {
        dfs(root);
        return ans;
    }
};

二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例 1：
image

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

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

提示：

树中节点的数量在[0,104]区间内。
-100 <= Node.val <= 100

/**
 * 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:
    int dfs(TreeNode *root){
        if(root==nullptr){
            return 0;
        }
        return max(dfs(root->right),dfs(root->left))+1;
    }
    int maxDepth(TreeNode* root) {
        return dfs(root);
    }
};

翻转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1：
image
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
示例 2：
image
输入：root = [2,1,3]
输出：[2,3,1]
示例 3：
输入：root = []
输出：[]

提示：
树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100

/**
 * 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:
    void invert(TreeNode* root){
        if(root==nullptr){
            return ;
        }
        invert(root->right);
        invert(root->left);
        swap(root->right,root->left);
    }
    TreeNode* invertTree(TreeNode* root) {
        invert(root);
        return root;
    }
};

对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1：
image
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
image
输入：root = [1,2,2,null,3,null,3]
输出：false

提示：
树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool judge(struct TreeNode *p ,struct TreeNode *q){
    if(p == NULL && q == NULL){
        return true;
    }
    else if(p == NULL || q == NULL){
        return false;
    }
    else if(p -> val != q -> val){
        return false;
    }
    return judge(p -> left,q -> right) && judge(p -> right,q -> left);
}
bool isSymmetric(struct TreeNode* root){
    return judge(root -> left,root -> right);
}

二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的 长度 由它们之间边数表示。

示例 1：
image
输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。
示例 2：

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

提示：
树中节点数目在范围 [1, 104] 内
-100 <= Node.val <= 100

/**
 * 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:
    int ans=0;
    int dfs(TreeNode* root){
        if(root==NULL){
            return 0;
        }
        int L=dfs(root->left);
        int R=dfs(root->right);
        ans=max(L+R+1,ans);
        return max(L,R)+1;
    }
    int diameterOfBinaryTree(TreeNode* root) {
        ans=0;
        dfs(root);
        return ans-1;
    }
};

二叉树的层序遍历

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

示例 1：
image
输入：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.
 * 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) {
        queue<TreeNode*>q;
        q.push(root);
        vector<vector<int>>ans;
        if (!root) {
            return ans;
        }
        while(!q.empty()){
            int c=q.size();
            vector<int>tmp;
            for(int i=0;i<c;i++){
                TreeNode* node=q.front();
                q.pop();
                tmp.push_back(node->val);
                if(node->left){
                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
            }
            ans.push_back(tmp);
        }
        return ans;
    }
};

给你一个二叉树的根节点root，树中每个节点都存放有一个0到9之间的数字。
每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径1−>2−>3表示数字123。
计算从根节点到叶节点生成的所有数字之和。
叶节点是指没有子节点的节点。
示例 1：
image
输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：
image
输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此，数字总和 = 495 + 491 + 40 = 1026

/**
 * 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<int>ans;
    void dfs(TreeNode* root,int t){
        if(root->left==nullptr&&root->right==nullptr){
            ans.push_back(t*10+root->val);
            return ;
        }
        t=t*10+root->val;
        if(root->left) dfs(root->left,t);
        if(root->right) dfs(root->right,t);
    }
    int sumNumbers(TreeNode* root) {
        dfs(root,0);
        int z=0;
        for(int i=0;i<ans.size();i++){
            z+=ans[i];
            //cout<<ans[i]<<endl;
        }      
        return z;
    }
};

/**
 * 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:
    int total_sum = 0;
    void preorder(TreeNode* cur, int sum) {
        if(!cur)
            return;
        sum = sum*10+cur->val;
        if(!cur->left && !cur->right)
            total_sum += sum;
        preorder(cur->left, sum);
        preorder(cur->right, sum);
    }
    int sumNumbers(TreeNode* root) {
        preorder(root, 0);
        return total_sum;
    }
};

二叉搜索树

二叉搜索树有一个特点，就是他的中序遍历是一个递增的序列

二叉搜索树的最小绝对差

https://leetcode.cn/problems/minimum-absolute-difference-in-bst/description/?envType=study-plan-v2&envId=top-interview-150
下面的三个题都是这个一特性
给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

示例 1：
image
输入：root = [4,2,6,1,3]
输出：1

示例 2：
image
输入：root = [1,0,48,null,null,12,49]
输出：1

提示：
树中节点的数目范围是[2,104]
0<=Node.val<=105

/**
 * 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<int>ans;
    void dfs(TreeNode* root){
        if(root==nullptr) return ;
        if(root->left) dfs(root->left);
        ans.push_back(root->val);
        if(root->right) dfs(root->right);
    }
    int getMinimumDifference(TreeNode* root) {
        dfs(root);
        int mi=0x3f3f3f3f;
        for(int i=1;i<ans.size();i++){
            mi=min(mi,ans[i]-ans[i-1]);
        }
        return mi;
    }
};

二叉搜索树中第K小的元素

给定一个二叉搜索树的根节点root，和一个整数k，请你设计一个算法查找其中第k个最小元素（从 1 开始计数）。

示例 1：
输入：root = [3,1,4,null,2], k = 1
输出：1

示例 2：
输入：root = [5,3,6,2,4,null,null,1], k = 3
输出：3

提示：
树中的节点数为 n 。
1<=k<=n<=104
0<=Node.val<=104

/**
 * 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<int>ans;
    void dfs(TreeNode* root){
        if(root==nullptr) return ;
        if(root->left) dfs(root->left);
        ans.push_back(root->val);
        if(root->right) dfs(root->right);
        
    }
    int kthSmallest(TreeNode* root, int k) {
        dfs(root);
        return ans[k-1];
    }
};

验证二叉搜索树

https://leetcode.cn/problems/validate-binary-search-tree/description/?envType=study-plan-v2&envId=top-interview-150
给你一个二叉树的根节点root，判断其是否是一个有效的二叉搜索树。
有效 二叉搜索树定义如下：
节点的左子树只包含 小于 当前节点的数。
节点的右子树只包含 大于 当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：
image
输入：root = [2,1,3]
输出：true

示例 2：
image
输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：

树中节点数目范围在[1,104] 内−231<=Node.val<=231−1

/**
 * 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<int>ans;
    void dfs(TreeNode* root){
        if(root==nullptr) return ;
        if(root->left) dfs(root->left);
        ans.push_back(root->val);
        if(root->right) dfs(root->right);
        
    }
    bool isValidBST(TreeNode* root) {
        dfs(root);
        for(int i=1;i<ans.size();i++){
            if(ans[i]<=ans[i-1]){
                return false;
            }
        }
        return true;
    }
};
posted @   lipu123  阅读(4)  评论(0)  编辑  收藏  举报
（评论功能已被禁用）
相关博文：
·  二叉树层次遍历
·  子树完全二叉树的判断
·  LeetCode题解-02（树、字典树、堆）
·  LeetCodeHot100 二叉树 94. 二叉树的中序遍历 104. 二叉树的最大深度 101. 对称二叉树 543. 二叉树的直径 102. 二叉树的层序遍历 108. 将有序数组转换为二叉搜索树 98. 验证二叉搜索树 230. 二叉搜索树中第K小的元素 199. 二叉树的右视图 114. 二叉树展开为链表
·  【LeetCode】12.二叉树系列——搜索树
阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？
历史上的今天：
2020-12-07 +1和*2
2020-12-07 线段树（区间最大值和最大值的个数）
点击右上角即可分享
微信分享提示
SQL AI 助手