LeetCode：经典题之144、94、145、102题解及延伸｜二叉树的遍历｜前中后层序遍历｜Morris算法

已于 2024-07-14 17:06:18 修改
阅读量1.3k 收藏 15
点赞数 41
分类专栏： LeetCode 文章标签： 算法 leetcode 学习 C++
于 2024-06-29 22:57:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64906980/article/details/140071487
版权

系列目录

88.合并两个有序数组
52.螺旋数组
567.字符串的排列
643.子数组最大平均数
150.逆波兰表达式
61.旋转链表
160.相交链表
83.删除排序链表中的重复元素
389.找不同
1491.去掉最低工资和最高工资后的工资平均值
896.单调序列
206.反转链表
92.反转链表II
141.环形链表
142.环型链表
21.合并两个有序列表
24.两辆交换链表中的节点
876.链表的中间节点
143. 重排链表
2.两数相加
445.两数相加II

目录

前言

方法都是类似的～
递归是隐式调用栈(递归栈，无需手动实现)，迭代是显式调用栈


Morris遍历

简介

Morris遍历是一种高效的二叉树遍历算法，其显著特点是能在不使用额外的栈或队列，而是利用树大量的空闲指针完成遍历，空间复杂度为O(1)

1. 遍历思路

1、开始时 cur = root，cur为空时过程停止

2、若cur无左树，cur向右移动

3、若cur有左树，找到左树最右节点mostRight

​ a.若mostRight的右指针指向空，让其指向cur，cur向左移动

​ b.若mostRight的右指针指向cur，让其指向空，cur向右移动


举例：

/**			 a
*           / \
*          b   e
*         / \ / \
*        c  d f  g
*
*	Morris = [a, b, c, b, d, a, e, f, e, g]
/

2. 类型转换
Morris遍历可以实现前序、中序和后序遍历

  • 前序遍历：在第一次访问节点时，输出节点的值，然后进行左子树的遍历
  • 中序遍历：在第二次访问节点时(即mostRight的右指针指向当前节点时)，输出节点的值，然后进行右子树的遍历
  • 后序遍历：后序遍历的实现相对复杂，需要在遍历过程中记录左子树最右分支的路径，并在回溯时逆序输出

3. 优缺点

  • 优点：Morris遍历的空间复杂度为O(1)，比使用栈或递归的遍历算法更高效
    此外，Morris遍历不会占用额外的内存空间，对于内存受限的环境非常友好
  • 缺点：Morris遍历会修改原始树的结构，需要在遍历完成后还原 此外，Morris遍历的实现相对复杂，需要理解其背后的思想和原理

代码实现

// Morris遍历
public:
	vector<int> void morris(TreeNode *root) {
	    TreeNode *cur = root;
	    TreeNode *mostRight = nullptr;
	    
	    while (cur != cullptr) {
			mostRight = cur->left;
	        // cur 有左树
	        if (mostRight != nullptr) {
	            // 最右节点不为空 且 不为cur
				while (mostRight->right != nullptr && mostRight->right != cur){
	                most = most->right;
	            }
	            
	            // 第一次到达
	            // cur左子树的 最右节点mostRight的右指针指向空
	            // cur 向右移动
	            if (mostRight == nullptr) {
					mostRight->right = cur;
	                cur = cur->left;
	                continue;
	            }
	            // 第二次到达
	            // 此时cur左子树的 最右节点mostRight的右指针指向cur
	            // cur 向左移动
	            else {
	                // 恢复
	                mostRight->right = nullptr;
	                // cur = cur->right;
	            }
	        }
	        
	 		// cur 无子树，向右移动
	 		cur = cur->right;
    	}
};



Morris遍历模板

public: 
	vector<int> marris(TreeNode *root) {
		TreeNode *cur = root;
	    TreeNode *mostRight = nullptr;
	    
	    while (cur != nullptr) {
			mostRight = cur->left;
	        if (mostRight != nullptr) {
				while (mostRight->right != nullptr && mostRight->right != cur) {
	                mostRight = mostRight->right;
	            }
	          	
	            if (mostRight == nullptr) {
	                mostRight->right = cur;
	                cur = cur->left;
	                continue;
	            } else {
	                mostRight->right = nullptr;
	                // cur = cur->right
	            }
	        } 
			
	        cur = cur->right;
	    }
};



Morris遍历加工出前序

测试链接

/**
 * 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> preorderTraversal(TreeNode* root) {
        // 修改I
        vector<int> res;
        if (root == nullptr)
            return res;
        
		TreeNode *cur = root;
        TreeNode *mostRight = nullptr;

        while (cur != nullptr) {
            mostRight = cur->left;
            // cur 有左树
            if (mostRight != nullptr) {
                // 最右节点不为空 且 不为cur
                while (mostRight->right != nullptr && mostRight->right != cur){
                    mostRight = mostRight->right;
                }

                // 第一次到达
                // cur左子树的 最右节点mostRight的右指针指向空
                // cur 向右移动
                if (mostRight->right == nullptr) {
                    // 对于有左子树的节点——第一次收集
					// 修改II
                    // emplace_back()也可
                    res.push_back(cur->val);
                    mostRight->right = cur;
                    cur = cur->left;
                    // 别忘了 continue
                    continue;
                }
                // 第二次到达
                // cur左子树的 最右节点mostRight的右指针指向cur
                // cur 向左移动
                else {
                    // 恢复
                    mostRight->right = nullptr;
                    // cur = cur->right;
                }
            } else {
                // 对于没有左子树的节点——直接收集
                // 修改III
                res.emplace_back(cur->val);
            }

            // cur 无子树，向右移动
            cur = cur->right;
        }
        
        // 修改IV
        // 别忘了 修改时在最后返回res
        return res;
    }
};



Morris遍历加工出中序

测试链接

写法一 一般写法

/**
 * 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> inorderTraversal(TreeNode* root) {
        // 修改I
        vector<int> ans;
        if (root == nullptr)
            return ans;
        
        TreeNode *cur = root, *mostRight = nullptr;
        
        while (cur != nullptr) {
            mostRight = cur->left;
            if (mostRight != nullptr) {
                while (mostRight->right != nullptr && mostRight->right != cur)
                    mostRight = mostRight->right;
                
                if (mostRight->right == nullptr) {
                    mostRight->right = cur;
                    cur = cur->left;
                    continue;
                } else {
					// 修改II
                    ans.push_back(cur->val);
                    mostRight->right = nullptr;
                } 
            } else {
                // 修改III
                ans.push_back(cur->val);
            }
        
            cur = cur->right;        
        }
        
		// 修改IV
        return ans;
    }
};


写法二 简略写法

/**
 * 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> inorderTraversal(TreeNode* root) {
        // 修改I
        vector<int> ans;
        if (root == nullptr)
            return ans;
        
        TreeNode *cur = root, *mostRight = nullptr;
        
        while (cur != nullptr) {
            mostRight = cur->left;
            if (mostRight != nullptr) {
                while (mostRight->right != nullptr && mostRight->right != cur)
                    mostRight = mostRight->right;
                
                if (mostRight->right == nullptr) {
                    mostRight->right = cur;
                    cur = cur->left;
                    continue;
                } else {
                    mostRight->right = nullptr;
                } 
            } 
            
            // 修改II
            // 无左树——只被遍历1次；有左树——第2次遍历 都会经过这里
            ans.push_back(cur->val);
            cur = cur->right;        
        }
        
		// 修改III
        return ans;
    }
};





144.二叉树的前序遍历

🌟递归

原题链接


C++
若未特殊标明，以下题解均写用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:
    // 注意引用符
    void preorder(TreeNode* root, vector<int> &res) {
        if (root == nullptr)
            // preorder 函数被定义为返回 void 类型——不返回任何值
            // return; 仅仅是结束函数的执行，并不返回任何值
            return;
        // 存入向量的末尾
        res.push_back(root->val);
        // 前序——根左右
        preorder(root->left, res);
        preorder(root->right, res);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        // 定义一个 矢量/向量——更准确地说是一个动态数组
        vector<int> res;
        preorder(root, res);

        return res;
    }
};




方法二 Morris遍历

/**
 * 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> preorderTraversal(TreeNode* root) {
        // 修改I
        vector<int> res;
        if (root == nullptr)
            return res;
        
		TreeNode *cur = root;
        TreeNode *mostRight = nullptr;

        while (cur != nullptr) {
            mostRight = cur->left;
            // cur 有左树
            if (mostRight != nullptr) {
                // 最右节点不为空 且 不为cur
                while (mostRight->right != nullptr && mostRight->right != cur){
                    mostRight = mostRight->right;
                }

                // 第一次到达
                // cur左子树的 最右节点mostRight的右指针指向空
                // cur 向右移动
                if (mostRight->right == nullptr) {
                    // 对于有左子树的节点——第一次收集
					// 修改II
                    // emplace_back()也可
                    res.push_back(cur->val);
                    mostRight->right = cur;
                    cur = cur->left;
                    // 别忘了 continue
                    continue;
                }
                // 第二次到达
                // cur左子树的 最右节点mostRight的右指针指向cur
                // cur 向左移动
                else {
                    // 恢复
                    mostRight->right = nullptr;
                    // cur = cur->right;
                }
            } else {
                // 对于没有左子树的节点——直接收集
                // 修改III
                res.emplace_back(cur->val);
            }

            // cur 无子树，向右移动
            cur = cur->right;
        }
        
        // 修改IV
        // 别忘了 修改时在最后返回res
        return res;
    }
};





94.二叉树的中序遍历

🌟递归+迭代

原题链接


C++
若未特殊标明，以下题解均写用C++

方法一 递归 (DFS )

/**
 * 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:
    void inorder(TreeNode* root, vector<int>& res) {
        //可以另写成if (!root)
        if (!root) 
            return;
		// 中序——左根右——先插入最左边的左孩子
        inorder(root->left, res);
        res.push_back(root->val);
        inorder(root->right, res);
    }
    
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        inorder(root, res);
        
        return res;
    }
};




方法二 Morris遍历

/**
 * 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> inorderTraversal(TreeNode* root) {
        // 修改I
        vector<int> ans;
        if (root == nullptr)
            return ans;
        
        TreeNode *cur = root, *mostRight = nullptr;
        
        while (cur != nullptr) {
            mostRight = cur->left;
            if (mostRight != nullptr) {
                while (mostRight->right != nullptr && mostRight->right != cur)
                    mostRight = mostRight->right;
                
                if (mostRight->right == nullptr) {
                    mostRight->right = cur;
                    cur = cur->left;
                    continue;
                } else {
					// 修改II
                    ans.push_back(cur->val);
                    mostRight->right = nullptr;
                } 
            } else {
                // 修改III
                ans.push_back(cur->val);
            }
        
            cur = cur->right;        
        }
        
		// 修改IV
        return ans;
    }
};





145.二叉树的后序遍历

🌟递归+迭代

原题链接


C++
若未特殊标明，以下题解均写用C++

方法一 递归 (DFS )

/**
 * 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:
    void postorder(TreeNode *root, vector<int> &res) {
        if (!root)
            return;

        // 后序——左右根
        postorder(root->left, res);
        postorder(root->right, res);
        // 左右都不存在才先插入根节点的值
        res.push_back(root->val);
    }

    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        postorder(root, res);
        return res;
    }
};




方法二 迭代

/**
 * 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> postorderTraversal(TreeNode* root) {
        vector<int> res;
        // 空树
        if (!root) 
            return res;
        
        // 定义一个 树节点栈
        stack<TreeNode* > stk;
        TreeNode *prev = nullptr;
        // 树没遍历完 或 栈非空
        while (root != nullptr || !stk.empty()) {
            // 树没遍历完
            while (root != nullptr) {
                // 遍历所有左节点 入栈
                // 将这个树节点 入栈
                stk.emplace(root);
                root = root->left;
            }
            
            // 若此时 root 为空
            // 更新 root 
            root = stk.top();
            // 栈顶元素用完 弹出栈
            stk.pop();
            // 无右子节点 或 这个右子节点被遍历过
            if (root->right == nullptr || root->right == prev) {
                res.emplace_back(root->val);
                // 标记这个节点
                prev = root;
                root = nullptr;
            } 
            // 有右子节点
            else { 
                stk.emplace(root);
                root = root->right;
            }
        }

        return res;
    }
};




方法三 Morris遍历

class Solution {
public:
    void addPath(vector<int> &vec, TreeNode *node) {
        int count = 0;
        while (node != nullptr) {
            ++count;
            vec.emplace_back(node->val);
            node = node->right;
        }
        reverse(vec.end() - count, vec.end());
    }

    vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        if (root == nullptr) {
            return res;
        }

        TreeNode *p1 = root, *p2 = nullptr;

        while (p1 != nullptr) {
            p2 = p1->left;
            if (p2 != nullptr) {
                while (p2->right != nullptr && p2->right != p1) {
                    p2 = p2->right;
                }
                if (p2->right == nullptr) {
                    p2->right = p1;
                    p1 = p1->left;
                    continue;
                } else {
                    p2->right = nullptr;
                    addPath(res, p1->left);
                }
            }
            p1 = p1->right;
        }
        addPath(res, root);
        return res;
    }
};





102.二叉树的层序遍历

🌟BFS+队列

原题链接


C++
若未特殊标明，以下题解均写用C++

方法一 BFS

/**
 * 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>> ret;
        if (!root) {
            return ret;
        }

        queue <TreeNode*> q;
        q.push(root);
        while (!q.empty()) {
            int currentLevelSize = q.size();
            ret.push_back(vector <int> ());
            for (int i = 1; i <= currentLevelSize; ++i) {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        
        return ret;
    }
};




方法二 队列

/**
 * 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) {}
 * };
 */
// #include <queue>  
// #include <vector>  
class Solution {  
public:  
    vector<vector<int>> levelOrder(TreeNode* root) {  
        vector<vector<int>> ans;  
        if (root == nullptr )
            return ans;  
        
        queue<TreeNode*> cur;  
        cur.push(root);  
          
        while (!cur.empty()) {
        	 // 当前层的节点数
            int size = cur.size();
            // 存储当前层的节点值  
            vector<int> vals; 
              
            for (int i = 0; i < size; ++i) {  
                TreeNode* node = cur.front();  
                cur.pop();
                  
                vals.push_back(node->val);
                  
                if (node->left)
                    cur.push(node->left); 
  
                if (node->right)
                    cur.push(node->right);  
            }  
              
            ans.push_back(vals); // 将当前层的节点值添加到答案中  
        }  
          
        return ans;  
    }
};
Chiefavefan
关注
专栏目录
LeetCode：二叉树的前、中、后序遍历——如何创建一棵【二叉树】
Super algorithm 的博客，技术爱好者。
04-08 1650
LeetCode：二叉树的前、中、后序遍历——如何创建一棵【二叉树】 给你二叉树的根节点 root ，返回它节点值的`前序`、`中序`、`后序`遍历。 🌱[144、先序遍历] 🌱[94、中序遍历] 🌱[144、后序遍历]
python-leetcode面试题解之第366题寻找二叉树的叶子节点.zip
06-26
总之，理解和解决LeetCode的第366题不仅可以帮助你在面试中展示你的Python编程和数据结构能力，还能加深你对二叉树遍历算法的理解，这对于任何从事计算机科学和软件工程的人来说都是宝贵的经验。
leetcode | java | 第94题 | 二叉树中的中序遍历
iCling的博客
03-22 357
【代码】leetcode | java | 第94题 | 二叉树中的中序遍历。
leetcode | python | 第144题 | 二叉树的前序遍历
iCling的博客
03-29 435
【代码】leetcode | python | 第144题 | 二叉树的前序遍历。
leetcode | python | 第145题 | 二叉树的后序遍历
iCling的博客
03-30 171
【代码】leetcode | python | 第145题 | 二叉树的后序遍历。
【算法】二叉树遍历算法总结：前序中序后序遍历
蛮三刀酱
02-22 5044
前言 二叉树遍历是非常经典的算法题，也是二叉树的一道基础算法题。 但是在平常的笔试面试中，其出现的频率其实并不是特别的高，我推测是这种题目相对来说比较基础，算是一个基础知识点。 比如剑指offer中出现的后序遍历题目，是给出一个数字序列，让你判断是不是平衡二叉树后序遍历序列，这样出题的难度比直接让你写后序遍历难很多。 但是，二叉树遍历容易吗？在递归方法下，前中后序遍历都是一个思路，理解起来也比较...
二叉树前中后序Morris遍历，力扣94，144,145
qq_45948401的博客
05-01 733
二叉树Mirros前中后序遍历
Leetcode（144）——二叉树的前序遍历
KCDCY的博客
05-31 330
Leetcode 144 ——二叉树的前序遍历
【LeetCode】二叉树的遍历（Java）--递归、迭代、Morris
Hello World!
07-08 1160
方法1：递归方法思路与算法首先我们需要了解什么是二叉树的前序遍历：按照访问根节点——左子树——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候，我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质，我们可以直接用递归函数来模拟这一过程。定义 preorder(root) 表示当前遍历到 root 节点的答案。按照定义，我们只要首先将 root 节点的值加入答案，然后递归调用 preorder(root.left) 来遍历 root 节点的左子树，最后递归调用 preorder(
题解：二叉树的中序遍历（94.二叉树的中序遍历）
weixin_75156045的博客
07-30 835
本文介绍了二叉树中序遍历的三种方法：递归、迭代和 Morris 遍历。递归方法最为直观，迭代方法显式使用栈，Morris 遍历则巧妙地使用空闲指针，实现了 O(1) 空间复杂度。选择哪种方法主要取决于具体应用场景和对空间复杂度的要求。Morris遍历还没弄得很明白！
java-leetcode题解之第173题二叉搜索树迭代器.zip
06-18
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第173题——“二叉搜索树迭代器”。这道题目涉及到数据结构，特别是二叉搜索树（BST）以及迭代器的设计。让我们深入探讨一下这个话题。 首先，二叉搜索树...
C语言实现二叉树中序遍历-LeetCode题解
资源摘要信息:"c语言-leetcode题解之0094-binary-tree-inorder-traversal.zip" 在深入探讨这个资源之前，我们需要理解几个关键的概念：C语言、leetcode以及二叉树的中序遍历。 C语言是一种广泛使用的高级编程语言...
【算法】深入了解 CRC 校验码的计算过程
最新发布
qq_20623849的博客
10-16 528
CRC（循环冗余校验，Cyclic Redundancy Check）是一种常见的错误检测方法，它通过生成冗余码来确保数据传输的可靠性。在这篇文章中，我们将探讨 CRC 码的基本原理，并详细介绍其计算过程。通过对数据进行 CRC 校验，我们可以在传输过程中检测到潜在的错误并采取适当的纠正措施。这个新的数据包在传输时，如果接收方再次计算 CRC 校验码并与附带的校验码进行比较，可以确定数据是否在传输过程中出现了错误。：将附加了零位的数据通过生成多项式进行二进制除法运算，得出的余数就是 CRC 校验码。
【算法】双指针
2303_80828380的博客
10-13 771
力扣oj题之双指针算法
力扣10.13
qq_40052678的博客
10-13 436
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
【进阶OpenCV】 （14）-- 人脸识别 -- LBPH 算法
m0_74896766的博客
10-15 1076
本篇介绍了如何通过创建LBPH的人脸识别器来进行人脸识别。
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
csdn_aspnet的专栏
10-14 1193
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
【从零开始的LeetCode-算法】3099. 哈沙德数
qq_40878316的博客
10-15 289
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
PMRF：一种新的图像恢复算法 高质量修复图像 降低图像失真还原跟自然逼真度
GDL_MPY的博客
10-14 1012
（Posterior-Mean Rectified Flow，后验均值修正流）是一种新提出的图像恢复算法，旨在解决图像恢复任务中的。在去噪、超分辨率、修复等不同图像恢复任务中，PMRF能够在多个图像质量评估指标（如PSNR、SSIM、FID等）上表现出色，且没有明显的弱点，展示了其在多任务环境下的稳健性。图像恢复任务（如去噪、超分辨率、盲恢复等）中，常常需要在（如均方误差MSE）和（如图像的真实感和自然度，使用FID、SSIM等衡量）之间做权衡。
Java面试精选：二叉树中序遍历题解与leetcode第94题
资源摘要信息:"Java面试-leetcode题解之第94题二叉树的中序遍历.zip" Java是一种广泛使用的高级编程语言，它具有面向对象、跨平台、分布式的特性。Java在企业级应用开发中非常流行，尤其是在Web应用、移动应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值