代码随想录算法训练营 | 二叉树part01

最新推荐文章于 2024-10-27 05:36:49 发布
最新推荐文章于 2024-10-27 05:36:49 发布
阅读量399 收藏 2
点赞数 6
分类专栏： leetcode 文章标签： leetcode 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fern_v/article/details/140472755
版权

前序遍历

144. 二叉树的前序遍历
前序遍历：根结点 —> 左子树 —> 右子树

递归法

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
        if (cur == NULL) return;
        vec.push_back(cur->val);    // 中
        traversal(cur->left, vec);  // 左
        traversal(cur->right, vec); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

迭代法

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if (root == nullptr){
            return {};
        }
        vector<int> res;
        stack<TreeNode*> stk;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode* cur = stk.top(); // 访问栈顶结点
            stk.pop();
            res.push_back(cur->val);
            if(cur->right != nullptr) { // 将右子节点（如果有）压入栈
                stk.push(cur->right);
            }
            if(cur->left != nullptr) { // 将左子节点（如果有）压入栈
                stk.push(cur->left);
            }
        }
        return res;
    }
};

中序遍历

94. 二叉树的中序遍历
中序遍历：左子树—> 根结点 —> 右子树

递归法

class Solution {
public:
    void traversal(TreeNode* cur, vector<int>& vec) {
	    if (cur == NULL) return;
	    traversal(cur->left, vec);  // 左
	    vec.push_back(cur->val);    // 中
	    traversal(cur->right, vec); // 右
	}
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

迭代法

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while(!stk.empty() || root != nullptr){
            while (root != nullptr) {
            	// 将父节点，父节点的左子节点，左子节点的左子节点，... ，直到访问到最底层，依次入栈
                stk.push(root);
                root = root->left; // 先遍历左子树
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val); // 访问当前节点
            root = root->right; // 访问右子树
        }
        return res;
    }
};

后序遍历

145. 二叉树的后序遍历
后序遍历：左子树 —> 右子树 —> 根结点

递归法

class Solution {
public:
	void traversal(TreeNode* cur, vector<int>& vec) {
	    if (cur == NULL) return;
	    traversal(cur->left, vec);  // 左
	    traversal(cur->right, vec); // 右
	    vec.push_back(cur->val);    // 中
	}
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

迭代法

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

层序遍历

层次遍历：只需按层次遍历即可

102.二叉树的层序遍历

102.二叉树的层序遍历

广度优先遍历
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr) {
            return {};
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> temp;
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                temp.push_back(cur->val);
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            res.push_back(temp);
        }
        return res;
    }
};
递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

107.二叉树的层次遍历II

107.二叉树的层次遍历II

将102的结果反转reverse(res.begin(), res.end());；

class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
        if (root == nullptr) {
            return {};
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> temp;
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                temp.push_back(cur->val);
                if(cur->left) {
                    que.push(cur->left);
                }
                if(cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            res.push_back(temp);
        }
        reverse(res.begin(), res.end());
        return res;

    }
};

199.二叉树的右视图

199.二叉树的右视图
找到层序遍历的每一层的最后一个节点

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) {
            return {};
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            TreeNode* cur = nullptr;
            while (size) {
                cur = que.front();
                que.pop();
                if(cur->left) {
                    que.push(cur->left);
                }
                if(cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            res.push_back(cur->val);
        }
        return res;

    }
};

637.二叉树的层平均值

637.二叉树的层平均值

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> res;
        if(root == nullptr) {
            return {};
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            double sum = 0.0;
            double n = size;
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                sum += cur->val; //计算每一层的元素和
                if(cur->left) {
                    que.push(cur->left);
                }
                if(cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            res.push_back(sum / n);
        }
        return res;
    }
};

429.N叉树的层序遍历

429.N叉树的层序遍历
102变形，这里只需要将判断左右子节点，改为判断存储子节点的children数组即可

/*
// 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) {
        if (root == nullptr) {
            return {};
        }
        vector<vector<int>> res;
        queue<Node*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            vector<int> temp;
            while (size) {
                Node* cur = que.front();
                que.pop();
                temp.push_back(cur->val);
                for(int i = 0; i < cur->children.size(); ++i) {
                    // 遍历子节点数组，将子节点push进队列
                    que.push(cur->children[i]);
                }
                --size;
            }
            res.push_back(temp);
        }
        return res;
    }
};

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

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

class Solution{
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> res;
        if(root == nullptr) {
            return {};
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            int maxVal = INT_MIN;
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                maxVal = max(maxVal, cur->val); //更新最大值
                if(cur->left) {
                    que.push(cur->left);
                }
                if(cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            res.push_back(maxVal);
        }
        return res;
    }
};

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

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

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr) {
            return nullptr;
        }
        queue<Node*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            Node* cur = nullptr;
            while (size) {
                cur = que.front();
                que.pop();
                --size;
                if (size > 0) { //链接当前节点所在层的下一个元素（如果存在）
                    cur->next = que.front();
                }
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
                
            }
        }
        return root;
    }
};

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

117.填充每个节点的下一个右侧节点指针II
和116一样的方法，层序遍历，链接当前层的节点

class Solution {
public:
    Node* connect(Node* root) {
        if (root == nullptr) {
            return nullptr;
        }
        queue<Node*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            Node* cur = nullptr;
            while (size) {
                cur = que.front();
                que.pop();
                --size;
                if (size > 0) { //链接当前节点所在层的下一个元素（如果存在）
                    cur->next = que.front();
                }
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
                
            }
        }
        return root;
    }
};

104.二叉树的最大深度

104.二叉树的最大深度

递归法
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        return max(maxDepth(root->left),maxDepth(root->right)) + 1;
    }
};
广度优先遍历

计算二叉树的最大深度即计算二叉树的层数；

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int depth = 0;
        if (root == nullptr) {
            return 0;
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            ++depth; 
        }
        return depth;
    }
};

111.二叉树的最小深度

111.二叉树的最小深度

递归法
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        if(root->left == nullptr) {
            return minDepth(root->right) + 1;
        }
        if(root->right == nullptr) {
            return minDepth(root->left) + 1;
        }
        return min(minDepth(root->left),minDepth(root->right)) + 1;
    }
};
广度优先遍历

叶子节点所在的层数即为它的深度，层序遍历可以保证最先访问到的叶子节点深度最小，即整棵二叉树的最小深度。

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        queue<TreeNode*> que;
        int res = 1; //根节点不为空，深度初始值设为 1
        que.push(root);
        while(!que.empty()) {
            TreeNode* cur = nullptr;
            int size = que.size();
            while (size) {
                cur = que.front();
                que.pop();
                if(cur->left == nullptr && cur->right == nullptr) {
                    return res; //是叶子节点，返回它的深度
                }
                if(cur->left) {
                    que.push(cur->left);
                }
                if(cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            ++res;
        }
        return res;
    }
};
Fern_v
关注
专栏目录
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录算法训练营 | 二叉树part06
Fern_v的博客
07-27 327
遍历二叉树，使用map存储相同节点值和个数；在遍历map，取出可以作为众数的节点值；中序遍历得到的结果是有序的，最小的绝对差只可能出现在相邻元素中；利用二叉搜索树 有序的特性。
代码随想录算法训练营 | 二叉树part05
Fern_v的博客
07-27 251
若它的左子树不空，则左子树上的所有节点的值均小于它的根节点的值；若它的右子树不空，则右子树上的所有节点的值均大于它的根节点的值；它的左右子树也分别是二叉搜索树；利用构造二叉树的思想，前序遍历，构造中间节点，在构造左右子树的vector容器，递归遍历左右子树。给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。给定二叉搜索树（BST）的根节点 root 和一个整数值 val。节点的左子树 只包含 小于 当前节点的数。节点的右子树只包含 大于 当前节点的数。中序遍历的结果是递增的；
代码随想录算法训练营 | 二叉树part02
Fern_v的博客
07-19 377
叶子节点所在的层数即为它的深度，层序遍历可以保证最先访问到的叶子节点深度最小，即整棵二叉树的最小深度。：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）同104计算根节点的最小高度，注意左右子字节一方为空的情况。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。计算二叉树的最大深度即计算二叉树的层数；说明：叶子节点是指没有子节点的节点。根节点的高度就是二叉树的最大深度；
代码随想录算法训练营 | 二叉树part07
Fern_v的博客
07-28 188
但考虑到二叉搜索树有序，判断当前节点值与p,q节点值的大小来判断p,q在那颗子树上，在决定是否遍历子树。
代码随想录算法训练营 | 二叉树part04
Fern_v的博客
07-26 437
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum。判断该树中是否存在 根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum。否则，返回 false。给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。假设二叉树中至少有一个节点。叶子节点 是指没有子节点的节点。叶子节点 是指没有子节点的节点。
代码随想录算法训练营 | 二叉树part03
Fern_v的博客
07-26 235
除了最底层节点没填满外，其余每层节点数都达到最大值，并且最后一层的节点都集中在该层最左边的若干位置；给定一个二叉树，判断它是否是 平衡二叉树（该树所有节点的左右子树的深度相差不超过 1 ）完全二叉树中的节点的左右子树，要么都是满二叉树，要么一颗是满二叉树，一颗是完全二叉树；：遍历二叉树来计算节点个数；代码同二叉树的前序/中序/后序/层序遍历。
代码随想录算法训练营 | 二叉树part08
Fern_v的博客
07-28 223
每一个节点都有一个平衡因子（balance factor），任一节点的平衡因子是-1、0、1（每一个节点的平衡因子 = 右子树高度 - 左子树高度）要每个节点 node 的新值等于原树中大于或等于 node.val 的值之和；根据二叉搜索树的性质要优先遍历右子树，得到节点和；给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡二叉搜索树。会想到判断大于low的右子树，但是具体的处理很懵，脑子里全是删除节点的操作。树的每个左子树和右子树都是AVL树。
代码随想录算法训练营第11天|二叉树part01
zxjiaya的博客
08-18 1314
前中后序遍历，层次遍历，二叉树的详细知识点，还是学的东西很多很杂
代码随想录算法训练营 | 贪心算法 part05
Fern_v的博客
08-14 491
节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。当发现当前数字大于下一个数字时，就把当前数字减。给定一个二叉树，我们在树的节点上安装摄像头。：让叶子节点的父节点安摄像头，所用摄像头最少。计算监控树的所有节点所需的最小摄像头数量。从哪里开始，同时将赋值循环分离出来；，最后两位数同样被再次赋值；，后面的所有数字都设置成。：全部摄像头数量所用最少。
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
在《代码随想录算法PDF》中，作者可能会采用实际的LeetCode题目作为示例，通过解题过程详解每种算法的思想、步骤和优化技巧。这不仅有助于提高编程能力，也能为面试准备提供有力的支持。通过阅读和实践书中的内容，...
代码随想录的pdf版本，需要准备秋招的小伙伴们看过来呀！
02-28
《代码随想录》是一本深受程序员喜爱的书籍，尤其对于即将参加秋季招聘的计算机科学和技术专业的学生们来说，它是提升编程技能和算法能力的重要资源。这本书深入浅出地讲解了编程思维和各种常见算法，旨在帮助读者...
二叉树习题其六【力扣】【算法学习day.13】
2301_79232523的博客
10-25 571
书接上篇文章二叉树习题其四，这篇文章我们将基础拓展###我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
力扣 中等 198.打家劫舍
qq_51352130的博客
10-25 425
法一：动态规划 和716最少花费爬楼梯思路一样链接确定dp数组（dp table）以及下标的含义：dp[i]的定义为到第i号房屋能偷窃到的最高金额为dp[i]确定递推公式：可以有两个途径得到dp[i]，一个是dp[i-1] 一个是dp[i-2]。所以 dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1])dp数组如何初始化：dp[0] = nums[0];确定遍历顺序举例推导dp数组// nums.length是大于等于1的。
leetcode153. Find Minimum in Rotated Sorted Array
weixin_44245188的博客
10-23 187
【代码】leetcode153. Find Minimum in Rotated Sorted Array。
Java | Leetcode Java题解之第514题自由之路
最新发布
m0_57195758的博客
10-27 244
Java | Leetcode Java题解之第514题自由之路
C++ | Leetcode C++题解之第502题IPO
Ddddddd_158的博客
10-23 373
C++ | Leetcode C++题解之第502题IPO
力扣hot100--＞递归/回溯
qq_73450329的博客
10-26 122
/ 定义一个字符串向量 v，存储数字到字母的映射关系，数字 2 到 9 分别对应不同的字母组合。// 递归结束条件：当 path 的长度等于输入的数字串长度时，将当前组合添加到结果中。// 回溯：移除最后一个添加的字母，以便尝试下一个字母组合。// 定义一个字符串向量 result，用于存储所有可能的字母组合结果。// 递归函数 recursive，用于生成所有可能的字母组合。// 定义一个字符串 path，用于记录当前组合的路径。// 根据当前数字获取对应的字母字符串。// 返回所有生成的字母组合。
代码随想录算法训练营
08-23
代码随想录算法训练营是一个优质的学习和讨论平台，提供了丰富的算法训练内容和讨论交流机会。在训练营中，学员们可以通过观看视频讲解来学习算法知识，并根据讲解内容进行刷题练习。此外，训练营还提供了刷题建议，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值