leetcode二叉树的层次遍历---C++实现

最新推荐文章于 2024-06-18 13:52:22 发布
最新推荐文章于 2024-06-18 13:52:22 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： leetcode 文章标签： leetcode 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Eccentric_Lee/article/details/124057330
版权

102 二叉树的层序遍历

leetcode 102 二叉树的层序遍历

题述：
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例1：
在这里插入图片描述

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

示例 2：

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

示例 3：

输入：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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;

        if(root)
        {
            que.push(root);
        }

        while(!que.empty())
        {
            int size=que.size();
            vector<int> vec;

            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                
                vec.push_back(node->val);
                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
            }
            result.push_back(vec);
        }

        return result;
    }
};

107. 二叉树的层序遍历 II

leetcode 107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：
在这里插入图片描述

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

示例 2：

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

示例 3：

输入：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:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;

        if(root)
        {
            que.push(root);
        }
        while(!que.empty())
        {
            int size=que.size();
            vector<int> vec;

            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                vec.push_back(node->val);

                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
            }
            result.push_back(vec);
        }

        reverse(result.begin(),result.end());
        
        return result;
    }
};

199. 二叉树的右视图

leetcode 199. 二叉树的右视图

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

在这里插入图片描述

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

/**
 * 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> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;

        if(root)
        {
            que.push(root);
        }
        while(!que.empty())
        {
            int size=que.size();

            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();

                if(i==size-1)
                {
                    result.push_back(node->val);
                }

                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
            }
        }

        return result;
    }
};

637. 二叉树的层平均值

leetcode 637. 二叉树的层平均值

题述：

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：

在这里插入图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。

示例 2:

在这里插入图片描述

输入：root = [3,9,20,15,7]
输出：[3.00000,14.50000,11.00000]

C++实现：

/**
 * 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<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;

        if(root)
        {
            que.push(root);
        }
        while(!que.empty())
        {
            int size=que.size();
            double sum=0;

            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();

                sum+=node->val;
                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
            }
            sum=sum/size;
            result.push_back(sum);
        }

        return result;
    }
};

429. N 叉树的层序遍历

leetcode 429. N 叉树的层序遍历

给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

在这里插入图片描述

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

示例 2：

在这里插入图片描述

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        queue<Node*> que;

        if(root)
        {
            que.push(root);
        }

        while(!que.empty())
        {
            int size=que.size();
            vector<int> vec;

            for(int i=0;i<size;i++)
            {
                Node* node=que.front();
                que.pop();
                vec.push_back(node->val);
                for(int i=0;i<node->children.size();i++)
                {
                    if(node->children[i])
                    {
                        que.push(node->children[i]);
                    }
                }
            }

            result.push_back(vec);
        }

        return result;
    }
};

515. 在每个树行中找最大值

leetcode 515. 在每个树行中找最大值

题述：

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例1：

在这里插入图片描述

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

/**
 * 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> largestValues(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root)
        {
            que.push(root);
        }
        while(!que.empty())
        {
            int size=que.size();
            int maxValue=INT_MIN;
            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                maxValue=node->val>maxValue?node->val:maxValue;
                if(node->left)
                {
                    que.push(node->left);
                }

                if(node->right)
                {
                    que.push(node->right);
                }
            }
            result.push_back(maxValue);
        }

        return result;
    }
};

116. 填充每个节点的下一个右侧节点指针

leetcode 116. 填充每个节点的下一个右侧节点指针

题述：
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

示例 1：

在这里插入图片描述

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，‘#’ 标志着每一层的结束。

示例 2:

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

C++代码实现：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root)
        {
            que.push(root);
        }

        while(!que.empty())
        {
            int size=que.size();
            Node* node;
            Node* nodePre;

            for(int i=0;i<size;i++)
            {
                if(i==0)
                {
                    nodePre=que.front();
                    que.pop();
                    node=nodePre;
                }
                else
                {
                    node=que.front();
                    que.pop();
                    nodePre->next=node;
                    nodePre=nodePre->next;
                }
                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
                nodePre->next=NULL;
            }
        }

        return root;
    }
};

117. 填充每个节点的下一个右侧节点指针 II

leetcode 117. 填充每个节点的下一个右侧节点指针 II
给定一个二叉树

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

示例 1：
在这里插入图片描述

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，‘#’ 标志着每一层的结束。

示例 2:

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

C++代码实现如下：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root)
        {
            que.push(root);
        }
        while(!que.empty())
        {
            int size=que.size();
            Node* nodePre;
            Node* node;
            for(int i=0;i<size;i++)
            {
                if(i==0)
                {
                    nodePre=que.front();
                    que.pop();
                    node=nodePre;
                }
                else
                {
                    node=que.front();
                    que.pop();
                    nodePre->next=node;
                    nodePre=nodePre->next;
                }
                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
            }
            nodePre->next=NULL;
        }

        return root;
    }
};

104. 二叉树的最大深度

leetcode 104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。

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

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

在这里插入图片描述

返回它的最大深度 3 。

C++递归：

/**
 * 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 maxDepth(TreeNode* root) {
        //递归
        if(root==NULL)
        {
            return 0;
        }
        int leftMaxDepth=maxDepth(root->left);
        int rightMaxDepth=maxDepth(root->right);

        return leftMaxDepth>rightMaxDepth?leftMaxDepth+1:rightMaxDepth+1;
    }
};

C++非递归：

/**
 * 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 maxDepth(TreeNode* root) {
        if(root==NULL)
        {
            return 0;
        }
        int depth=0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            depth++;
            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
            }
        }

        return depth;
    }
};

111. 二叉树的最小深度

leetcode 111. 二叉树的最小深度

题述：
给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：
在这里插入图片描述

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

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

/**
 * 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 minDepth(TreeNode* root) {
        if(root==NULL)
        {
            return 0;
        }
        if(root->left==NULL && root->right)
        {
            return 1+minDepth(root->right);
        }
        if(root->left && root->right==NULL)
        {
            return 1+minDepth(root->left);
        }

        return 1+min(minDepth(root->left),minDepth(root->right));
    }
};

C++非递归：

/**
 * 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 minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root==NULL)
        {
            return 0;
        }
        que.push(root);
        int depth=0;
        while(!que.empty())
        {
            int size=que.size();
            depth++;

            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();

                if(node->left)
                {
                    que.push(node->left);
                }
                if(node->right)
                {
                    que.push(node->right);
                }
                if(node->left==nullptr && node->right==nullptr)
                {
                    return depth;
                }
            }
        }

        return depth;
    }
};
Eccentric_Lee
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode题库-LeetCode-Code-Set:LeetCode-代码集
06-29
对于二叉树问题，递归遍历（前序、中序、后序）和层次遍历（广度优先搜索）是常见方法。 此外，这个代码集可能还包含了对复杂度分析的注释，比如时间复杂度和空间复杂度，这是评估算法效率的重要指标。通过阅读和...
LeetCode刷题day33
LXYDSF的博客
12-05 591
今日刷题重点—二叉树的层次遍历 102. 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其层序遍历结果： [ [3], [9,20], [15,7] ] 思路分析 层序遍历二叉树,就是从左到右一层一层的去遍历二叉树. 我们需要一个队列来完成,队列先进先出,符合一层一层遍历的逻
二叉树的层次遍历（C++）
weixin_42817333的博客
06-04 6032
102.二叉树的层次遍历 107. 二叉树的层序遍历 II 199. 二叉树的右视图 637. 二叉树的层平均值 429. N叉树的层序遍历 515. 在每个树行中找最大值 116. 填充每个节点的下一个右侧节点指针 117. 填充每个节点的下一个右侧节点指针II 104. 二叉树的最大深度 111. 二叉树的最小深度...
【C++数据结构】二叉树的层序遍历
最新发布
2301_80937868的博客
06-18 705
在线性结构中，每个结点只有一个后继。在有些情况下，一个结点可能有多个后继。树（tree）可以描述这类非线性结构，二叉树（Binary Tree)的递归定义如下：二叉树要么为空，要么由根节点（root）、左子树（left subrree）和右子树（right subtree）组成，而左子树和右子树分别是一颗二叉树。注意，在计算机中，树一般是“倒置”的，即根在上，叶子在下。本文将介绍二叉树的创建及层序遍历。
二叉树的层序遍历（c++）
qq_45519325的博客
02-24 1907
使用层序建树实现二叉树并进行层序遍历
二叉树的深度优先遍历（递归法）
Aaron_Yang
07-13 518
二叉树的结构体定义： 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, Tree
LeetCode #100 相同的树——每日一题
JUST CODE IT
05-08 174
100. 相同的树 给你两棵二叉树的根节点p和q，编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。 示例 1： 输入：p = [1,2,3], q = [1,2,3] 输出：true 示例 2： 输入：p = [1,2], q = [1,null,2] 输出：false 示例 3： 输入：p = [1,2,1], q = [1,1,2] 输出：false 提示： 两棵树上的节点数目都在范围...
LeetCode-Hot-100
03-25
5. **递归与函数**：递归是解决许多算法问题的有效手段，如"Binary Tree Level Order Traversal"使用层次遍历（广度优先搜索）求解。而"Factorial Trailing Zeroes"则通过递归计算阶乘尾部零的个数。 6. **复杂度...
leetcode卡-Leetcode-competitive-coding:C/C++七月Leetcoding挑战的解决方案
07-06
leetcode卡该存储库包含一些具有竞争力的 C 或 C++ 编码解决方案。 此处提供了所有问题的链接，以便更好地理解。 继续编码！...2）二叉树层次遍历二： 3）N天后的牢房： 4）丑二： 5）汉明距离： 6）加一：
leetcode卡-LeetCode-May-Challenge:它由5月份的31道日常问题组成
07-06
在解决LeetCode中的问题时，C++以其高效、直接和面向对象的特点，使得程序员能够更直观地理解和实现算法。此外，C++的STL（Standard Template Library）库提供了丰富的数据结构和算法，如vector、map、set、...
leetcode-Trees-3:树-3
06-29
在LeetCode平台上，"树-3"专题涵盖了与树数据结构相关的编程问题，这些问题主要测试你的逻辑思维、递归理解和算法实现能力。树是一种非线性数据结构，它由节点（或称为顶点）和边构成，每个节点可以有零个或多个子...
二叉树的层序遍历（C++详解）
m0_50655389的博客
01-11 1171
本篇文章使用C++实现了二叉树的层序遍历。
【LeetCode】-- 144. 二叉树的前序遍历
局部变量和全局变量
08-14 549
给你二叉树的根节点root，返回它节点值的前序遍历。
C++——二叉树的层序遍历
一抹阳光的博客
05-11 8278
二叉树的层序遍历：一般基于队列的实现 首先将二叉树的根节点push到队列中。 判断队列不为空就输出队头元素。 判断当前对头节点是否有孩子节点，有则push到队列中。 循环操作，直到队列为空。 代码如下： void FloorPrint_QUEUE(TreeNode* Tree) //层序遍历_队列实现 { queue < TreeNode* > q; if (Tree != NULL) q.push(Tree); //根节点进队列 whil
二叉树的层序遍历（两种方法：迭代+递归）
m0_58681055的博客
07-28 702
借助一个队列，层层遍历，将每一层的节点入队，出队时由于队列先进先出的特点，也会按顺序出队。在出队前，我们先计算队列的长度len，这个长度len就相当于当前层一共有len个节点，所以我们只需要将len个节点出队即可，其他的节点都是下一层的，我们先不去管，所以在循环出队时，结束条件就是len=0。递归也就是我们常说的深度优先遍历，需要设置一个index，用来记录遍历到哪一层了，将节点放入到自己的层中。输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]
二叉树的操作——层序创建、先序、中序、后序、层序遍历
qq_54731568的博客
03-15 706
二叉树的操作——层序创建、先序、中序、后序、层序遍历
【代码随想录】——二叉树层序遍历
m0_51660741的博客
06-10 364
之前介绍的是二叉树的深度优先遍历，接着是二叉树的另外一种遍历方式——层序遍历。层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。102. 二叉树的层序遍历方法一： 方法二：相较于方法一，不同之处在于：for循环将每层填好的path放进res中之后，用path.clear()清除每层的path，就不用每一层申请一个新path。 107. 二叉树的层序遍历 II该题与上题的
leetcode：889. 根据前序和后序遍历构造二叉树
OceanStar的博客
11-22 3722
题目来源 889. 根据前序和后序遍历构造二叉树 题目描述 题目解析 我们知道，在前序遍历的时候，根节点是第一个输出，而在后序遍历中，根节点是最后一个输出； 那么我们可以利用前序遍历来构建Tree，然后通过后续遍历来检验当前树是否构建完毕。 首先我们创建一个节点作为 root，root = TreeNode(pre[preIndex])当 root.val == post[posIndex]时, 意味着我们已经构建完毕了当前子树，如果当前子树没有构建完毕，那么我们就递归的构建左右子树。 具体代码: /**
TreeNode
qq_38494269的博客
07-24 2044
可以使用前序遍历，这样才先优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。回溯法，一定要注意这种通过记录深度来找节点的题目。可以通过层序遍历的方式，获得每层最右边节点，效率更高的是通过后序遍历，保证同层先访问最右边节点。pair存储搜索二叉树的最小值和最大值，-1代表不是二叉搜索树（当树的参数值有-1就不行了）要注意为什么求高度的时候要做是否是平衡二叉树的判断，中序遍历下，输出的二叉搜索树节点的数值是有序序列。//注意不同递归方式,返回值不同。要找深度最大的叶子节点。...
LeetCode Clean Code Handbook - 解析算法面试必刷题
"《LeetCode Clean Code Handbook》是官方提供的刷题指南，主要针对LeetCode上的编程挑战题目，帮助用户提高代码质量和解题效率。这本书涵盖了数组/字符串、数学、链表和二叉树等多个核心编程领域，每个章节都包含多...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值