leetcode树算法总结
Leetcode数组类题目总结(Java版本)
First
mid
last
要注意 mid 落在哪个区域，通过 A[mid]与 A[first]大小比较可以确定，同时要注意边界
条件的判断，当 A[mid]==A[first]应该是将其归类 A[mid]>A[first]的情况。
代码 public int search(int[] A, int target) {
if(target>=A[first]&&target<A[mid]){ last=mid-1;
}else{ first=mid+1;
} }else{
if(target>A[mid]&&target<=A[last]){ first=mid+1;
}else{ last=mid-1;
} } } return -1; } 相关题目 Search in Rotated Sorted Array II，见 §1.4 1.4 Search in Rotated Sorted Array II 描述 Follow up for ”Search in Rotated Sorted Array”: What if duplicates are allowed? Would this affect the run-time complexity? How and why? Write a function to determine if a given target is in the array. 分析 问题就出在边界上，即 A[mid]==A[first]的情况，如果这样，那么无法确定 mid 的位置 属于上题的图一还是图二。 因此这时判断 A[first]==target,如果不成立则 first++缩小一个范围。 代码 public class Solution { public boolean search(int[] A, int target) { if(A==null||A.length==0) return false; int first=0,last=A.length-1; while(first<=last){ int mid=(first+last)/2;
力扣 排序算法
力扣排序算法
力扣（LeetCode）中的排序算法主要包括冒泡排序、选择排序和插入排序。
以下是这些算法的简介：
1. 冒泡排序（Bubble Sort）：从序列右边开始比较相邻两个数字的大小，
再根据结果交换两个数字的位置。
2. 选择排序（Selection Sort）：从待排序的数据中寻找最小值，将其与序
列最左边的数字进行交换。
3. 插入排序（Insertion Sort）：从序列左端开始一次对数据进行排序。
在
排序过程中左侧的数据陆续归位，右侧留下的就是还未被排序的数据。
这些算法的时间复杂度均为O(n^2)，空间复杂度均为O(1)。
此外，力扣中还有一些高级的排序算法，如快速排序、归并排序等。
这些算法的时间复杂度通常优于O(n log n)，空间复杂度可能高于O(1)。
以上内容仅供参考，如需更多信息，建议访问力扣官网或请教编程专业人士。
刷力扣的基础知识
刷力扣的基础知识力扣（LeetCode）是一个在线技术面试准备平台，提供了大量的算法题和编程题目。
对于初学者来说，刷力扣的基础知识是非常重要的，它可以帮助我们掌握算法和数据结构的基本原理，并提高我们的编程能力。
本文将介绍一些刷力扣的基础知识，帮助初学者更好地利用这个平台。
一、刷题的重要性刷力扣可以帮助我们提高算法和编程的能力，对于求职和提升职业发展都非常有帮助。
通过刷题，我们可以熟悉各种常见的算法和数据结构，例如数组、链表、栈、队列、树、图等。
在解题过程中，我们可以学习到不同的解题思路和优化方法，提高我们的编程技巧和思维能力。
二、刷题的方法和技巧1. 题目分类：力扣的题目可以根据不同的难度和类型进行分类，我们可以根据自己的实际情况选择适合自己的题目进行刷题。
初学者可以先从简单难度的题目开始，逐渐提高难度。
2. 解题思路：在解题之前，我们可以先思考一下解题的思路和方法。
可以先分析题目要求，明确问题的输入和输出，然后根据题目的特点选择合适的算法和数据结构。
在解题的过程中，我们可以多尝试不同的解题思路，提高自己的思维能力。
3. 编程实现：在编程实现时，我们要注意编程语言的语法和细节，尽量写出简洁、高效的代码。
可以使用调试工具进行调试，查看代码的执行过程和变量的取值，帮助我们找出代码中的错误。
4. 测试和优化：在编写完代码后，我们要进行测试和优化。
可以编写一些测试用例进行验证代码的正确性，尽量覆盖各种边界情况和特殊情况。
如果发现代码运行效率较低，可以尝试优化算法和数据结构，减少代码的时间复杂度和空间复杂度。
三、常见的算法和数据结构在刷力扣的过程中，我们会遇到很多常见的算法和数据结构。
下面列举一些常见的算法和数据结构，供大家参考。
1. 数组：数组是一种线性数据结构，可以存储多个相同类型的元素。
在数组中，每个元素都有一个索引，可以根据索引访问元素。
常见的操作有插入、删除、查找等。
2. 链表：链表是一种动态数据结构，可以存储多个不连续的元素。
二叉树遍历（前中后序遍历，三种方式）
⼆叉树遍历（前中后序遍历，三种⽅式）⽬录刷题中碰到⼆叉树的遍历，就查找了⼆叉树遍历的⼏种思路，在此做个总结。
对应的LeetCode题⽬如下：，，，接下来以前序遍历来说明三种解法的思想，后⾯中序和后续直接给出代码。
⾸先定义⼆叉树的数据结构如下：//Definition for a binary tree node.struct TreeNode {int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};前序遍历，顺序是“根-左-右”。
使⽤递归实现：递归的思想很简单就是我们每次访问根节点后就递归访问其左节点，左节点访问结束后再递归的访问右节点。
代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;helper(root,res);return res;}void helper(TreeNode *root, vector<int> &res){res.push_back(root->val);if(root->left) helper(root->left, res);if(root->right) helper(root->right, res);}};使⽤辅助栈迭代实现：算法为：先把根节点push到辅助栈中，然后循环检测栈是否为空，若不空，则取出栈顶元素，保存值到vector中，之后由于需要想访问左⼦节点，所以我们在将根节点的⼦节点⼊栈时要先经右节点⼊栈，再将左节点⼊栈，这样出栈时就会先判断左⼦节点。
代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;stack<TreeNode*> st;st.push(root);while(!st.empty()){//将根节点出栈放⼊结果集中TreeNode *t = st.top();st.pop();res.push_back(t->val);//先⼊栈右节点，后左节点if(t->right) st.push(t->right);if(t->left) st.push(t->left);}return res;}};Morris Traversal⽅法具体的详细解释可以参考如下链接：这种解法可以实现O(N)的时间复杂度和O(1)的空间复杂度。
树枝问题公式
树枝问题公式
树枝问题指的是如何计算一棵树的总枝数。
一个简单的公式来计
算树枝的数量是n-1，其中n表示树的总节点数（包括根节点）。
这个公式的原理是树的分支总数等于节点总数减去1。
这个公式的推导可以通过归纳法证明。
当有一个节点时，树枝数
量为0。
如果加入一个节点形成两个节点的树，树枝数量为1。
接着，
再加入一个节点形成三个节点的树，树枝数量为2。
可以发现，每增加一个节点，树枝数量也增加1。
因此，树枝数量可以表示为n-1。
除了这个简单的公式，还可以从树的结构本身来拓展树枝的计算。
树枝是树的分支，可以通过遍历树的方式来计算树枝的数量。
常用的
树的遍历算法有深度优先遍历（DFS）和广度优先遍历（BFS）。
通过
这些遍历算法，可以遍历树的每一个节点，并统计出树的树枝数量。
还可以进一步拓展讨论树中的叶子节点与分支节点数量之间的关系。
叶子节点是指没有子节点的节点，分支节点是指至少有一个子节
点的节点。
在一棵树中，叶子节点数目为n0，分支节点数目为n2，则
树的总节点数为n = n0 + n2，而树的总枝数为n2。
树枝数量也可以通过叶子节点和分支节点的关系来计算。
力扣算法题讲解
力扣算法题讲解全文共四篇示例，供读者参考第一篇示例：力扣算法题作为程序员面试中的重要一环，是检验求职者编码能力和逻辑思维能力的利器。
力扣网站（LeetCode）上有大量的算法题目，涵盖了各种难度和类型，让程序员可以通过刷题提升自己的编码能力。
本文将对力扣算法题进行讲解，帮助读者更好地理解和掌握这些题目的解法。
一、算法题的重要性在程序员求职过程中，算法题几乎是不可或缺的一部分。
无论是技术面试还是在线编程测试，都会涉及到各种算法问题。
掌握算法题对于提高面试成功率和找到理想工作至关重要。
力扣算法题是目前最受欢迎的刷题平台之一，许多公司的面试题目也来源于此。
二、如何刷题在刷题之前，我们首先要了解算法的基本概念和常见的解题思路。
针对不同类型的算法题目，可以采取不同的解题策略，比如暴力求解、贪心算法、动态规划、分治法等。
熟悉这些解题思路可以帮助我们更快地解决问题。
在刷题的过程中，我们还要注意一些技巧和注意事项。
比如要注重代码的复用性和可读性，尽量避免写出冗长复杂的代码；要注意边界条件的处理，避免出现溢出或越界等问题；要利用调试工具进行调试，找出代码中的错误并进行修正。
在刷题的过程中，我们要注重积累经验，不断总结和学习。
三、力扣算法题目讲解下面我们以一道力扣算法题目为例，进行详细的讲解和解题过程。
题目：两数之和给定一个整数数组nums 和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回它们的数组下标。
假设每种输入只对应一个答案，且同样的元素不能被重复利用。
示例：输入：nums = [2, 7, 11, 15], target = 9输出：[0, 1]解释：因为nums[0] + nums[1] = 2 + 7 = 9，所以返回[0, 1]。
解题思路：针对这道题目，我们可以通过哈希表来存储每一个数字及其对应的索引值。
遍历数组nums，在遍历的过程中，判断target 减去当前元素的值，是否已经在哈希表中出现过了。
lc刷题分类总结
LC（LeetCode）刷题分类总结如下：
1. 数组和字符串
- 数组操作：查找、排序、旋转、反转等
- 双指针技巧：判断回文字符串、寻找两个数的中位数等- 字符串匹配：KMP算法、暴力匹配等
2. 链表
- 链表基础操作：添加节点、删除节点、反转链表等
- 链表进阶操作：两数相加、环形链表等
3. 树和图
- 二叉树遍历：前序、中序、后序、层次遍历等
- 二叉树操作：判断平衡树、判断二叉搜索树等
- 图的遍历：深度优先搜索、广度优先搜索等
- 最小生成树：Prim算法、Kruskal算法等
4. 动态规划
- 最长递增子序列、最长公共子序列等
- 背包问题：01背包、完全背包等
- 打家劫舍问题、分割等和子集等
5. 贪心算法
- 分发饼干、合并区间等
- 活动选择问题、无重叠区间等
6. 回溯算法
- N皇后问题、全排列问题等
- 子集问题、电话号码的字母组合等
7. 位运算和数学技巧
- XOR异或的应用、位运算与加减乘除等
- 数学技巧：绝对值方程、同余方程等。
LeetCodeJAVA语言全部解题思路+答案代码+多种解法+关键注释（持续更新...）
LeetCodeJAVA语⾔全部解题思路+答案代码+多种解法+关键注释（持续更新...）第⼀题:给定⼀个整数数组 nums 和⼀个⽬标值 target，请你在该数组中找出和为⽬标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输⼊只会对应⼀个答案。
但是，你不能重复利⽤这个数组中同样的元素。
⽰例:给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]解题思路 :使⽤双层for嵌套进⾏遍历查询 nums[i]=target-nums[j]题⽬解答:public static int[]twoSum(int nums[],int target){for(int i=0;i<nums.length;i++){for(int j=1;j<nums.length;j++){if(nums[i]==target-nums[j]){return new int []{i,j};}}}throw new IllegalArgumentException("No two sum solution ");}第⼆题给出两个 ⾮空 的链表⽤来表⽰两个⾮负的整数。
其中，它们各⾃的位数是按照 逆序 的⽅式存储的，并且它们的每个节点只能存储 ⼀位 数字。
如果，我们将这两个数相加起来，则会返回⼀个新的链表来表⽰它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
⽰例：输⼊：(2 -> 4 -> 3) + (5 -> 6 -> 4)输出：7 -> 0 -> 8原因：342 + 465 = 807解题思路:⾸先建⽴⼀个新的链表,然后从头往后撸给的这两个链表,建⽴⼀个dummy结点(哑结点),作⽤是防⽌这两个链表都为空,保证新建的这个链表存在,由于dummy结点本⾝不变,所以我们⽤⼀个指针cur来指向新链表的最后⼀个结点(因为是⼀个⼀个结点往⾥加的),这道题最⾼位在链表的末尾(还有⼀种情况最⾼位在链表的开头,⼀个类型,下个题给出),然后进⾏while循环(条件是两个链表有⼀个不为空)因为链表可能为空,所以我们取结点值的时候判断⼀下,如果为空取0,否则取结点值即可,同时还要加上⼀个进位carry,然后更新carry,直接sum/10即可然后 ⽤sum%10建⽴⼀个新的结点,(不⽤考虑两数和⼤于10,因为⼤于10就会随着carry的更新进位给⾼位),连到cur的后⾯,然后移动cur到下⼀个结点,while循环退出以后,还要进⾏⼀次判断就是最⾼位在进⾏相加的时候是否进位了,若carry的值为1,在建⽴⼀个为1的结点.public ListNode addTwonumbers(ListNode l1,ListNode l2){ListNode dummy =new ListNode(-1);ListNode cur = dummy;int carry =0;while(l1 != null || l2 != null){int d1 = l1 == null ?0: l1.val;int d2 = l2 == null ?0: l2.val;int sum = d1 + d2 + carry;carry = sum >=10?1:0;cur.next =new ListNode(sum %10);cur=cur.next;if(l1 != null) l1 = l1.next;if(l2 != null) l2 = l2.next;}if(carry ==1) cur.next =new ListNode(1);return dummy.next;}第⼆题进阶解题思路:上⾯的这道题最⾼位在链表的末尾,⽽这道题⽆⾮就是倒置⼀下链表,然后在执⾏上⾯⼀样的操作,下⾯介绍⼀下如何倒置链表 ,思路是在原链表之前建⽴⼀个空的newhead,因为⾸结点会变,然后从head开始,将之后的下⼀个结点移动到newhead之后,重复此操作直到head成为末结点为⽌public ListNode addTwonumbers(ListNode l1,ListNode l2){ListNode dummy =new ListNode(-1);ListNode cur = dummy;int carry =0;while(l1 != null || l2 != null){int d1 = l1 == null ?0: l1.val;int d2 = l2 == null ?0: l2.val;int sum = d1 + d2 + carry;carry = sum >=10?1:0;cur.next =new ListNode(sum %10);cur=cur.next;if(l1 != null) l1 = l1.next;if(l2 != null) l2 = l2.next;}if(carry ==1) cur.next =new ListNode(1);return reverseList(dummy.next);}public static ListNode reverseList(ListNode head){if(head == null){return head;}ListNode dummy =new ListNode(-1);dummy.next = head;ListNode cur = dummy;while(cur.next != null){ListNode tmp = cur.next;tmp.next = dummy.next;dummy.next = tmp;}return dummy.next;}第3题给定⼀个字符串，请你找出其中不含有重复字符的 最长⼦串 的长度。
leetcode基础算法
leetcode基础算法LeetCode是一个非常受程序员欢迎的在线编程平台，提供了大量的算法题目，帮助程序员提升编程能力和解决问题的能力。
在LeetCode 上，有许多基础算法题目，这些题目涵盖了算法的各个方面，对于初学者来说是非常有挑战性的。
本文将介绍一些LeetCode上的基础算法题目，并给出相应的解题思路。
1. 两数之和（Two Sum）题目描述：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
解题思路：使用哈希表来存储数组中的元素和它们的索引。
遍历数组，对于每个元素，计算目标值与当前元素的差值，然后在哈希表中查找是否存在这个差值，如果存在，则返回两个数的索引。
2. 反转字符串（Reverse String）题目描述：编写一个函数，将输入的字符串反转过来。
解题思路：使用双指针法，一个指针指向字符串的开头，另一个指针指向字符串的末尾，然后交换两个指针指向的字符，然后分别向中间移动指针，直到两个指针相遇。
3. 整数反转（Reverse Integer）题目描述：给定一个32位有符号整数，将整数中的数字进行反转。
解题思路：使用数学方法，通过取余和除法操作，将整数的每一位数字取出并反转，然后重新组合成一个新的整数。
需要注意的是，反转后的整数可能会溢出，所以需要判断反转后的整数是否在32位有符号整数的范围内。
4. 回文数（Palindrome Number）题目描述：判断一个整数是否是回文数。
解题思路：将整数转换为字符串，然后使用双指针法，一个指针指向字符串的开头，另一个指针指向字符串的末尾，然后比较两个指针指向的字符是否相等，如果相等，则继续向中间移动指针，直到两个指针相遇。
5. 罗马数字转整数（Roman to Integer）题目描述：给定一个罗马数字，将其转换成整数。
解题思路：使用哈希表来存储罗马数字和对应的整数值。
遍历罗马数字，对于每个字符，判断它的下一个字符是否存在，并且下一个字符对应的整数值是否比当前字符对应的整数值大，如果是，则减去当前字符对应的整数值，否则加上当前字符对应的整数值。
leetcode c语言版解答
leetcode c语言版解答LeetCode是面向程序员的一个在线编程平台，提供了丰富的编程题目，以供开发者练习和提高自己的算法和数据结构能力。
本文将用简体中文介绍一些常见的LeetCode题目，并提供相应的C语言解答。
1.两数之和（Two Sum）题目描述：给定一个整数数组nums和一个目标值target，在数组中找出和为目标值的两个整数，并返回这两个整数的索引。
解题思路：使用哈希表来存储每个元素的值与索引，对于每一个元素，通过target异或当前元素的值得到另一个元素，然后在哈希表中查找是否存在这个元素。
解答代码：```cint* twoSum(int* nums, int numsSize, int target, int* returnSize) {int* res = (int*)malloc(sizeof(int) * 2);*returnSize = 2;if (nums == NULL || numsSize < 2) { return res;}int HashMap[10000] = {0};for (int i = 0; i < numsSize; i++) { int rest = target - nums[i];if (HashMap[rest] > 0) {res[0] = HashMap[rest] - 1;res[1] = i;break;} else {HashMap[nums[i]] = i + 1;}}return res;}```2.有效的括号（Valid Parentheses）题目描述：给定一个只包含字符'('，')'，'{'，'}'，'['和']'的字符串，判断字符串中的括号是否有效。
如果一个字符串满足以下条件的其中之一，则认为它是有效的：1.字符串为空；2.字符串的第一个字符是一个闭括号；3.字符串的长度为奇数；4.字符串中的每个括号都有一个配对的闭括号。
LeetCode刷题的一点个人建议和心得
LeetCode刷题的⼀点个⼈建议和⼼得⽬录1. 为什么我们要刷LeetCode?LeetCode是⾯向找IT⾏业相关公司开发岗/算法岗的⼀个算法题库⽹站，想去BAT等⼤⼚，笔试和⾯试中的⼤部头都要考你算法题的解题技巧和编码能⼒。
然⽽，对于很多⼤⼀⼤⼆在校的本科同学，甚⾄包含⼀部分研究⽣同学，都会问⼀句：LeetCode是啥？该部分同学⼀般都是在临近找⼯作时，寻找相关经验贴才知道原来还有这样的⼀个神奇的⽹站。
随着IT相关专业和⼤多数转专业同学都瞄准了互联⽹⽅向的岗位，以及计算机学科招⽣增多和专业的热门化（⾼考专业录取收分越来越⾼），导致内卷越来越严重。
因此，为了提⾼个⼈的核⼼竞争⼒，提前or开始刷LeetCode，从⽽开阔⾃⼰的算法思维，并提⾼⾃⼰的编码能⼒，能够⼤⼤增加我们获取理想Offer的机会。
2. LeetCode的现状和问题LeetCode⽹站刚开始创建时，题库内部共约800道题，其中的题⽬基本都是来⾃⾕歌等互联⽹⼤⼚的⾯试笔试真题。
然⽽，随着⽹站的发展，题库⾥⾯的题⽬数量也在逐步递增。
截⽌2020年10⽉4⽇，已累计1822道题。
后期，基本还会以每周4-5道题的数量递增。
从⽽导致：（1）题⽬量越来越⼤，想半年or⼀年全部刷完，很难！或者说，不现实，付出和收⼊很难成正⽐。
（2）考点⽅向多，不知道从哪⾥⼊⼿，让⼈感觉很迷茫。
（3）如果盲⽬地每天随机刷⼏道题，会出现：随着时间的推移，⼏周前答错的题，如今重写，依然会⼤概率出错。
即可能出现：⽵篮打⽔⼀场空的问题。
3. 本⽂的初衷本⼈⼤三时，有系统学习和刷过算法题半年多时间，另外在研⼆上学期也刷过三个多⽉的LeetCode。
对于LeetCode的刷题有⼀点个⼈的经验和⼼得，在记录⾃⼰过去学习过程的同时，也希望对初步踏⼊LeetCode刷题之旅的同学有点帮助。
本⽂的重点对象：⼤⼀⼤⼆的本科⽣，以及研⼀就下定决⼼打算找⼯作的同学。
如果正在看本⽂的你，有着ACM等算法⽐赛经历，就当作参考⼩资料看看吧>~<。
LeetCode--力扣算法整理总结
LeetCode--⼒扣算法整理总结1、双指针双指针法是最简单的⼀种了，⼤概就是通过两个变量，作为数组或者字符串的下标索引进⾏操作双指针⼀共分为三种，分为快慢指针、左右指针、滑动窗⼝左右指针⼀般就是while(left<right)................................⼒扣3题：给定⼀个字符串，请你找出其中不含有重复字符的最长⼦串的长度。
................................双指针法滑动窗⼝：两个变量为字符串起始位置索引，⼀个是左指针，⼀个右指针，当左指针指向内容和右指针指向的内容不⼀样，右指针++，⼀样的话，左指针等于右指针，右指针++。
期间左右指针指向的内容是否相等⽤了⼀个循环去判断class Solution {public:int lengthOfLongestSubstring(string s) {if(s.size() <= 1)return s.size();int res = 0;int len = 1;int left = 0;int right = 1;while(right < s.size()){len = 1;int tmp = right;for(int i=left;i<tmp;i++){if(s[right] == s[i]){left++;right = left+1;break;}if(s[right] != s[i])len++;if(i == right-1 && s[right] != s[i])right++;}res = max(res,len);}return res;}};................................⼒扣15题：给你⼀个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满⾜条件且不重复的三元组。
力扣算法总结
力扣算法总结力扣算法总结作为一名程序员，算法是必不可少的技能之一。
而力扣是一个非常好的算法练习平台，它提供了大量的算法题目，让我们可以不断地挑战自己，提高自己的算法水平。
在这里，我将分享一些我在力扣上做题的经验和总结。
1. 切题四件套在做算法题目时，我们需要先明确题目的要求和限制条件，然后再根据题目的特点选择合适的算法进行解题。
这里介绍一种切题四件套的方法：1）Clarification：明确题目的含义和限制条件，确保自己理解正确。
2）Possible solutions：列举可能的解法，比较它们的时间复杂度和空间复杂度，选择最优解。
3）Coding：根据选择的解法进行编码实现。
4）Test cases：编写测试用例进行测试，确保代码正确性和鲁棒性。
2. 常见算法分类在力扣上，算法题目可以分为多个分类，比如数组、链表、树、字符串、动态规划等。
下面简单介绍一些常见的算法分类：1）数组：数组是一种线性数据结构，可以用来存储一组相同类型的数据。
在算法题目中，数组常用来解决查找、排序、统计等问题。
2）链表：链表是一种非线性数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在算法题目中，链表常用来解决插入、删除、反转等问题。
3）树：树是一种非线性数据结构，它由一些节点组成，每个节点包含一个数据元素和若干个指向子节点的指针。
在算法题目中，树常用来解决遍历、查找、构建等问题。
4）字符串：字符串是一种特殊的数组，它由一些字符组成。
在算法题目中，字符串常用来解决匹配、替换、反转等问题。
5）动态规划：动态规划是一种算法思想，它通过将问题分解成子问题来解决复杂的问题。
在算法题目中，动态规划常用来解决最优化问题，比如背包问题、最长公共子序列等。
3. 常见算法技巧在做算法题目时，我们需要掌握一些常见的算法技巧，比如双指针、滑动窗口、递归、回溯等。
下面简单介绍一些常见的算法技巧：1）双指针：双指针是一种常用的算法技巧，它可以在O(n)的时间复杂度内解决一些问题。
单词拆分 leetcode
单词拆分 leetcode【原创实用版】目录1.单词拆分概述2.LeetCode 简介3.单词拆分的方法4.示例与实践5.总结正文一、单词拆分概述单词拆分是一种常见的编程问题，主要涉及到字符串处理和算法设计。
给定一个单词，将其拆分成若干个单词，要求拆分后的单词数量最少。
这个问题在面试题和编程竞赛中经常出现，具有一定的挑战性。
本文以LeetCode 为例，介绍如何解决这类问题。
二、LeetCode 简介LeetCode 是一个在线编程练习平台，提供海量的编程题目，主要针对算法和数据结构。
该平台可以帮助程序员提高编程能力，提升面试成功率。
LeetCode 上的题目涉及多个领域，包括动态规划、回溯、贪心等，适合各个层次的程序员学习和挑战。
三、单词拆分的方法解决单词拆分问题有多种方法，下面介绍两种常用的方法：滑动窗口法和前缀树法。
1.滑动窗口法滑动窗口法是一种贪心算法，通过维护一个窗口，不断向前滑动，得到拆分后的单词。
具体步骤如下：（1）初始化一个空字符串 s 和窗口 left 为 0，right 为 0。
（2）遍历字符串，当 right 到达字符串末尾时，将当前窗口加入结果列表，同时更新 left 为 right，right 为 right+1。
（3）重复步骤 2，直到窗口为空。
2.前缀树法前缀树是一种特殊的树结构，可以用来存储字符串。
解决单词拆分问题时，可以利用前缀树进行字符串匹配。
具体步骤如下：（1）构建一个前缀树，将单词插入树中。
（2）遍历字符串，将每个字符插入树中，如果遇到“空格”字符，则弹出当前节点的单词。
（3）遍历结束，返回树中的所有单词。
四、示例与实践下面以 LeetCode 上的一道题目为例，介绍如何使用前缀树法解决单词拆分问题。
题目：单词拆分给定一个字符串 s，返回拆分后的单词列表。
输入：s = "leetcode"输出：["leet", "code"]解题思路：（1）构建一个前缀树，将单词"leetcode"插入树中。
最近最久未使用算法例题
最近最久未使用算法例题（原创版）目录1.算法例题的重要性2.最久未使用算法例题的概述3.如何利用最近最久未使用算法例题提高编程能力4.总结正文【1.算法例题的重要性】算法例题是学习计算机编程和算法设计的重要组成部分，它能帮助我们更好地理解算法原理和编程实现。
通过解决算法例题，我们可以锻炼自己的编程能力、逻辑思维能力，提高代码实现的效率。
对于程序员来说，掌握一定的算法例题有助于提高面试成功率和职场竞争力。
【2.最久未使用算法例题的概述】最近最久未使用算法例题（LeetCode 90.Most Recent Common Ancestor）是一道典型的树形算法题目。
题目要求找到一个二叉树中两个节点的最近公共祖先。
这个问题可以通过优先队列（Heap）解决，将两个节点分别放入优先队列，然后遍历优先队列，找到第一个相同的节点，即为它们的最近公共祖先。
【3.如何利用最近最久未使用算法例题提高编程能力】（1）学习算法基础知识：要解决最近最久未使用算法例题，首先需要了解二叉树的基本结构和遍历方法，以及优先队列的基本原理和实现。
这些基础知识是解决类似问题的关键。
（2）阅读经典算法书籍：阅读一些经典的算法书籍，如《算法导论》、《编程珠玑》等，可以加深对算法原理的理解，为解决实际问题提供思路。
（3）刻意练习：通过在线编程平台，如 LeetCode、牛客网等，可以找到大量的算法题目进行练习。
在练习过程中，要注意总结经验，梳理知识点，不断提高自己的编程水平。
（4）参与讨论和分享：加入一些技术社区，如知乎、CSDN、GitHub 等，可以和其他开发者一起讨论和分享算法心得，提高自己的编程能力。
【4.总结】最近最久未使用算法例题作为一道典型的树形算法题目，可以帮助我们巩固和提高编程能力。
leetcode 题目分类
leetcode 题目分类LeetCode是一家专门提供算法题目的在线平台，并且该平台的题目广泛涵盖了各种难度级别的问题。
在这个平台上，题目种类非常繁多，包括但不限于数组、字符串、树、图、动态规划等等。
本文将对LeetCode上的题目进行分类，方便读者更好地理解和掌握这些题目。
一、数组和字符串问题1. 数组和字符串的基本操作，如查找、排序、去重等等。
2. 双指针问题，如反转字符串、判断回文字符串、移动零等等。
3. 哈希表问题，如两数之和、三数之和、无重复字符的最长子串等等。
4. 滑动窗口问题，如最小覆盖子串、长度最小的子数组等等。
二、链表问题1. 链表的基本操作，如遍历、翻转、删除等等。
2. 双指针问题，如链表的中间节点、链表的倒数第k个节点等等。
3. 递归问题，如反转链表、合并两个有序链表等等。
三、树问题1. 树的遍历问题，如前序遍历、中序遍历、后序遍历等等。
2. 二叉搜索树问题，如验证二叉搜索树、二叉搜索树的最近公共祖先等等。
3. 递归问题，如二叉树的最大深度、路径总和等等。
四、图问题1. 图的遍历问题，如深度优先遍历、广度优先遍历等等。
2. 最短路径问题，如Dijkstra算法、贝尔曼-福德算法等等。
3. 拓扑排序问题，如课程表、拓扑排序等等。
五、动态规划问题1. 斐波那契数列问题，如爬楼梯、不同路径等等。
2. 背包问题，如0/1背包、完全背包等等。
3. 最长公共子序列问题，如最长回文子序列、最长递增子序列等等。
六、其他问题1. 双栈问题，如有效的括号、最小栈等。
2. 堆问题，如前K个高频元素、数据流中的第K大元素等等。
3. 位运算问题，如位1的个数、缺失的数字等等。
通过以上分类，我们可以更好地理解LeetCode上的题目，同时也可以更有目的性地进行练习和提高。
力扣算法分类
力扣算法分类力扣（LeetCode）的算法题目可以按照不同的分类方式进行划分，以下是一些常见的分类方式：1. 数据结构：包括数组、链表、栈、队列、哈希表、树等数据结构的相关问题。
例如，数组的反转、链表的合并、栈的实现等。
2. 图论：包括最短路径、最小生成树、最大流、网络流等问题。
例如，最短路径问题中的Dijkstra算法、Floyd算法等。
3. 动态规划：包括背包问题、最长公共子序列、最长上升子序列、最长连续子序列等问题。
例如，背包问题中的最优二分查找算法、最长公共子序列中的滑动窗口算法等。
4. 数学问题：包括数学函数、数学模型等问题。
例如，计算斐波那契数列、计算最大子序列和等。
5. 字符串问题：包括字符串匹配、正则表达式匹配、字符串排序等问题。
例如，KMP算法、Boyer-Moore算法等。
6. 数学问题：包括数学函数、数学模型等问题。
例如，计算斐波那契数列、计算最大子序列和等。
7. 字符串问题：包括字符串匹配、正则表达式匹配、字符串排序等问题。
例如，KMP算法、Boyer-Moore算法等。
8. 数学问题：包括数学函数、数学模型等问题。
例如，计算斐波那契数列、计算最大子序列和等。
9. 数学问题：包括数学函数、数学模型等问题。
例如，计算斐波那契数列、计算最大子序列和等。
10. 数学问题：包括数学函数、数学模型等问题。
例如，计算斐波那契数列、计算最大子序列和等。
以上是一些常见的分类方式，不同的分类方式可以根据不同的需求进行选择。
在实际使用中，可以根据自己的需求选择合适的分类方式，以便更好地进行算法学习和练习。
[USER] [USER][BOS] 题目分类：数组题目编号：485题目描述：给出一个正整数数组nums 和一个目标值target ，请你在原数组中找出和为目标值的两个数，并返回这两个数的最小加值和。
示例1：输入：nums = [2, 3, 2, 5], target = 7输出：3解释：2 和5 的最小和是3 。
力扣算法解析
力扣算法解析全文共四篇示例，供读者参考第一篇示例：力扣（LeetCode）是一家在全球范围内拥有很高人气的在线编程学习平台。
它为编程爱好者和专业程序员提供了大量的算法题目和面试准备资源。
力扣算法题目的丰富性和难度也吸引了大批程序员加入进来，力扣算法解析成为了每一个程序员必备的技能之一。
力扣算法解析的作用主要有以下几个方面：1. 提高编程技能：通过分析和解决力扣算法题目，程序员可以不断提高自己的编程技能和算法思维能力。
力扣算法的难度分为简单、中等和困难三个级别，不同级别的题目涵盖了各种算法思想和数据结构，帮助程序员全面提升自己的编程水平。
2. 准备面试：很多技术公司的面试过程中会考察应聘者的算法和数据结构能力，力扣算法解析是应对面试挑战的重要方法之一。
通过练习力扣算法题目，程序员可以熟悉常见的算法思想和解题思路，为面试表现提供有力支持。
在解析力扣算法题目时，程序员一般会采取以下几个步骤：1. 理解问题：首先要对题目要求和输入输出进行详细理解，确定问题的关键点和解题思路。
有时候题目会比较复杂，需要程序员反复阅读和思考，确保自己对问题有清晰的认识。
2. 制定解决方案：在理解问题的基础上，程序员需要制定解决方案的思路和算法。
有些问题可以用暴力解法进行求解，有些问题则需要应用特定的算法思想和数据结构进行解决。
在选择解决方案时，程序员要考虑算法的时间复杂度和空间复杂度，确保解法是高效和可行的。
3. 编写代码实现：一旦有了解决方案思路，程序员就可以开始编写代码实现了。
在编写代码时，要注意代码的清晰和简洁，规范命名和注释，确保代码的可读性和可维护性。
要考虑边界条件和特殊情况，保证代码在各种情况下都能正确运行。
4. 调试和优化：在编写完代码后，程序员要进行调试和优化工作，确保代码没有逻辑错误和运行错误。
有时候需要通过调试工具和测试用例来验证代码的正确性。
如果发现代码效率不高或者算法思路有改进空间，可以对代码进行优化和改进，提高算法的执行效率。
leetcode 力扣 662 二叉树最大宽度 题解 算法题
题目:二叉树最大宽度给定一个二叉树，编写一个函数来获取这个树的最大宽度。
树的宽度是所有层中的最大宽度。
这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。
每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。
示例 1:输入:1/ \3 2/ \ \5 3 9输出: 4解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。
示例 2:输入:1/3/ \5 3输出: 2解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。
示例 3:输入:1/ \3 2/5输出: 2解释: 最大值出现在树的第 2 层，宽度为 2 (3,2)。
示例 4:输入:1/ \3 2/ \5 9/ \6 7输出: 8解释: 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null, 7)。
注意:答案在32位有符号整数的表示范围内。
语言:Pythondef widthOfBinaryTree(self, root):queue = [(root, 0, 0)]cur_depth = left = ans =0for node, depth, pos in queue:if node:queue.append((node.left, depth+1, pos*2))queue.append((node.right, depth+1, pos*2+1))if cur_depth != depth:cur_depth = depthleft = posans = max(pos - left +1, ans)return ans语言:Pythonclass Solution(object):def widthOfBinaryTree(self, root):self.ans =0left = {}def dfs(node, depth =0, pos =0):if node:left.setdefault(depth, pos)self.ans = max(self.ans, pos - left[depth] +1)dfs(node.left, depth +1, pos *2)dfs(node.right, depth +1, pos *2+1)dfs(root)return self.ans语言:Javaclass Solution {public int widthOfBinaryTree(TreeNode root) {Queue<AnnotatedNode> queue = new LinkedList();queue.add(new AnnotatedNode(root, 0, 0));int curDepth = 0, left = 0, ans = 0;while (!queue.isEmpty()) {AnnotatedNode a = queue.poll();if (a.node != null) {queue.add(new AnnotatedNode(a.node.left, a.depth + 1, a.pos * 2));queue.add(new AnnotatedNode(a.node.right, a.depth + 1, a.pos * 2 + 1));if (curDepth != a.depth) {curDepth = a.depth;left = a.pos;}ans = Math.max(ans, a.pos - left + 1);}}return ans;}}class AnnotatedNode {TreeNode node;int depth, pos;AnnotatedNode(TreeNode n, int d, int p) {node = n;depth = d;pos = p;}}语言:Javaclass Solution {int ans;Map<Integer, Integer> left;public int widthOfBinaryTree(TreeNode root) {ans = 0;left = new HashMap();dfs(root, 0, 0);return ans;}public void dfs(TreeNode root, int depth, int pos) {if (root == null) return;puteIfAbsent(depth, x-> pos);ans = Math.max(ans, pos - left.get(depth) + 1);dfs(root.left, depth + 1, 2 * pos);dfs(root.right, depth + 1, 2 * pos + 1);}}语言:c++int widthOfBinaryTree(TreeNode* root) {int res = 0;queue<pair<TreeNode *, long long>> q;if (root) q.emplace(root, 0);while (!q.empty()) {long long first_offset = q.front().second;res = max(res, (int)(q.back().second - first_offset + 1));for (int size = q.size(), i = 0; i < size; i++) {auto [node, offset] = q.front(); q.pop();offset -= first_offset; //统一减去行首元素偏移，避免下面*2超出long long if (node->left) q.emplace(node->left, offset * 2);if (node->right) q.emplace(node->right, offset * 2 + 1);}}return res;}语言:php/*** Definition for a binary tree node.* class TreeNode {* public $val = null;* public $left = null;* public $right = null;* function __construct($value) { $this->val = $value; }* }*/class S olution {/*** @param TreeNode $root* @return Integer*/private$arr=[];function widthOfBinaryTree($root) {$this->travel($root,1,1);$max=0;foreach($this->arr as$k=>$v){$val=abs($this->arr[$k]['l']-$this->arr[$k]['r']);if($val>$max)$max=$val;}return$max+1;}function travel($root,$level,$val){if($root==null){return;}if(!isset($this->arr[$level]['l'])){$this->arr[$level]['l']=$val;}if(!isset($this->arr[$level]['r'])){$this->arr[$level]['r']=$val;}else if($this->arr[$level]['r']<$val){$this->arr[$level]['r']=$val;}$this->travel($root->left,$level+1,2*$val);$this->travel($root->right,$level+1,2*$val+1);}}语言:js[0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0, null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,null,0,nu ll,0,null,0,null,0,null,0,null,0,1,2,3,4,5,6]。
leetcode 力扣 587 安装栅栏 题解 算法题
题目:安装栅栏在一个二维的花园中，有一些用 (x, y) 坐标表示的树。
由于安装费用十分昂贵，你的任务是先用最短的绳子围起所有的树。
只有当所有的树都被绳子包围时，花园才能围好栅栏。
你需要找到正好位于栅栏边界上的树的坐标。
示例 1:输入: [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]输出: [[1,1],[2,0],[4,2],[3,3],[2,4]]解释:示例 2:输入: [[1,2],[2,2],[4,2]]输出: [[1,2],[2,2],[4,2]]解释:即使树都在一条直线上，你也需要先用绳子包围它们。
注意:1.所有的树应当被围在一起。
你不能剪断绳子来包围树或者把树分成一组以上。
2.输入的整数在 0 到 100 之间。
3.花园至少有一棵树。
4.所有树的坐标都是不同的。
5.输入的点没有顺序。
输出顺序也没有要求。
语言:Javaimport java.util.Arrays;import java.util.HashSet;import java.util.Set;public class Solution {public int[][] outerTrees(int[][] trees) {Set<int[]> hull = new HashSet<>();if (trees.length < 4) {hull.addAll(Arrays.asList(trees));int[][] res = new int[hull.size()][2];int index = 0;for (int[] h : hull) {res[index] = h;index++;}return res;}int leftMost = 0;for (int i = 0; i < trees.length; i++) {if (trees[i][0] < trees[leftMost][0]) {leftMost = i;}}int p = leftMost;do {int q = (p + 1) % trees.length;for (int i = 0; i < trees.length; i++) {if (orientation(trees[p], trees[i], trees[q]) < 0) {q = i;}}for (int i = 0; i < trees.length; i++) {if (i != p && i != q && orientation(trees[p], trees[i], trees[q]) == 0 && inBetween(trees[p], tre es[i], trees[q])) {hull.add(trees[i]);}}hull.add(trees[q]);p = q;} while (p != leftMost);int[][] res = new int[hull.size()][2];int index = 0;for (int[] h : hull) {res[index] = h;index++;}return res;}public int orientation(int[] p, int[] q, int[] r) {return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);}public boolean inBetween(int[] p, int[] i, int[] q) {boolean a = i[0] >= p[0] && i[0] <= q[0] || i[0] <= p[0] && i[0] >= q[0];boolean b = i[1] >= p[1] && i[1] <= q[1] || i[1] <= p[1] && i[1] >= q[1];return a && b;}}语言:Javaimport java.util.Arrays;import parator;import java.util.Stack;public class Solution {public int[][] outerTrees(int[][] trees) {if (trees.length <= 1) {return trees;}int[] bm = bottomLeft(trees);Arrays.sort(trees, (o1, o2) -> {double diff = orientation(bm, o1, o2) - orientation(bm, o2, o1);if (diff == 0) {return distance(bm, o1) - distance(bm, o2);} else {return diff > 0 ? 1 : -1;}});int i = trees.length - 1;while (i >= 0 && orientation(bm, trees[trees.length - 1], trees[i]) == 0) { i--;}for (int l = i + 1, h = trees.length - 1; l < h; l++, h--) {int[] temp = trees[l];trees[l] = trees[h];trees[h] = temp;}Stack<int[]> stack = new Stack<>();stack.push(trees[0]);stack.push(trees[1]);for (int j = 2; j < trees.length; j++) {int[] top = stack.pop();while (orientation(stack.peek(), top, trees[j]) > 0) {top = stack.pop();}stack.push(top);stack.push(trees[j]);}int[][] res = new int[stack.size()][2];int index = 0;for (int[] tree : stack) {res[index] = tree;index++;}return res;}public int orientation(int[] p, int[] q, int[] r) {return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);}public int distance(int[] p, int[] q) {return (p[0] - q[0]) * (p[0] - q[0]) + (p[1] - q[1]) * (p[1] - q[1]);}private int[] bottomLeft(int[][] points) {int[] bottomLeft = points[0];for (int[] p : points) {if (p[1] < bottomLeft[1]) {bottomLeft = p;}}return bottomLeft;}}语言:Javaimport java.util.Arrays;import java.util.HashSet;import java.util.Objects;import java.util.Set;import java.util.Stack;public class Solution {public int[][] outerTrees(int[][] trees) {Arrays.sort(trees, (p, q) -> q[0] - p[0] == 0 ? q[1] - p[1] : q[0] - p[0]);Stack<int[]> hull = new Stack<>();for (int[] tree : trees) {while (hull.size() >= 2 && orientation(hull.get(hull.size() - 2), hull.get(hull.size() - 1), tree) > 0) {hull.pop();}hull.push(tree);}hull.pop();for (int i = trees.length - 1; i >= 0; i--) {while (hull.size() >= 2 && orientation(hull.get(hull.size() - 2), hull.get(hull.size() - 1), trees[i]) > 0) {hull.pop();}hull.push(trees[i]);}// 去重Set<Point> hashSet = new HashSet<>();for (int[] tree : hull) {hashSet.add(new Point(tree[0], tree[1]));}int index = 0;int[][] res = new int[hashSet.size()][2];for (Point tree : hashSet) {res[index] = new int[]{tree.a, tree.b};index++;}return res;}class Point {int a;int b;public Point(int a, int b) {this.a = a;this.b = b;}@Overridepublic boolean equals(Object o) {if (this == o) {return true;}if (o == null || getClass() != o.getClass()) {return false;}Point point = (Point) o;return a == point.a && b == point.b;}@Overridepublic int hashCode() {return Objects.hash(a, b);}}public int orientation(int[] p, int[] q, int[] r) {return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]); }}语言:cppmemset(have,false,n);// 找到最左下角点int pre = 0;for(int i = 1;i < s.size();i ++) {if(s[i][0] < s[pre][0]) pre = i;else if(s[i][0] == s[pre][0] && s[i][1] < s[pre][1]) pre = i;}res.push_back(s[pre]);have[pre] = true;while(1) {int add = -1;for(int i = 0;i < s.size();i ++) {if(have[i]) continue;if(judge(s,pre,i)) {have[i] = true;res.push_back(s[i]);if(add == -1) add = i;else {if(Cal_dis(s[pre][0],s[pre][1],s[add][0],s[add][1]) < \Cal_dis(s[pre][0],s[pre][1],s[i][0],s[i][1])) {add = i;// 选择最远的}}}}if(add == -1) break;// 当没有新入点时 breakpre = add;}语言:cpp// 每一个点的 judge 函数判断时间复杂度 : O(n) 所以总的时间复杂度为 O(n ^ 2) bool judge(vector<vector<int>>& s,int a,int b) {// 判断是否有点 c 在 ab 的右边int x,y;// (x,y) 向量ab 的表示x = s[b][0] - s[a][0];y = s[b][1] - s[a][1];for(int i = 0;i < s.size();i ++) {int x_,y_;x_ = s[i][0] - s[a][0];y_ = s[i][1] - s[a][1];if(Crossmultiplication(x,y,x_,y_) < 0) return false;// 说明有点在 ab 的右侧 }return true;}语言:cppclass Solution {public:bool have[3005];// 已经确定的点// (x1,y1) x (x1,y2) 如果 < 0 说明点在线的右边int Crossmultiplication(int& x1,int& y1,int& x2,int& y2) {return x1 * y2 - x2 * y1;}int Cal_dis(int& x1,int& y1,int& x2,int& y2) {return (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);}bool judge(vector<vector<int>>& s,int& a,int& b) {// 判断是否有点 c 在 ab 的右边int x,y;// (x,y) 向量ab 的表示x = s[b][0] - s[a][0];y = s[b][1] - s[a][1];for(int i = 0;i < s.size();i ++) {int x_,y_;x_ = s[i][0] - s[a][0];y_ = s[i][1] - s[a][1];if(Crossmultiplication(x,y,x_,y_) < 0) return false;// 说明有点在 ab 的右侧 }return true;}vector<vector<int>> outerTrees(vector<vector<int>>& s) {if(s.size() < 4) return s;// 三角形一定是凸的// 凸包题// 首先找到最左的点然后慢慢的来围起来vector<vector<int>> res;int n = s.size();memset(have,false,n);int pre = 0;for(int i = 1;i < s.size();i ++) {if(s[i][0] < s[pre][0]) pre = i;else if(s[i][0] == s[pre][0] && s[i][1] < s[pre][1]) pre = i;}res.push_back(s[pre]);have[pre] = true;while(1) {int add = -1;for(int i = 0;i < s.size();i ++) {if(have[i]) continue;if(judge(s,pre,i)) {have[i] = true;res.push_back(s[i]);if(add == -1) add = i;else {if(Cal_dis(s[pre][0],s[pre][1],s[add][0],s[add][1]) < \Cal_dis(s[pre][0],s[pre][1],s[i][0],s[i][1])) {add = i;// 选择最远的}}}}if(add == -1) break;pre = add;}return res;}};语言:python3class Solution:def outerTrees(self, points: List[List[int]]) -> List[List[int]]:def oriented(p, q, r):return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]) # 相当于负sinx的值，如果-sinx大于0说明qr相对于pq右拐了，则q 点作为内部点可以忽略，反之-sinx小于0说明qr相对于pq左拐了，可以正常添加r点到序列中def inbetween(p, i, q):a = p[0] <= i[0] <= q[0] or q[0] <= i[0] <= p[0]b = p[1] <= i[1] <= q[1] or q[1] <= i[1] <= p[1]return a and bif len(points) < 4:return pointspoints.sort()m = set()p = 0q = 1hull = []while q != 0:hull.append(points[p])m.add(p)q = (p + 1) % len(points)for r in range(len(points)):if oriented(points[p], points[r], points[q]) < 0: # 发生右拐,r比q更近q = rfor r in range(len(points)):if r != p and r != q and oriented(points[p], points[q], points[r]) == 0 and inbetween(points[p], points[r], points[q]) and r n ot in m:hull.append(points[r]) # r值不能与p,q重合，因为0与任何向量的sin值都为0，同时如果r点在p,q之间则将r点添加，否则r点会作为下一个最近点添加到hull里m.add(r) # 防止一条竖直的线的情况p = qreturn hull语言:python3class Solution:def outerTrees(self, points: List[List[int]]) -> List[List[int]]:def oriented(p, q, r):return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])def cos(origin, p): # cos值return round((p[0] - origin[0]) / (distance(origin, p) ** 0.5), 7) # 根据我调试后发现保留7位小数可以得到正确结果，太低或太高都不行def distance(origin, p): # 距离的平方return (p[1] - origin[1]) ** 2 + (p[0] - origin[0]) ** 2if len(points) < 4:return pointspoints.sort(key=lambda x: (x[1], x[0])) # 先根据y值排序，y值相同则根据x值排序origin = points[0]polors = [] # 极坐标列表m = {} # 储存极坐标与原坐标的对应关系for i in range(1, len(points)):polor = (cos(origin, points[i]), distance(origin, points [i]))m[polor] = points[i]polors.append(polor)polors.sort(key=lambda x: (-x[0], x[1])) # 先根据cos值逆序排序，如果相同则距离近的排前面x = polors[-1][0] # 最后一条边的cos值xs = []for i in range(len(polors) - 1, -1, -1): # 最后一条边如果共线的点则需要反转顺序，即由远到近排序if polors[i][0] == x:xs.append(polors[i])else:breakpolors = polors[:i + 1] + xs if round(polors[i][0], 5) != x else xsstack = [origin, m[polors[0]]] # 栈里面先储存两点for i in range(1, len(polors)):r = m[polors[i]]while len(stack) >= 2 and oriented(stack[-2], r, stack[-1]) < 0: # 发生右拐，弹出栈顶的点stack.pop()stack.append(r)return stack语言:python3class Solution:def outerTrees(self, points: List[List[int]]) -> List[List[int]]:def oriented(p, q, r):return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])if len(points) < 4:return pointspoints.sort() # 按照x值正序排列hull = [points[0], points[1]]for i in range(2, len(points)):r = points[i]while len(hull) >= 2 and oriented(hull[-2], r, hull[-1]) < 0:hull.pop()hull.append(r)m = set()for p in hull: # 将已经添加的树储存到集合中m.add(tuple(p))points = points[::-1] # 按照x值逆序排列for i in range(1, len(points)):r = points[i]while len(hull) >= 2 and oriented(hull[-2], r, hull[-1]) < 0:hull.pop()if tuple(r) not in m:hull.append(r) m.add(tuple(r)) return hull。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
LeetCode树算法总结
1. 简介
LeetCode是一个在线编程平台，提供了大量的算法题目用于练习和学习。
树是其中一个重要的数据结构，在LeetCode上有很多与树相关的算法题目。
本文将对LeetCode树算法进行全面总结，包括重要观点、关键发现和进一步思考。
2. 树的基础知识
在深入讨论LeetCode树算法之前，我们先回顾一下树的基础知识。
2.1 树的定义
树是一种非线性的数据结构，由节点和边组成。
每个节点可以有多个子节点，但只能有一个父节点（除了根节点）。
没有父节点的节点称为根节点，没有子节点的节点称为叶子节点。
2.2 二叉树
二叉树是一种特殊的树，每个节点最多只能有两个子节点。
这两个子节点分别称为左子节点和右子节点。
2.3 二叉搜索树（BST）
二叉搜索树是一种特殊的二叉树，满足以下条件： - 左子树所有值小于等于当前节点值 - 右子树所有值大于等于当前节点值 - 左右子树也都是二叉搜索树
二叉搜索树的一个重要性质是，对于任意节点，它的左子树中的所有节点值都小于它，右子树中的所有节点值都大于它。
这个性质使得在二叉搜索树中进行查找、插入和删除操作非常高效。
2.4 二叉树的遍历
在LeetCode树算法中，经常需要对二叉树进行遍历。
常见的遍历方式有三种：前序遍历、中序遍历和后序遍历。
•前序遍历（Preorder Traversal）：先访问当前节点，然后递归地访问左子树和右子树。
•中序遍历（Inorder Traversal）：先递归地访问左子树，然后访问当前节点，最后递归地访问右子树。
•后序遍历（Postorder Traversal）：先递归地访问左子树和右子树，然后访问当前节点。
3. 树算法题目分类
LeetCode上的树算法题目可以分为以下几个类别：
3.1 根到叶子节点路径问题
这类问题要求从根节点到叶子节点的路径上找出满足某种条件的路径。
通常使用深度优先搜索（DFS）来解决。
例题：路径总和（Path Sum）
给定一个二叉树和一个目标值，判断是否存在从根节点到叶子节点的路径上的节点值之和等于目标值。
解题思路： - 使用深度优先搜索遍历二叉树。
- 对于每个遍历到的节点，将目标值减去当前节点的值，并继续递归遍历左子树和右子树。
- 如果当前节点是叶子节点，并且目标值等于0，则找到了满足条件的路径。
时间复杂度分析： - 深度优先搜索需要遍历每个节点，时间复杂度为O(n)。
- 在最坏情况下，树为链表状，递归调用会达到O(n)次。
- 因此，总的时间复杂度为O(n^2)。
3.2 两个树之间的比较问题
这类问题要求比较两棵树是否相同、是否是对称的等。
通常使用递归来解决。
例题：相同的树（Same Tree）
给定两个二叉树，判断它们是否相同。
相同定义为结构相同且对应节点值相等。
解题思路： - 如果两个二叉树都为空，则认为它们是相同的。
- 如果两个二叉树中有一个为空而另一个不为空，则认为它们是不相同的。
- 如果两个二叉树的根节点值不相等，则认为它们是不相同的。
- 递归地比较两个二叉树的左子树和右子树。
时间复杂度分析： - 递归调用需要遍历每个节点，时间复杂度为O(n)。
- 在最坏情况下，两棵树完全相同，递归调用会达到O(n)次。
- 因此，总的时间复杂度为O(n^2)。
3.3 树的构造问题
这类问题要求构造一棵满足某种条件的树。
通常使用深度优先搜索或广度优先搜索来解决。
例题：从前序与中序遍历序列构造二叉树（Construct Binary Tree from Preorder and Inorder Traversal）
给定一棵二叉树的前序遍历和中序遍历结果，请构造出该二叉树并返回其根节点。
解题思路： - 前序遍历的第一个节点是当前子树的根节点。
- 在中序遍历中找到该节点，将数组分成左子树和右子树两部分。
- 分别对左右子数组进行递归调用，得到左子树和右子树的根节点，并将其连接到当前节点上。
时间复杂度分析： - 在每次递归调用中，需要遍历每个节点，时间复杂度为O(n)。
- 在最坏情况下，树为链表状，递归调用会达到O(n)次。
- 因此，总的时间复杂
度为O(n^2)。
3.4 树的遍历问题
这类问题要求对树进行遍历，并按照某种顺序输出节点的值。
通常使用深度优先搜索或广度优先搜索来解决。
例题：二叉树的前序遍历（Binary Tree Preorder Traversal）
给定一个二叉树，返回它的前序遍历结果。
解题思路： - 使用递归进行前序遍历。
- 先访问当前节点，然后递归地访问左子树和右子树。
时间复杂度分析： - 递归调用需要遍历每个节点，时间复杂度为O(n)。
- 因此，总的时间复杂度为O(n)。
4. 进一步思考
LeetCode上的树算法题目非常多样化，并且往往结合了其他数据结构和算法。
在
解决这些问题时，我们需要灵活运用各种技巧和方法。
以下是一些进一步思考的方向：
4.1 平衡二叉树
平衡二叉树是一种特殊的二叉搜索树，其左右子树的高度差不超过1。
平衡二叉树
的一个重要应用是实现高效的查找和插入操作。
在LeetCode上有一系列与平衡二
叉树相关的问题，如判断一棵树是否是平衡二叉树、将有序数组转换为平衡二叉搜索树等。
4.2 二叉堆
二叉堆是一种特殊的完全二叉树，满足以下性质： - 最大堆：父节点的值大于等
于子节点的值。
- 最小堆：父节点的值小于等于子节点的值。
二叉堆常用来实现优先队列和堆排序。
在LeetCode上有一些与二叉堆相关的问题，如合并K个排序链表、前K个高频元素等。
4.3 字典树
字典树（Trie）是一种特殊的前缀树，常用来存储和搜索字符串。
字典树可以非常高效地完成字符串匹配和前缀匹配操作。
在LeetCode上有一些与字典树相关的问题，如实现Trie、单词搜索II等。
4.4 线段树
线段树（Segment Tree）是一种用于解决区间查询问题的数据结构。
线段树可以高效地完成区间最值查询、区间和查询等操作。
在LeetCode上有一些与线段树相关的问题，如区域和检索 - 数组可修改等。
5. 总结
本文对LeetCode树算法进行了全面总结，包括树的基础知识、常见问题分类和解题思路。
通过学习和练习LeetCode上的树算法题目，我们可以提高对树数据结构和相关算法的理解和应用能力。
同时，通过进一步思考相关领域的知识，我们可以拓宽视野，提高解决问题的能力。
希望本文对读者在学习LeetCode树算法方面有所帮助。