letcode 分类练习 树的遍历

最新推荐文章于 2024-09-13 16:27:15 发布
最新推荐文章于 2024-09-13 16:27:15 发布
阅读量503 收藏 3
点赞数 4
分类专栏： letcode训练 文章标签： 深度优先 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44062177/article/details/141170464
版权

letcode 分类练习 树的遍历

树的构建

输入数组：[8, 3, 10, 1, 6, null, 14, null, null, 4, 7, 13]

#include <iostream>
#include <vector>
#include <queue>
#include <memory>

using namespace std;

// 定义二叉树节点结构
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

// 根据向量数组构建二叉树
TreeNode* constructBinaryTree(const vector<int*>& nums) {
    if (nums.empty() || !nums[0]) {
        return nullptr;
    }

    // 使用队列进行层序遍历构建树
    queue<TreeNode*> q;
    TreeNode* root = new TreeNode(*nums[0]);
    q.push(root);
    int i = 1;

    while (!q.empty() && i < nums.size()) {
        TreeNode* current = q.front();
        q.pop();

        // 构建左子节点
        if (i < nums.size() && nums[i]) {
            current->left = new TreeNode(*nums[i]);
            q.push(current->left);
        }
        i++;

        // 构建右子节点
        if (i < nums.size() && nums[i]) {
            current->right = new TreeNode(*nums[i]);
            q.push(current->right);
        }
        i++;
    }

    return root;
}

递归遍历

前序遍历

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

中序遍历

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

后序遍历

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

迭代遍历

前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> result;
        if(!root)return result;
        while(root || !s.empty()){
            while(root){
                s.push(root);
                // 这里while一直向左就开始收集
                result.push_back(root->val);
                root = root -> left;
            }
            TreeNode* node = s.top();
            s.pop();
            root = node -> right;
        }
        return result;
    }
};

中序遍历

在这里插入图片描述

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> result;
        if(!root)return result;
        while(root || !s.empty()){
            while(root){
                s.push(root);
                root = root -> left;
            }
            TreeNode* node = s.top();
            s.pop();
            // 弹栈的时候才收集
            result.push_back(node->val);
            root = node -> right;
        }
        return result;
    }
};

后序遍历


后序遍历的迭代方式有区别，就是弹栈后，不是收集，而是判断它的右孩子节点，如果右孩子为空，说明它是叶子节点，这个时候我们收集到result里，并且把这个标记成前驱节点，root再置为空。如果右孩子不为空，我们要像访问左孩子这样继续遍历。

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<TreeNode*> s;
        vector<int> result;
        if(!root) return result;
        TreeNode* prev;
        while(root || !s.empty()){
            while(root){
                s.push(root);
                root = root -> left;
            }
            TreeNode* root = s.top();
            s.pop();
            if(root -> right == nullptr && root != prev){
                result.push_back(root -> val);
                prev = root;
                root = root -> right;
            }else{
                s.push(root);
                root = root -> right;
            }
        }
        return result;
    }
};

层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>q;
        vector<vector<int>> result;
        if(!root)return result;
        q.push(root);
        while(!q.empty()){
            int k = q.size();
            vector<int> tmp;
            for(int i =0;i<k;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);
            }
            result.push_back(tmp);
        }
        return result;

    }
};

层序遍历可以解决的问题

107. 二叉树的层序遍历 II

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        queue<TreeNode*>q;
        vector<vector<int>> result;
        if(!root)return result;
        q.push(root);
        while(!q.empty()){
            int k = q.size();
            vector<int> tmp;
            for(int i =0;i<k;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);
            }
            result.push_back(tmp);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

199. 二叉树的右视图

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*>q;
        vector<int> result;
        if(!root)return result;
        q.push(root);
        while(!q.empty()){
            int k = q.size();
            vector<int> tmp;
            for(int i =0;i<k;i++){
                TreeNode* node = q.front();
                q.pop();
                if(i==k-1) result.push_back(node -> val);
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }
        }
        return result;
    }
};

637. 二叉树的层平均值

在这里插入图片描述

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*>q;
        vector<double> result;
        if(!root)return result;
        q.push(root);
        while(!q.empty()){
            int k = q.size();
            vector<int> tmp;
            double sum = 0;
            for(int i =0;i<k;i++){
                TreeNode* node = q.front();
                sum += node->val;
                q.pop();
                if(i==k-1) result.push_back(sum/k);
                if(node->left)q.push(node->left);
                if(node->right)q.push(node->right);
            }
        }
        return result;
    }
};

429. N 叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> q;
        vector<vector<int>>result;
        if(!root)return result;
        q.push(root);
        while(!q.empty()){
            int k = q.size();
            vector<int>tmp;
            for(int i =0;i<k;i++){
                Node* node = q.front();
                q.pop();
                tmp.push_back(node->val);
                for(auto c : node->children){
                    q.push(c);
                }
            }
            result.push_back(tmp);
        }
        return result;
    }
};

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

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> q;
        vector<int> result;
        if(!root) return result;
        q.push(root);
        while(!q.empty()){
            int k = q.size();
            int maxV = INT_MIN;
            for(int i =0;i<k;i++){
                TreeNode* node = q.front();
                q.pop();
                if(node -> val > maxV)maxV = node -> val;
                if(i == k-1)result.push_back(maxV);
                if(node -> left)q.push(node -> left);
                if(node -> right)q.push(node -> right);
            }
        }
        return result;
    }
};

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

在这里插入图片描述

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

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

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

104.二叉树的最大深度

在这里插入图片描述

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> q;
        if(!root) return 0;
        q.push(root);
        int count = 0;
        while(!q.empty()){
            int k = q.size();
            count++;
            for(int i =0;i<k;i++){
                TreeNode* node = q.front();
                q.pop();
                if(node -> left)q.push(node -> left);
                if(node -> right)q.push(node -> right);
            }
        }
        return count;
    }
};

111.二叉树的最小深度

如果是叶子节点提前返回

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> q;
        if(!root) return 0;
        q.push(root);
        int count = 0;
        while(!q.empty()){
            int k = q.size();
            count++;
            for(int i =0;i<k;i++){
                TreeNode* node = q.front();
                q.pop();
                if(!node -> left && !node -> right)return count;
                if(node -> left)q.push(node -> left);
                if(node -> right)q.push(node -> right);
            }
        }
        return count;
    }
};
计划是动力
关注
专栏目录
leetcode分类-leetcode:练习leetcode题目，提高编程能力
06-30
搜索算法：回溯、递归、深度优先遍历，广度优先遍历，二叉搜索树等 图论：最短路径、最小生成树 动态规划：背包问题、最长子序列 数据结构，主要有如下几种： 数组与链表：单 / 双向链表 栈与队列 哈希表 堆：最大堆...
leetcode分类-Leetcode:练习编码面试问题
06-29
分类这是练习编码面试问题提供了所有解决方案 (150/150) 和数据结构和算法摘要： 动态规划 编辑距离 最大子阵列 最小路径和 独特的路径 独特的路径 II 最长回文子串 交错串 三角形 不同的子序列 解码方式 回文分区二...
LeetCode二叉树系列——144.二叉树的前序遍历
w20001118的博客
07-29 633
关于二叉树的遍历方式，要知道二叉树遍历的基本方式都有哪些。 一些同学用做了很多二叉树的题目了，可能知道前中后序遍历，可能知道层序遍历，但是却没有框架。 我这里把二叉树的几种遍历方式列出来，大家就可以一一串起来了。 二叉树主要有两种遍历方式： 深度优先遍历：先往深走，遇到叶子节点再往回走。 广度优先遍历：一层一层的去遍历。 这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候 还会介绍到。 那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式： 深度优先遍历 前序遍历（递归法，迭代.
【数据结构】Leetcode——遍历树 经典题
Bryce-HJ
09-25 1300
深度优先遍历 前序遍历（递归法，迭代法） 中序遍历（递归法，迭代法） 后序遍历（递归法，迭代法） 广度优先遍历 层次遍历（迭代法） 「这里前中后，其实指的就是中间节点的遍历顺序」，只要大家记住 前中后序指的就是中间节点的位置就可以了。 看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式 前序遍历：中左右 中序遍历：左中右 后序遍历：左右中 前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。 而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出
LeetCode练习九：树（上）——树的定义及遍历、二叉搜索树
qq_56591814的博客
04-05 870
树（Tree）：由n≥0n \ge 0n≥0个节点与节点之间的边组成的有限集合。当n0n = 0n0时称为空树，当n0n > 0n0时称为非空树。其中一个节点被设定为根；每个节点n(除根节点)，都恰连接一条来自节点p的边，p是n的父节点；每个节点从根开始的路径是唯一的。如果每个节点最多有两个子节点，这样的树称为“二叉树”之所以把这种数据结构称为「树」是因为这种数据结构看起来就像是一棵倒挂的树，也就是说数据结构中的「树」是根朝上，而叶朝下的。如下图所示。节点Node。
【数据结构与算法】树介绍及树的遍历(包含LeetCode的三种遍历方式例题)
Cain Xcy的博客
09-09 2138
01、目录 文章目录01、目录02、前言03、树的简介04、树的遍历方式4.1、 前序遍历4.2、 中序遍历4.3、 后续遍历05、三种遍历方式的Code题（来自LeetCode）5.1、 前序遍历（例题）5.2、 中序遍历（例题）5.3、 后续遍历（例题）06、层序遍历（了解内容）6.1、 层序遍历（了解例题）07、小结 02、前言 有一说一，对于数据结构和算法，我从学编程以来，一只都是抱着一份敬畏或者说是畏惧的心情。 因为我实在没有把握学好他，想必很多人都跟我一样，曾经被数据结构与算法的外表吓住，不敢轻
LeetCode：二叉树的遍历方式（13道经典题目）
一起加油~
03-31 3333
二叉树的遍历方式（前序遍历、后序遍历、中序遍历以及层序遍历）以及LeetCode相关题目。
Python刷LeetCode练习：二叉树（前、中、后、层序遍历）
weixin_49755891的博客
10-24 874
二叉树的后序遍历顺序：左右中。没法或者直接进行遍历，换个思维将某个遍历逆序输出后的遍历顺序式左右中这个遍历顺序。在遍历元素的进栈的时候，要先遍历右节点，再遍历左节点。因为 stack 的特性是先入后出，先进 stack 的后进行操作，所以整个遍历的顺序由原本应该的 中左右 变成 中右左。二叉树的中序遍历的遍历顺序：左中右，与前序、后序不同。在图论中层序遍历的遍历形式属于广度搜索，而前序、中、后序遍历属于是深度搜索。递归相较于迭代法 更容易记忆（不一定更容易理解），前序遍历的遍历顺序是 中左右，直接开整。
LeetCode练习——树和图（二叉树的中序遍历）
strivequeen的博客
09-15 98
给定一个二叉树的根节点 root ，返回它的 中序 遍历。 官方解法：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/ 解法一：颜色标记法 （28ms/14.9MB） https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solut.
LeetCode练习——树（二叉树的层序遍历）
strivequeen的博客
08-18 85
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 官方解法：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/er-cha-shu-de-ceng-xu-bian-li-by-leetcode-solution/ 解法： # Definition for a binary tree node. # class TreeNode: # def __init_
leetcode解题模板 —— 树的遍历
_微尘_的博客
12-05 382
1.二叉树前序遍历 模板： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ void order(TreeNode* root) { if (root ==
代码随想录算法训练营第十五天| LeetCode 102. 层次遍历、226.翻转二叉树 、101.对称二叉树
qq_64336203的博客
03-20 615
完成了二叉树的层次遍历和相关练习.
leetcode分类-LeetCode:Leetcode练习和排序
06-30
LeetCode 是一个在线编程挑战平台，它为程序员提供了一个练习和提升编程技能的环境，尤其在准备技术面试时非常有用。这个压缩包“LeetCode-main”似乎包含了一个与LeetCode相关的项目，可能是一个个人编写的代码库...
leetcode分类-Leetcode:力码练习
06-30
通过分类LeetCode的题目，我们可以系统地学习和练习编程技巧，尤其是对于准备面试或者想要提升自身编程能力的开发者来说，这是一个极好的资源。 在这个名为“LeetCode-master”的压缩包中，我们可以期待找到一个...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5152
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 504
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
输出一个三位数
最新发布
2301_77501988的博客
09-13 387
本题要求编写程序，输入一个三位数，输出其个位数字、十位数字和百位数字。
算法知识点——常用输入输出数据的方式
5233的博客
09-12 294
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1185
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
LeetCode刻意练习：恢复二叉搜索树
这个方法的时间复杂度是O(n)，其中n是树中的节点数，因为我们需要遍历整个树。 然而，题目还提出了一个进阶要求，即寻找只使用常数空间的解决方案。在不增加额外空间的情况下，我们可以使用两个变量来保存两个已知...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值