算法训练营 Day 14

最新推荐文章于 2024-08-18 18:02:49 发布
最新推荐文章于 2024-08-18 18:02:49 发布
阅读量154 收藏
点赞数 2
文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NEWSBOYNEWSBOY/article/details/139173110
版权

1、二叉树的最大深度

后序递归法：

class Solution {
public:
    int getdepth(TreeNode* node) { //利用根节点的高度求二叉树的深度
        if (node == nullptr) return 0; //叶子结点高度为1，那叶子结点的子节点(NULL)高度就为0
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
    
    int maxDepth(TreeNode* root) {
        return getdepth(root);
    }
};

精简后的：

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

前序递归法：

class Solution { // 前序递归
public:
    int result; // 两个函数共用一个变量
    void getdepth(TreeNode* node, int depth) {
        result = depth > result ? depth : result; // 中 持续更新result

        if (node->left == nullptr && node->right == nullptr) //结束条件，即遇到叶子结点
            return;

        if (node->left) { // 左
            depth++;    // 深度+1
            getdepth(node->left, depth);
            depth--;    // 回溯，深度-1 （这里为什么要回溯，是因为函数栈弹栈时node从子结点回溯到父结点，相应的深度也要减一）
        }

        if (node->right) { // 右
            depth++;    // 深度+1
            getdepth(node->right, depth);
            depth--;    // 回溯，深度-1
        }
    }

    int maxDepth(TreeNode* root) {
        result = 0; //初始化为0
        if (root == nullptr) return result;
        getdepth(root, 1); //根节点存在的情况，深度最小为1
        return result;
    }
};

精简后的：

class Solution {
public:
    int result;
    void getdepth(TreeNode* node, int depth) {
        result = depth > result ? depth : result; // 中
        if (node->left == nullptr && node->right == nullptr) return;
        if (node->left) { // 左
            getdepth(node->left, depth + 1); //至于这里为什么没有减一，看下图
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
    }
    int maxDepth(TreeNode* root) {
        result = 0;
        if (root == nullptr) return result;
        getdepth(root, 1);
        return result;
    }
};

层序迭代法：

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr) return 0;  
  
        queue<TreeNode *> que;  
        que.push(root); // 将根节点入队  
        int depth = 0; // 当前深度初始化为0  
  
        while (!que.empty()) {  
            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); 
            } 
        }  

        // 当队列为空时，说明已经遍历完所有节点，此时depth即为最大深度  
        return depth;  
    }
};

2、N叉树的最大深度

递归法：

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == nullptr) return 0;
        int depth = 0;
        for (auto child: root->children) {
            depth = max(depth, maxDepth(child));
        }
        return depth + 1;
    }
};

迭代法：

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == nullptr) return 0;  
  
        queue<Node *> que;  
        que.push(root); // 将根节点入队  
        int depth = 0; // 当前深度初始化为0  
  
        while (!que.empty()) {  
            int size = que.size(); // 当前层的节点数  
            depth++; // 遍历到下一层，深度+1  
  
            // 遍历当前层的所有节点  
            while(size--) {  
                Node* node = que.front(); // 取出队首节点  
                que.pop(); // 弹出队首节点  
  
                // 将当前节点的子节点入队   
                for (auto child: node->children) {
                    que.push(child);
                }
            } 
        }  

        // 当队列为空时，说明已经遍历完所有节点，此时depth即为最大深度  
        return depth;
    }
};

3、二叉树的最小深度

后序递归：

class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == nullptr) return 0;
        int leftDepth = getDepth(node->left);           // 左
        int rightDepth = getDepth(node->right);         // 右
        // 中
        // 当一个左子树为空，右不为空，这时并不是最低点
        if (node->left == nullptr && node->right != nullptr) {
            return 1 + rightDepth;
        }
        // 当一个右子树为空，左不为空，这时并不是最低点
        if (node->left != nullptr && node->right == nullptr) {
            return 1 + leftDepth;
        }
        int result = 1 + min(leftDepth, rightDepth);
        return result;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

精简后的：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        if (root->left == nullptr && root->right != nullptr) {
            return 1 + minDepth(root->right);
        }
        if (root->left != nullptr && root->right == nullptr) {
            return 1 + minDepth(root->left);
        }
        return 1 + min(minDepth(root->left), minDepth(root->right));
    }
};

前序递归：

class Solution {
private:
    int result;
    void getdepth(TreeNode* node, int depth) {
        // 函数递归终止条件
        if (node == nullptr) return;
        
        // 中，处理逻辑：判断是不是叶子结点
        if (node->left == nullptr && node->right == nullptr) {
            result = min(result, depth); //更新result值
        }
        if (node->left) { // 左
            getdepth(node->left, depth + 1);
        }
        if (node->right) { // 右
            getdepth(node->right, depth + 1);
        }
    }

public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;
        
        result = INT_MAX;
        getdepth(root, 1);
        return result;
    }
};

层序迭代：

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (root == nullptr) return 0;  
  
        queue<TreeNode *> que;  
        que.push(root); // 将根节点入队  
        int depth = 0; // 当前深度初始化为0  
  
        while (!que.empty()) {  
            int size = que.size(); // 当前层的节点数  
            depth++; // 遍历到下一层，深度+1  
  
            // 遍历当前层的所有节点  
            for (int i = 0; i < size; ++i) {  
                TreeNode* node = que.front(); // 取出队首节点  
                que.pop(); // 弹出队首节点  

                if (node->left == nullptr && node->right ==nullptr) 
                    return depth;
  
                // 将当前节点的子节点入队  
                if (node->left) que.push(node->left);  
                if (node->right) que.push(node->right); 
            } 
        }  

        // 当队列为空时，说明已经遍历完所有节点，此时depth即为最大深度  
        return depth; 
    }
};

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

后序递归：

class Solution {
private:
    int getNodesNum(TreeNode* cur) {
        if (cur == nullptr) return 0;
        int leftNum = getNodesNum(cur->left);      // 左
        int rightNum = getNodesNum(cur->right);    // 右
        int treeNum = leftNum + rightNum + 1;      // 中
        return treeNum;
    }
public:
    int countNodes(TreeNode* root) {
        return getNodesNum(root);
    }
};

精简后

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) return 0;
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

层序迭代：

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != nullptr) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* node = que.front();
                que.pop();
                result++;   // 记录节点数量
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

利用完全二叉树的性质的递归写法：

class Solution {
public:
    int countNodes(TreeNode* root) {
        // 终止条件
        if (root == nullptr) return 0;
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
        while (left) {  // 求左子树深度
            left = left->left;
            leftDepth++;
        }
        while (right) { // 求右子树深度
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }

        // 单层递归逻辑
        int leftTreeNum = countNodes(root->left);       // 左
        int rightTreeNum = countNodes(root->right);     // 右
        int result = leftTreeNum + rightTreeNum + 1;    // 中
        return result;

        //return countNodes(root->left) + countNodes(root->right) + 1; //上面四行可以精简成一行
    }
};
progressiveboy
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
AI基础实战营Day1ppt
02-02
【AI基础实战营Day1】课程主要探讨了计算机视觉领域，并深入介绍了OpenMMLab开源算法体系。计算机视觉是一门研究如何使机器“看”并理解图像和视频内容的科学。这一领域的应用广泛，从日常的微信扫一扫识物功能，到...
训练营风控审批策略day1（2019版） .pdf
07-06
这些规则可以是非常简单的，例如单一的信用评分阈值判断，也可以是极其复杂的，包含多重条件和权重分配的算法。决策引擎的目的是将策略逻辑转化为可执行的决策，并高效地完成审批过程。 3. 策略调优：策略制定是一...
算法训练营day14
czk0411的博客
02-02 366
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。（即逐层地，从左到右访问所有节点）。
算法训练营Day14
momolinshaomo的博客
12-13 1300
Java #二叉树层次遍历 #反转二叉树二叉树的层次遍历很好理解：就是从根结点一层一层地往下遍历（同一层，从左到右）：迭代的方式很好理解：就是依次入队出队。但是判断条件怎么写？最需要解决的就是，要把节点依次入队，那要怎么记录这些节点，防止它们丢失。第一步把根节点先入队，这时候要想让它的左孩子和右孩子入队（如上图），就要在A出队的时候，记录它。关键的就是在一个节点出队的时候，记录该节点，就能找到它的左右孩子。用两个while循环，主要是为了满足结果形式，保证每个结果都保存在一个新的集合中。
寒假算法训练营day14
henhenzhuanyibi的博客
01-27 227
重要在理解其中的变化逻辑。
算法训练营day14,二叉树3
weixin_50253985的博客
01-25 363
/依旧采用后序遍历，但求的是叶子结点的最小深度，因此要去掉root节点情况。//原理与二叉树一样，只不过左右替换为循环判断，找出最大值。//依旧采用后序遍历左右中。//采用后序遍历左右中。
代码随想录算法训练营day14（二叉树）
qq_44195388的博客
06-04 1057
今天学习二叉树。
【LeetCode】二叉树的遍历——代码随想录算法训练营Day14
晴雪月乔的博客
01-23 1316
二叉树的前序遍历，中序遍历和后序遍历
算法训练营day14二叉树
ddzy_12的博客
01-30 280
层序遍历。
代码随想录算法训练营day14 | 二叉树的遍历
weixin_46536635的博客
03-21 359
【代码】代码随想录算法训练营day14 | 二叉树的遍历。
算法训练营day25
wugong_true的博客
04-27 636
在搜索过程中，**我们“剪掉”乐不满足约束条件的搜索分支，**避免许多无意义的尝试，从而提高了搜索效率。当算法在搜索过程中遇到某个状态无法继续前进或无法得到满足条件的解时，它会撤销上一步的选择，退回到之前的状态，并尝试其他可能的选择。回溯算法的本质是深度优先搜索算法，它尝试所有可能的解决方案直到找到满足条件的解。例题2：在二叉树中搜索所有值为 7 的节点，请返回根节点到这些节点的路径，能够找到所有可能的解决方案，并且在合理的剪枝操作下，具有很高的效率。：这类问题的目标是找到满足所有约束条件的解。
算法训练营day43
stmfresher的博客
05-29 393
【代码】算法训练营day43。
飞象工场七日数据刷题营Day11
08-03
处理缺失值的策略可以帮助保持数据的完整性和准确性，估算问题的解决能力反映了数据分析的逻辑思维，而区分监督和无监督学习以及理解数据挖掘的任务则有助于选择合适的算法模型进行建模。相关系数和决定系数的理解则...
数据-行业数据-《1223TikTok训练营1群Day28精华》(2).rar
09-12
《1223TikTok训练营1群Day28精华》(2).rar 这个压缩包文件，从标题和描述中我们可以推测，它包含了关于TikTok平台的特定培训资料，特别是针对数据分析和行业趋势的部分。TikTok作为全球最热门的短视频社交平台之一，...
数据-行业数据-《1224TikTok训练营1群Day29精华》(2).rar
09-12
总的来说，《1224TikTok训练营1群Day29精华》(2).pdf这份文件可能涵盖了TikTok平台的数据分析方法、广告投放策略、算法优化技巧以及合作营销案例，对于想要在TikTok上进行有效推广的行业人士来说，是一份非常实用的...
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 340
基于Pygame和PIL的迷宫生成器
C语言——函数递归
最新发布
2406_83392683的博客
08-18 377
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 787
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 594
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
dijkstra 算法训练营 邓俊辉
10-08
在邓俊辉教授的指导下，他办了多次Dijkstra算法训练营，旨在培养学生对于算法学习的兴趣与能力。Dijkstra算法是一种用于图论中求解最短路径问题的经典算法，具有广泛的应用领域，如路由算法、网络规划和GPS导航系统...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值