Leetcode算法训练日记 | day16

最新推荐文章于 2024-05-20 18:16:07 发布
最新推荐文章于 2024-05-20 18:16:07 发布
阅读量312 收藏 5
点赞数 5
文章标签： 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74882777/article/details/137408546
版权

一、二叉树的最大深度

1.题目

Leetcode：第 104 题

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

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

示例 1：

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

示例 2：

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

2.解题思路

使用递归法和迭代法遍历二叉树，计算二叉树的最大深度

3.实现代码

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 一、二叉树的最大深度（递归法）
class Solution1 {
public:
    // 定义名为getdepth的辅助函数，用于递归地计算二叉树节点的深度。
    // 函数接受一个参数：指向二叉树节点的指针node。
    int getdepth(TreeNode* node) {
        if (node == NULL) return 0; // 如果传入的节点为空，说明已经到达了叶子节点的下方，返回深度0。
        int leftdepth = getdepth(node->left);// 递归地计算左子树节点的深度。
        int rightdepth = getdepth(node->right); // 递归地计算右子树节点的深度。
        int depth = 1 + max(leftdepth, rightdepth); // 计算当前节点的深度，为左子树和右子树中的最大深度加1（当前节点本身）。
        return depth;// 返回当前节点的深度。
    }

    // 定义名为maxDepth的成员函数，用于返回二叉树的最大深度。
    // 函数接受一个参数：指向二叉树根节点的指针root。
    int maxDepth(TreeNode* root) {
        return  getdepth(root);// 调用getdepth函数计算并返回整棵树的最大深度。
    }
};

// 二、二叉树的最大深度（迭代法）
class Solution2 {
public:
    // 定义名为maxDepth的公共成员函数，用于计算并返回二叉树的最大深度。
    // 函数接受一个参数：指向二叉树根节点的指针root。
    int maxDepth(TreeNode* root) { 
        if (root == NULL) return 0; // 如果传入的根节点为空，说明是一棵空树，返回深度0。
        int depth = 0;// 初始化深度变量为0，用于记录二叉树的最大深度。
        queue<TreeNode*> que; // 创建一个队列que，用于存储待访问的节点。
        que.push(root);// 将根节点入队。
        while (!que.empty()) { // 使用while循环进行遍历，直到队列为空。
            int size = que.size();// 获取队列中的节点数量。
            depth++; // 增加深度计数，每遍历完一层，深度就增加1。
            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;// 返回记录的最大深度。
    }
};


//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    int result1 = s1.maxDepth(root);// 传入二叉树的根节点
    int result2 = s2.maxDepth(root);
    cout << "二叉树的最大深度(递归法)是: " << result1 << endl;
    cout << endl;
    cout << "二叉树的最大深度(迭代法)是: " << result2 << endl;
    cout << endl;
    return 0;
}

二、二叉树的最小深度

1.题目

Leetcode：第 111 题

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

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

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

示例 1：

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

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
2.解题思路

使用递归法和迭代法遍历二叉树，计算二叉树的最小深度

3.实现代码
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 一、二叉树的最小深度（递归法）
class Solution1 {
public:
    // 定义名为getDepth的辅助函数，用于递归地计算二叉树节点的深度。
    // 函数接受一个参数：指向二叉树节点的指针node。
    int getDepth(TreeNode* node) {
       
        if (node == NULL) return 0;// 如果传入的节点为空，说明是一棵空树，返回深度0。
        int leftDepth = getDepth(node->left); // 递归地计算左子树节点的深度。
        int rightDepth = getDepth(node->right);// 递归地计算右子树节点的深度。

        // 如果当前节点的左子树为空，但右子树不为空，则当前节点的深度等于右子树深度加1。
        if (node->left == NULL && node->right != NULL) {
            return 1 + rightDepth;
        }

        // 如果当前节点的右子树为空，但左子树不为空，则当前节点的深度等于左子树深度加1。
        if (node->left != NULL && node->right == NULL) {
            return 1 + leftDepth;
        }

        // 如果当前节点的左右子树都不为空，则当前节点的深度等于左右子树深度的最小值加1。
        // 这里加1是因为深度是从根节点开始计算的，根节点的深度是1。
        int result = 1 + min(leftDepth, rightDepth);
        
        return result;// 返回计算得到的深度结果。
    }
    // 定义名为minDepth的公共成员函数，用于返回二叉树的最小深度。
    // 函数接受一个参数：指向二叉树根节点的指针root。
    int minDepth(TreeNode* root) {
        // 调用getDepth函数计算并返回整棵树的最小深度。
        return getDepth(root);
    }
};

// 二、二叉树的最小深度（迭代法）
class Solution2 {
public:
    // 定义名为minDepth的公共成员函数，用于计算并返回二叉树的最小深度。
    // 函数接受一个参数：指向二叉树根节点的指针root。
    int minDepth(TreeNode* root) {
        
        if (root == NULL) return 0;// 如果根节点为空，说明是一棵空树，返回深度0。
        int depth = 0;// 初始化深度计数变量为0。
        queue<TreeNode*> que;// 创建一个队列que，用于存储待访问的节点。
        que.push(root);// 将根节点入队。
        
        while (!que.empty()) {// 使用while循环进行遍历，直到队列为空。
            int size = que.size(); // 获取队列中的节点数量。
            depth++; // 增加深度计数，每遍历完一层，深度就增加1。
            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 && !node->right) return depth;
            }
        }
        // 如果遍历结束，返回记录的最大深度。
        // 这个返回值在实际情况下不会被执行，因为所有叶子节点都会被提前返回。
        return depth;
    }
};

//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1,2,3,4,5, };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    int result1 = s1.minDepth(root);// 传入二叉树的根节点
    int result2 = s2.minDepth(root);
    cout << "二叉树的最小深度(递归法)是: " << result1 << endl;
    cout << endl;
    cout << "二叉树的最小深度(迭代法)是: " << result2 << endl;
    cout << endl;
    return 0;
}

三、完全二叉树的节点个数

1.题目

Leetcode：第 222 题

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例 1：

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

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1
2.解题思路

使用递归法和迭代法遍历二叉树，计算二叉树的节点个数

3.实现代码
#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// 定义一个结构体TreeNode，用于表示二叉树的节点。
struct TreeNode {
    int val; // 存储节点的值。
    TreeNode* left; // 指向该节点左子树的指针。
    TreeNode* right; // 指向该节点右子树的指针。
    // TreeNode的构造函数，用于创建一个TreeNode实例。
    // 参数x是节点的值，left和right默认为NULL，表示没有左右子节点。
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
// 一、二叉树的节点个数（递归法）
class Solution1 {
public:
    // 定义名为getNodesNum的辅助函数，用于递归地计算二叉树中节点的总数。
    // 函数接受一个参数：指向二叉树节点的指针node。
    int getNodesNum(TreeNode* node) {
        if (node == NULL) return 0;  // 如果传入的节点为空，说明是一棵空树，返回节点总数0。
        int leftNum = getNodesNum(node->left);// 递归地计算左子树中节点的总数。
        int rightNum = getNodesNum(node->right); // 递归地计算右子树中节点的总数。
        int treeNum = 1 + leftNum + rightNum; // 计算当前树的节点总数，为左子树节点数、右子树节点数加上当前节点本身（1）。
        return treeNum;// 返回计算得到的节点总数。
    }

    // 定义名为countNodes的公共成员函数，用于返回二叉树的节点总数。
    // 函数接受一个参数：指向二叉树根节点的指针root。
    int countNodes(TreeNode* root) {
        return getNodesNum(root); // 调用getNodesNum函数计算并返回整棵树的节点总数。
    }
};

// 一、二叉树的节点个数（迭代法）
class Solution2 {
public:
    // 定义名为countNodes的成员函数，用于计算并返回二叉树的节点总数。
    // 函数接受一个参数：指向二叉树根节点的指针root。
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que; // 创建一个队列que，用于存储待访问的节点。
        if (root != NULL) que.push(root); // 如果根节点不为空，则将其入队。
        int result = 0;// 初始化节点计数变量为0。

        while (!que.empty()) {  // 使用while循环进行遍历，直到队列为空。
            TreeNode* node = que.front();// 取出队列前端的节点。
            que.pop();// 将节点从队列中移除。
            result++;// 增加节点计数。
            if (node->left) que.push(node->left); // 如果节点有左子节点，将其入队，以便后续遍历。
            if (node->right) que.push(node->right);// 如果节点有右子节点，将其入队，以便后续遍历。
        }
        return result;// 返回计算得到的节点总数。
    }
};

//测试
// 辅助函数，用于创建一个新的TreeNode
TreeNode* createNode(int value) {
    return new TreeNode(value);
}

// 辅助函数，用于构建二叉树
TreeNode* buildTree(vector<int>& values) {
    if (values.empty()) return NULL;
    TreeNode* root = createNode(values[0]);
    queue<TreeNode*> queueNode;
    queueNode.push(root);
    int i = 1;
    while (!queueNode.empty()) {
        TreeNode* node = queueNode.front();
        queueNode.pop();
        if (i < values.size()) {
            node->left = createNode(values[i++]);
            queueNode.push(node->left);
        }
        if (i < values.size()) {
            node->right = createNode(values[i++]);
            queueNode.push(node->right);
        }
    }
    return root;
}

// 打印容器中的所有元素，用于验证测试结果
void printVector(const vector<int>& vec) {
    for (int value : vec) {
        cout << value << " ";
    }
    cout << endl;
}

// 主函数
int main() {

    vector<int> treeValues = { 1, 2, 3, 4, 5, 6, 7 };// 定义二叉树的层序遍历结果，用于构建二叉树
    TreeNode* root = buildTree(treeValues); // 构建二叉树
    Solution1 s1;// 创建Solution类的实例
    Solution2 s2;
    int result1 = s1.countNodes(root);// 传入二叉树的根节点
    int result2 = s2.countNodes(root);
    cout << "二叉树的节点个数(递归法)是: " << result1 << endl;
    cout << endl;
    cout << "二叉树的节点个数(迭代法)是: " << result2 << endl;
    cout << endl;
    return 0;
}

ps：以上皆是本人在探索算法旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。

山川人海
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
arith:LeetCode算法训练
03-10
arith:LeetCode算法训练
leetcode2sumc-LeetCode:Leetcodealgorithms|Leetcode算法题
06-30
leetcode 2 和 c 力扣算法 # 标题 解决方案 困难 680 , 简单的 678 , 中等的 666 , 中等的 663 中等的 662 中等的 661 简单的 660 难的 657 简单的 653 , 简单的 650 中等的 647 中等的 605 , 简单的 599 , 简单的 ...
Leetcode算法训练日记 | day34
m0_74882777的博客
04-23 1267
Leetcode：第 1005 题 给你一个整数数组nums和一个整数k，按以下方法修改该数组：选择某个下标i并将nums[i]替换为-nums[i]。重复这个过程恰好k次。可以多次选择同一个下标i。以这种方式修改数组后，返回数组可能的最大和。 Leetcode：第 134 题 在一条环路上有n个加油站，其中第i个加油站有汽油gas[i]升。 Leetcode：第 135 题 n个孩子站成一排。给你一个整数数组ratings表示每个孩子的评分。
Leetcode算法训练日记 | day31
m0_74882777的博客
04-20 990
Leetcode：第 455 题 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。 Leetcode：第 376 题 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。
Leetcode算法训练日记 | day30
m0_74882777的博客
04-19 674
Leetcode：第 332 题 给你一份航线列表tickets，其中tickets[i] = [fromi, toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。 Leetcode：第 51 题 按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 n皇后问题研究的是如何将n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数n，返回所有不同的n皇后问题的解决方案。
Leetcode算法训练日记 | day36
m0_74882777的博客
04-25 660
Leetcode：第 435 题 给定一个区间的集合intervals，其中intervals[i] = [starti, endi]。返回需要移除区间的最小数量，使剩余区间互不重叠。 Leetcode：第 763 题 给你一个字符串s。我们要把这个字符串划分为尽可能多的片段，同一字母最多出现在一个片段中。 Leetcode：第 56 题 以数组intervals表示若干个区间的集合，其中单个区间为intervals[i] = [starti, endi]。
Leetcode算法训练日记 | day29
m0_74882777的博客
04-18 964
Leetcode：第 491 题 给你一个整数数组nums，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。 Leetcode：第 46题 给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。 Leetcode：第 47题 给定一个可包含重复数字的序列nums，按任意顺序返回所有不重复的全排列。
Leetcode算法训练日记 | day18
m0_74882777的博客
04-06 766
Leetcode：第 513 题 给定一个二叉树的根节点root，请找出该二叉树的最底层最左边节点的值。假设二叉树中至少有一个节点。 Leetcode：第 112题 给你二叉树的根节点root和一个表示目标和的整数targetSum。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和targetSum。如果存在，返回true；否则，返回false。叶子节点是指没有子节点的节点。
Leetcode算法训练日记 | day32
m0_74882777的博客
04-20 947
Leetcode：第 53题 给你一个整数数组nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。 Leetcode：第 122 题 给你一个整数数组prices，其中prices[i]表示某支股票第i天的价格。 在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。 返回你能获得的最大利润。
Leetcode算法训练日记 | day10
m0_74882777的博客
03-29 994
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）。 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。
Leetcode算法训练日记 | day35
m0_74882777的博客
04-24 698
Leetcode：第 860 题 在柠檬水摊上，每一杯柠檬水的售价为5美元。顾客排队购买你的产品，（按账单bills支付的顺序）一次购买一杯。 Leetcode：第 406 题 假设有打乱顺序的一群人站成一个队列，数组people表示队列中一些人的属性（不一定按顺序）。每个people[i] = [hi, ki]表示第i个人的身高为hi，前面正好有ki个身高大于或等于hi的人。 Leetcode：第 452 题 有一些球形气球贴在一堵用 XY 平面表示的墙面上。
LeetCode算法数据结构专训笔记,
03-26
LeetCode算法数据结构专训笔记, 刷完之后对于自生的算法能力有着绝对的提升, 而且好处，题目分类清晰，专项专训, 题目存在套路，不会出现说刷不下去的问题存在
LeetCode 算法
09-07
本资源收集于互联网， 为LeetCode 算法习题和答案，供大家共同学习和进步
leetcode初级算法.zip
10-23
leetcode初级算法代码C++完整版，里面是我认为最适合于新手解题的代码，包含详细的注释，还有个人感悟和总结，适合于想要入门的新手。
【力扣一轮】数组-旋转矩阵
诚。
05-14 234
这时需要用到循环不变量，它是一个循环，每次处理的时候需要处理的方式是一样的，而不是有着条件的限制。2.对于进入再次循环的条件，没有考虑到，具体体现在for循环中用到了n，而n是作为退出条件改变了。对于这道题，循环不变量就是边元素的处理，只处理当前边的起始元素，不处理当前边的末尾元素。3.对于奇数矩阵和偶数矩阵的处理，没有考虑到中间值。对于奇数矩阵还是偶数矩阵，只是多加一个元素指定值。以上4点，导致看了4次卡尔老师的代码，才完成。1.对于循环退出条件，没有考虑到，需要设置。调试之后，发现自己欠缺考虑有几点。
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 781
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
day09
2202_76101487的博客
05-17 723
正值少年的日常打卡！！！
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
最新发布
未来就在脚下。
05-20 494
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
如何快速掌握LeetCode算法题
06-13
以下是一些快速掌握LeetCode算法题的建议，供您参考： 1. 学习数据结构和算法基础知识：LeetCode算法题需要掌握一些数据结构和算法基础知识，例如链表、树、堆、排序、查找、动态规划等。可以通过参考经典算法书籍...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值