leetcode-树

最新推荐文章于 2022-01-12 09:17:51 发布
最新推荐文章于 2022-01-12 09:17:51 发布
阅读量128 收藏
点赞数
分类专栏： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33287871/article/details/107571186
版权

目录

111.二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
3
/
9 20
/
15 7
返回它的最小深度 2.

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root)return 0;
        if(root&&!root->left&&!root->right)return 1;
        if(root){
            int left_depth=minDepth(root->left);
            int right_depth=minDepth(root->right);
            cout<<left_depth<<" "<<right_depth<<endl;
            if(left_depth==0&&right_depth!=0)return right_depth+1;
            else if(left_depth!=0&&right_depth==0)return left_depth+1;
            else return min(left_depth,right_depth)+1;
        }
        return 0;
    }
};

671.二叉树中第二小的节点

给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 2 或 0。如果一个节点有两个子节点的话，那么该节点的值等于两个子节点中较小的一个。

给出这样的一个二叉树，你需要输出所有节点中的第二小的值。如果第二小的值不存在的话，输出 -1 。

示例 1:
输入:
2
/
2 5
/
5 7
输出: 5
说明: 最小的值是 2 ，第二小的值是 5 。

示例 2:
输入:
2
/
2 2
输出: -1
说明: 最小的值是 2, 但是不存在第二小的值。

class Solution {
public:
    int findSecondMinimumValue(TreeNode* root) {
        vector<int>layer_value;
        if(!root)return -1;
        if(root&&!root->left&&!root->right)return -1;
        queue<TreeNode*>queueNode;
        queueNode.push(root);
        while(!queueNode.empty()){
            int n=queueNode.size();
            for(int i=0;i<n;++i){
                TreeNode* pNode=queueNode.front();
                queueNode.pop();
                layer_value.push_back(pNode->val);
                if(pNode->left)queueNode.push(pNode->left);
                if(pNode->right)queueNode.push(pNode->right);
            }
        }
        sort(layer_value.begin(),layer_value.end());
        for(int i=1;i<layer_value.size();++i){
            if(layer_value[i]>layer_value[0])return layer_value[i];
        }
        return -1;
    }
};

687.最长同值路径

给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。 这条路径可以经过也可以不经过根节点。
注意：两个节点之间的路径长度由它们之间的边数表示。

示例 1:
输入:

          5
         / \
        4   5
       / \   \
      1   1   5

输出:
2

示例 2:
输入:

          1
         / \
        4   5
       / \   \
      4   4   5

输出:
2

注意: 给定的二叉树不超过10000个结点。 树的高度不超过1000。

class Solution {
public:
    int dfs(TreeNode* root,int& res)
    {
        if(!root)
            return 0;
        int l=0,r=0;
        if(root->left)
        {
            int tmp = dfs(root->left,res);
            if(root->val == root->left->val)
                l = tmp+1;            
        }
        if(root->right)
        {
            int tmp = dfs(root->right,res);
            if(root->val == root->right->val)
                r = tmp+1;               
        }
        res = res>(r+l)?res:r+l;
        return l>r?l:r;
    }
    int longestUnivaluePath(TreeNode* root) {
        int res = 0;
        dfs(root,res);
        return res;
    }
};

112. 路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
说明: 叶子节点是指没有子节点的节点。
示例:
给定如下二叉树，以及目标和 sum = 22，
5
/
4 8
/ /
11 13 4
/ \
7 2 1

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

class Solution 
{
public:
    bool hasPathSum(TreeNode* root, int sum) 
    {
        binaryPaths(root, 0,sum);
        return record;
    }

private:
    bool record = false;
    void binaryPaths(TreeNode* root, int obj_sum,int sum)
    {
        if (!root) { return; }
        obj_sum += root->val;
        if (!root->left && !root->right)
        {
            if (obj_sum == sum) { record = true; }
            else { return; }
        }
        binaryPaths(root->left, obj_sum, sum);
        binaryPaths(root->right, obj_sum, sum);
    }
};

101. 对称二叉树

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/
2 2
/ \ /
3 4 4 3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/
2 2
\
3 3

进阶：
你可以运用递归和迭代两种方法解决这个问题吗？

class Solution {
public:
    bool isSymmetric(TreeNode* root) 
    {
        if (!root) { return true; }
        if (root->left == NULL && root->right == NULL && root != NULL) { return true; }
        queue<TreeNode*> node_queue1;
        queue<TreeNode*> node_queue2;
        node_queue1.push(root->left);
        node_queue2.push(root->right);
        while (!node_queue1.empty() && !node_queue2.empty())
        {
            TreeNode* node1 = node_queue1.front();
            node_queue1.pop();
            TreeNode* node2 = node_queue2.front();
            node_queue2.pop();
            if (!node1 && !node2) { continue; }
            if ((!node1 && node2) || (node1 && !node2) || (node1->val != node2->val)) { return false; }
            node_queue1.push(node1->left);
            node_queue1.push(node1->right);
            node_queue2.push(node2->right);
            node_queue2.push(node2->left);
        }
        return true;
    }
};

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:
给定二叉树 [3,9,20,null,null,15,7]
3
/
9 20
/
15 7

返回 true 。

示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]
1
/
2 2
/
3 3
/
4 4
返回 false 。

class Solution 
{
public:
    int maxDepth(TreeNode* root)
    {
        if (root == NULL) { return 0; }
        else
        {
            int left_height = maxDepth(root->left);
            int right_height = maxDepth(root->right);
            return max(left_height, right_height) + 1;
        }
    }

    bool isBalanced(TreeNode* root) 
    {
        if (!root) { return true; }
        if (root->left == NULL && root->right == NULL && root != NULL) { return true; }
        queue<TreeNode*> node_queue;
        node_queue.push(root);
        while(!node_queue.empty())
        {
            TreeNode* node = node_queue.front();
            node_queue.pop();
            int left_depth = maxDepth(node->left);
            int right_depth = maxDepth(node->right);
            if (abs(left_depth - right_depth) > 1) { return false; }
            if (node->left != NULL) { node_queue.push(node->left); }
            if (node->right != NULL) { node_queue.push(node->right); }
        }
        return true;
    }
};

783. 二叉搜索树节点最小距离

给定一个二叉搜索树的根节点 root，返回树中任意两节点的差的最小值。

示例：
输入: root = [4,2,6,1,3,null,null]
输出: 1
解释:
注意，root是树节点对象(TreeNode object)，而不是数组。

给定的树 [4,2,6,1,3,null,null] 可表示为下图:
4
/
2 6
/ \
1 3

最小的差值是 1, 它是节点1和节点2的差值, 也是节点3和节点2的差值。

注意：
二叉树的大小范围在 2 到 100。
二叉树总是有效的，每个节点的值都是整数，且不重复。
本题与 530：https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同

class Solution {
public:
    int min_num = int(1e9);
    vector<int>result;
    void InorderTravelsal(TreeNode* root)
    {
        if (!root) { return; }
        InorderTravelsal(root->left);
        result.push_back(root->val);
        InorderTravelsal(root->right);
    }
    int minDiffInBST(TreeNode* root) 
    {
        InorderTravelsal(root);
        for (int i = 0; i < result.size(); ++i)
        {
            if (i == result.size() - 1) { continue; }
            else{
                if (abs(result[i + 1] - result[i]) < min_num) {
                    min_num = result[i + 1] - result[i];
                }
            }
        }
        return min_num;
    }
};

404. 左叶子之和

计算给定二叉树的所有左叶子之和。
示例：
3
/
9 20
/
15 7
在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

class Solution 
{
public:
    Solution() { sum = 0; }
    int sumOfLeftLeaves(TreeNode* root) 
    {
        if (!root) { return 0; }
        if (root != NULL && root->left == NULL && root->right == NULL) { return 0; }
        if (root->left && (!root->left->left && !root->left->right))
        {
            sum += root->left->val;
        }
        sumOfLeftLeaves(root->left);
        sumOfLeftLeaves(root->right);
        return sum;
    }
private:
    int sum;
};

面试题 04.04. 检查平衡性

实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]
3
/
9 20
/
15 7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]
1
/
2 2
/
3 3
/
4 4
返回 false 。

class Solution 
{
public:
    int maxDepth(TreeNode* root)
    {
        if (!root) { return 0; }
        int left_maxDepth = maxDepth(root->left);
        int right_maxDepth = maxDepth(root->right);
        return max(left_maxDepth, right_maxDepth) + 1;
    }
    bool isBalanced(TreeNode* root) 
    {
        if (!root) { return true; }
        if (root && !root->left && !root->right) { return true; }
        queue<TreeNode*> node_queue;
        node_queue.push(root);
        while (!node_queue.empty())
        {
            TreeNode* node = node_queue.front();
            node_queue.pop();
            int node_left_maxDepth = maxDepth(node->left);
            int node_right_maxDepth = maxDepth(node->right);
            if (abs(node_left_maxDepth - node_right_maxDepth) > 1) { return false; }
            else
            {
                if (node->left) { node_queue.push(node->left); }
                if (node->right) { node_queue.push(node->right); }
            }
        }
        return true;
    }
};

530. 二叉搜索树的最小绝对差

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。
示例：
输入：

1

3
/
2

输出：
1

解释：
最小绝对差为 1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。

提示：
树中至少有 2 个节点。
本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ 相同

class Solution {
public:
    int min_num = int(1e9);
    vector<int>result;
    void InorderTravelsal(TreeNode* root)
    {
        if (!root) { return; }
        InorderTravelsal(root->left);
        result.push_back(root->val);
        InorderTravelsal(root->right);
    }
    int getMinimumDifference(TreeNode* root) 
    {
        InorderTravelsal(root);
        for (int i = 0; i < result.size(); ++i)
        {
            if (i == result.size() - 1) { continue; }
            else{
                if (abs(result[i + 1] - result[i]) < min_num) {
                    min_num = result[i + 1] - result[i];
                }
            }
        }
        return min_num;
    }
};

剑指 Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1
/
2 2
/ \ /
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1
/
2 2
\
3 3

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

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

限制：

0 <= 节点个数 <= 1000

注意：本题与主站 101 题相同：https://leetcode-cn.com/problems/symmetric-tree/

class Solution {
public:
    bool isSymmetric(TreeNode* root) 
    {
        if (!root) { return true; }
        if (root->left == NULL && root->right == NULL && root != NULL) { return true; }
        queue<TreeNode*> node_queue1;
        queue<TreeNode*> node_queue2;
        node_queue1.push(root->left);
        node_queue2.push(root->right);
        while (!node_queue1.empty() && !node_queue2.empty())
        {
            TreeNode* node1 = node_queue1.front();
            node_queue1.pop();
            TreeNode* node2 = node_queue2.front();
            node_queue2.pop();
            if (!node1 && !node2) { continue; }
            if ((!node1 && node2) || (node1 && !node2) || (node1->val != node2->val)) { return false; }
            node_queue1.push(node1->left);
            node_queue1.push(node1->right);
            node_queue2.push(node2->right);
            node_queue2.push(node2->left);
        }
        return true;
    }
};

100. 相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:
输入: 1 1
/ \ /
2 3 2 3

    [1,2,3],   [1,2,3]

输出: true

示例 2:
输入: 1 1
/
2 2

    [1,2],     [1,null,2]

输出: false

示例 3:
输入: 1 1
/ \ /
2 1 1 2

    [1,2,1],   [1,1,2]

输出: false

class Solution 
{
public:
    bool isSameTree(TreeNode* p, TreeNode* q) 
    {
        if (!p && !q) { return true; }
        if ((!p && q) || (!q && p)) { return false; }
        if (p->val != q->val) { return false; }
        return (isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
    }
};

257. 二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。

示例:
输入:
1
/
2 3

5
输出: [“1->2->5”, “1->3”]
解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3

class Solution 
{
public:
    vector<string> binaryTreePaths(TreeNode* root) 
    {
        binaryTreePath(root, "", true);
        return result;
    }
private:
    vector<string> result;
    void binaryTreePath(TreeNode* root, string str, bool isRoot)
    {
        if (!root) { return; }
        str += (isRoot ? "" : "->") + to_string(root->val);
        if (!root->left && !root->right) 
        {
            result.push_back(str);
            return;
        }
        binaryTreePath(root->left, str, false);
        binaryTreePath(root->right, str, false);
    }
};

235. 二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root)return NULL;
        if(root->val<p->val&&root->val<q->val){
            return lowestCommonAncestor(root->right,p,q);
        }
        if(root->val>p->val&&root->val>q->val){
            return lowestCommonAncestor(root->left,p,q);
        }
        return root;
    }
};

剑指 Offer 32 - II. 从上到下打印二叉树 II

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],

3

/
9 20
/
15 7

返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]

提示：
节点总数 <= 1000

注意：本题与主站 102 题相同：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

class Solution 
{
public:
    vector<vector<int>> levelOrder(TreeNode* root) 
    {
        vector<vector<int>> result;
        vector<int> layer_value;
        if (!root) { return result; }
        if (root && root->left == NULL && root->right == NULL)
        {
            layer_value.push_back(root->val);
            result.push_back(layer_value);
            return result;
        }
        queue<TreeNode*> node_queue;
        node_queue.push(root);
        while (!node_queue.empty())
        {
            int n = node_queue.size();
            for (int i = 0;i < n;i++)
            {
                TreeNode* node = node_queue.front();
                node_queue.pop();
                layer_value.push_back(node->val);
                if (node->left) { node_queue.push(node->left); }
                if (node->right) { node_queue.push(node->right); }
            }
            result.push_back(layer_value);
            for (int i = 0; i < n; i++) { layer_value.pop_back(); }
        }
        return result;
    }
};

面试题68 - II. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

注意：本题与主站 236 题相同：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root)return NULL;
        if(root==p||q==root)return root;
        TreeNode* left=lowestCommonAncestor(root->left,p,q);
        TreeNode* right=lowestCommonAncestor(root->right,p,q);
        if(left&&right)return root;
        if(left&&!right)return left;
        if(right&&!left)return right;
        return NULL;
    }
};

104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。

class Solution {
public:
    int maxDepth(TreeNode* root) 
    {
        if (root == NULL)
        {
            return 0;
        }
        else
        {
            int left_height = maxDepth(root->left);
            int right_height = maxDepth(root->right);
            return max(left_height, right_height) + 1;
        }
    }
};

226. 翻转二叉树

翻转一棵二叉树。
示例：

输入：
4
/
2 7
/ \ /
1 3 6 9

输出：
4
/
7 2
/ \ /
9 6 3 1

class Solution 
{
public:
    TreeNode* invertTree(TreeNode* root) 
    {
        TreeNode* tree_temp = root;
        if (!tree_temp || (tree_temp && !tree_temp->left && !tree_temp->right)) { return tree_temp; }
        if (tree_temp)
        {
            TreeNode* temp = tree_temp->left;
            tree_temp->left = tree_temp->right;
            root->right = temp;
            invertTree(tree_temp->left);
            invertTree(tree_temp->right);
        }
        return tree_temp;
    }
};

938. 二叉搜索树的范围和

给定二叉搜索树的根结点 root，返回 L 和 R（含）之间的所有结点的值的和。
二叉搜索树保证具有唯一的值。

示例 1：
输入：root = [10,5,15,3,7,null,18], L = 7, R = 15
输出：32

示例 2：
输入：root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10
输出：23

提示：
树中的结点数量最多为 10000 个。
最终的答案保证小于 2^31。

class Solution {
public:
    int rangeSumBST(TreeNode* root, int L, int R) {
        int sum = 0;
        int last = -1;
        DFS(root, sum, L, R);
        return sum;       
    }
    void DFS(TreeNode* root, int& sum,const int L, const int R){
        if(root==nullptr) return;
        //左子树
        if(root->left) DFS(root->left,sum,L,R);
        //如果当前结点的值在L-R之间，就相加
        if(root->val>=L && root->val<=R)sum += root->val;
        //右子树
        if(root->right) DFS(root->right,sum,L,R);      
    }
};

剑指 Offer 27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：
4
/
2 7
/ \ /
1 3 6 9
镜像输出：

 4

/
7 2
/ \ /
9 6 3 1

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

class Solution 
{
public:
    TreeNode* mirrorTree(TreeNode* root) 
    {
        TreeNode* tree_tmp;
        tree_tmp = root;
        if (!tree_tmp) { return tree_tmp; }
        if (tree_tmp != NULL && tree_tmp->left == NULL && tree_tmp->right == NULL) { return tree_tmp; }
        if (tree_tmp)
        {
            TreeNode* temp = tree_tmp->left;
            tree_tmp->left = tree_tmp->right;
            tree_tmp->right = temp;
            mirrorTree(tree_tmp->left);
            mirrorTree(tree_tmp->right);
        }
        return tree_tmp;
    }
};

剑指 Offer 34. 二叉树中和为某一值的路径

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
示例:
给定如下二叉树，以及目标和 sum = 22，
5
/
4 8
/ /
11 13 4
/ \ /
7 2 5 1
返回:
[
[5,4,11,2],
[5,8,4,5]
]

提示：
节点总数 <= 10000

注意：本题与主站 113 题相同：https://leetcode-cn.com/problems/path-sum-ii/

class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        if(!root)return {};
        vector<vector<int> >ans;
        vector<int>path;
        int currenSum=0;
        Findpath(root,ans,path,sum,currenSum);
        return ans;
    }
    void Findpath(TreeNode* root,vector<vector<int>>&ans,vector<int>&path,int sum,int& currenSum){
        currenSum+=root->val;
        path.push_back(root->val);
        bool isLeaf=!root->left&&!root->right;
        if(currenSum==sum&&isLeaf) ans.push_back(path);
        if(root->left)Findpath(root->left,ans,path,sum,currenSum);
        if(root->right)Findpath(root->right,ans,path,sum,currenSum);
        currenSum-=root->val;
        path.pop_back();
    }
};

102. 二叉树的层序遍历

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

示例：
二叉树：[3,9,20,null,null,15,7],

3

/
9 20
/
15 7

返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root)return {};
        if(root&&!root->left&&!root->right)return {{root->val}};
        vector<vector<int> >ans;
        vector<int>layer_value;
        queue<TreeNode*>queueNode;
        queueNode.push(root);
        while(!queueNode.empty()){
            int n=queueNode.size();
            for(int i=0;i<n;++i){
                TreeNode* pNode=queueNode.front();
                queueNode.pop();
                layer_value.push_back(pNode->val);\
                if(pNode->left)queueNode.push(pNode->left);
                if(pNode->right)queueNode.push(pNode->right);
            }
            ans.push_back(layer_value);
            for(auto x:layer_value)layer_value.pop_back();
        }
        return ans;
    }
};

剑指 Offer 32 - I. 从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],

3

/
9 20
/
15 7

返回：

[3,9,20,15,7]

class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        if(!root)return {};
        vector<int>ans;
        std::deque<TreeNode*>dequeTreeNode;
        dequeTreeNode.push_back(root);
        ans.push_back(root->val);
        while(dequeTreeNode.size()){
            TreeNode* pNode=dequeTreeNode.front();
            dequeTreeNode.pop_front();
            if(pNode->left){
                dequeTreeNode.push_back(pNode->left);
                ans.push_back(pNode->left->val);
            }
            if(pNode->right){
                dequeTreeNode.push_back(pNode->right);
                ans.push_back(pNode->right->val);
            }
        }
        return ans;
    }
};

144. 二叉树的前序遍历

给定一个二叉树，返回它的 前序 遍历。
示例:
输入: [1,null,2,3]
1

2
/
3
输出: [1,2,3]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

class Solution {
private:
    vector<int>result;
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(root){
            result.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return result;
    }
};

94. 二叉树的中序遍历

给定一个二叉树，返回它的中序 遍历。
示例:
输入: [1,null,2,3]
1

2
/
3
输出: [1,3,2]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

class Solution {
private:
    vector<int>ans;
public:
    vector<int> inorderTraversal(TreeNode* root) {
        if(root){
            inorderTraversal(root->left);
            ans.push_back(root->val);
            inorderTraversal(root->right);
        }
        return ans;
    }
};
yhwang-hub
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
leetcode 树（java）
GreenHand_D的博客
08-03 762
@[TOP](leetcode 树) 前中后序遍历 前序遍历：父节点 -> 左子节点 -> 右子节点 中序遍历：左子节点 -> 父节点 -> 右子节点 后序遍历：左子节点 -> 右子节点 -> 父节点 leetcode144 非递归实现二叉树的前序遍历（Medium） https://leetcode-cn.com/problems/binary-tree-preorder-traversal/ 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3
LeetCode-SQL题目集
HeavenDan的博客
12-23 8194
序号 题号 题目 题解链接 标签 备注 1 176 176. 第二高的薪水 【LeetCode-SQL】176. 第二高的薪水 2 184 184. 部门工资最高的员工 【LeetCode-SQL】184. 部门工资最高的员工 3 4 5 6 7 8 9 10 .........
.NET Core 2.0 初体验
aishuju1的专栏
01-11 3882
(一) .net core 2.0 初体验  1..net core 2.0环境 .net core 下载地址：https://www.microsoft.com/net/core#windowscmd 问题一：提示【Failed to load the dll from [C:\Program Files\dotnet\host\fxr\1.0.1\hostfxr.dll], HRESUL...
乱码
热门推荐
gang901016的专栏
08-06 13万+
被乱码问题困扰了好久，终于解决了！！    为了保证get数据采用UTF8编码，在server.xml中进行了如下设置： <Connector port="8080" maxThreads="150" minSpareThreads="25"  maxSpareThreads="75" enableLookups="false" redirectPort="8443"
下了个蓝屏代码查看工具，就中病毒了。。。什么鬼病毒，竟然还是用的VBS
a538641097的博客
06-03 1万+
扫描所有盘下面的html文件，加入VBS脚本。。。真是奇葩，多少年前的病毒了。。。 http://files.cnblogs.com/files/guangshan/lpdmcxq.rar 这个是病毒链接，下载地址也在里面。 原理是为所有的html文件增加一段脚本： </div><SCRIPT Language=VBScript><!-- ...
neditor本地上传音频一
qq_38529889的博客
12-29 6323
上一篇上传视频 首先需要你查看前两章上传图片与视频，只有对这两章有了一定的了解才能去增加音频上传，我先贴两张成功的图片： 好了，这是修改成功后的一套流程操作，改的东西实在太多，导致我回头找的时候也忘记了自己改动的代码是哪一块（这应该是程序员的通病吧，脑子不够用啊…），就不去一一赘述了，这里直接给代码，完全复制了一套video的代码： 修改后的代码： audio.html &amp;lt;!D...
LeetCode-树
以笔为刀的博客
01-12 151
1.二叉树层序遍历 LeetCode102 力扣https://leetcode-cn.com/problems/binary-tree-level-order-traversal/利用队列的特点: remove()方法:移除掉头部位置的元素并且返回最后位置的元素。 add()方法:队列尾部添加元素。 queue.isEmpty():队列是否为空。 队列先进先出。 public static void levelOrder(BiTreeNode t) { if (t == null)
LeetCode - 树节点
Atwood_Tom的博客
12-09 163
15.树节点 链接:https://leetcode-cn.com/problems/tree-node/ --方法一 select a.id , (case --当atree.p_id is null时说明他没有父节点,所以证明他是这棵树的根节点 when tree.id = (select atree.id FROM tree atree where atree.p_id IS NULL) then 'Root' --当它本身的节点可以在
LeetCode-Go
02-12
其次，LeetCode中的问题类型广泛，涵盖数组、链表、树、图、动态规划、回溯、贪心、排序等经典算法。使用Go语言解题，我们需要掌握数据结构和算法的基本概念，例如： 1. **数组和切片**：Go语言中的数组是固定长度...
leetcode答案-LeetCode-solution:LeetCode-解决方案
06-30
637,一开始想不通在递归里怎么获知旁边的树的节点的值，但是实际上只要有个共享的缓冲区用来读写就好了…… 怎么会这么蠢呢？这题用到了深度优先遍历和广度优先遍历，正好稍微复习下数据结构 2017/11/8 还是637，...
leetcode-java
03-21
leetcode-java 课程1：Java入门与基础算法 Fizz Buzz-> Java语言 字符串和数组 类和对象 参考 界面 数据结构： 链表 栈 阴离子 树 哈希表 算法： 枚举 递归 分治 排序 在IDE里打印输出，并输出分行-> System.out....
《leetcode-solutions》
04-19
《leetcode-solutions》是针对LeetCode平台的一份解决方案集，主要涵盖了各种算法题目及其解答。LeetCode是一个在线的编程挑战平台，它提供了大量的算法题目，旨在帮助程序员提升技能，准备技术面试，以及深入理解...
LeetCode-in-Go-master.zip
04-27
《LeetCode-in-Go-master.zip》是一个包含Go语言实现LeetCode问题解答的资源包，专为程序员提供关于算法和数据结构的学习材料。LeetCode是一个在线平台，它提供了大量的编程题目，帮助开发者提升算法技能和解决实际...
leetcode-数组中数字出现的次数
qq_33287871的博客
07-04 2165
一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。 示例 1： 输入：nums = [4,1,4,6] 输出：[1,6] 或 [6,1] 示例 2： 输入：nums = [1,2,10,4,1,4,3,3] 输出：[2,10] 或 [10,2] 限制： 2 <= nums.length <= 10000 答案很简单：全员进行异或操作即可。考虑异或操作的性质：对于两个操作数的每一位，相同结果为 000
leetcode-字序列中某一位的数字
qq_33287871的博客
06-30 1982
数字以0123456789101112131415…的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。 请写一个函数，求任意第n位对应的数字。 示例 1： 输入：n = 3 输出：3 示例 2： 输入：n = 11 输出：0 限制： 0 <= n < 2^31 我们通过观察，可以发现以下规律： 对于第 n 位对应的数字，我们令这个数字对应的数为 target，然后分三步进行。 首先找到这个数字对应的数是几位数，用 digits 表示；
leetcode-1～n 整数中 1 出现的次数（清晰图解）
qq_33287871的博客
06-30 805
输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。 例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。 示例 1： 输入：n = 12 输出：5 示例 2： 输入：n = 13 输出：6 限制： 1 <= n < 2^31 #include<iostream> #include<string> #include<vector> #include<algorithm> #include<
leetcode-找两个和为目标值且不重叠的子数组
qq_33287871的博客
06-27 734
给你一个整数数组 arr 和一个整数值 target 。 请你在 arr 中找 两个互不重叠的子数组 且它们的和都等于 target 。可能会有多种方案，请你返回满足要求的两个子数组长度和的 最小值 。 请返回满足要求的最小长度和，如果无法找到这样的两个子数组，请返回 -1 。 示例 1： 输入：arr = [3,2,2,4,3], target = 3 输出：2 解释：只有两个子数组和为 3 （[3] 和 [3]）。它们的长度和为 2 。 示例 2： 输入：arr = [7,3,4,7], target
经典动态规划：打家劫舍系列问题
qq_33287871的博客
06-26 685
打家劫舍系列总共有三道，难度设计非常合理，层层递进。第一道是比较标准的动态规划问题，而第二道融入了环形数组的条件，第三道更绝，让盗贼在二叉树上打劫. House Robber | public int rob(int[] nums); 题目很容易理解，而且动态规划的特征很明显。解决动态规划问题就是找「状态」和「选择」。 假想你就是这个专业强盗，从左到右走过这一排房子，在每间房子前都有两种选择：抢或者不抢。 如果你抢了这间房子，那么你肯定不能抢相邻的下一间房子了，只能从下下间房子开始做选择。 如果你不抢这
leetcode-把数组排成最小的数
qq_33287871的博客
07-04 636
输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。 示例 1: 输入: [10,2] 输出: “102” 示例 2: 输入: [3,30,34,5,9] 输出: “3033459” 提示: 0 < nums.length <= 100 说明: 输出结果可能非常大，所以你需要返回一个字符串而不是整数 拼接起来的数字可能会有前导 0，最后结果不需要去掉前导 0 思路描述：首先我们要明白就是 无论这些数字怎么取排列，形成的数字的位数是不变的 那么就是高位的
AcWing暑期LeetCode刷题班-树专题：判断BST
"AcWing夏季LeetCode刷题活动介绍及树相关题目解析" 在AcWing的暑期LeetCode刷题活动中，参与者将面临一系列精选的高频率算法题目，总计80道，涵盖了各种数据结构和算法主题。活动分为8周进行，每周会有10道题目，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yhwang-hub

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值