Leetcode

/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if(root == null || root == p || root == q) return root; TreeNode left = lowestCommonAncestor(root.left, p, q); TreeNode right = lowestCommonAncestor(root.right, p, q); if(left == null) return right; if(right == null) return left; return root; }}

递归 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean isSymmetric(TreeNode root) { return check(root, root); } public boolean check(TreeNode a, TreeNode b) { if(a == null && b == null) { return true; } if(a == null || b == null) { return false; } return a.val == b.val && check(a.left, b.right) && check(a.right, b.left); }}迭代 ...

原文：https://gobea.cn/blog/detail/g6kb2no7.html 给你一棵所有节点为非负值的二叉搜寻树，请你计算树中任意两节点的差的绝对值的最小值。 示例： 输出： 1 \ 3 / 2输入：1 解释：最小相对差为 1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。 提醒： 树中至多有 2 个节点。本题与 783 https://leetcode-cn.com/probl... 雷同思路与算法思考对升序数组 aa 求任意两个元素之差的绝对值的最小值，答案肯定为相邻两个元素之差的最小值，即 其中 nn 为数组 aa 的长度。其余任意距离间隔大于等于 22 的下标对 (i,j)(i,j) 的元素之差肯定大于下标对 (i,i+1)(i,i+1) 的元素之差，故不须要再被思考。 回到本题，本题要求二叉搜寻树任意两节点差的绝对值的最小值，而咱们晓得二叉搜寻树有个性质为二叉搜寻树中序遍历失去的值序列是递增有序的，因而咱们只有失去中序遍历后的值序列即能用上文提及的办法来解决。 奢侈的办法是通过一次中序遍历将值保留在一个数组中再进行遍历求解，咱们也能够在中序遍历的过程中用 pre 变量保留前驱节点的值，这样即能边遍历边更新答案，不再须要显式创立数组来保留，须要留神的是 pre 的初始值须要设置成任意正数标记结尾，下文代码中设置为 −1。 二叉树的中序遍历有多种形式，包含递归、栈、Morris 遍历等，读者可抉择本人最善于的来实现。下文代码提供最广泛的递归办法来实现，其余遍历办法的介绍能够具体看「94. 二叉树的中序遍历」的题解，这里不再赘述。 func getMinimumDifference(root *TreeNode) int { ans, pre := math.MaxInt64, -1 var dfs func(*TreeNode) dfs = func(node *TreeNode) { if node == nil { return } dfs(node.Left) if pre != -1 && node.Val-pre < ans { ans = node.Val - pre } pre = node.Val dfs(node.Right) } dfs(root) return ans}复杂度剖析工夫复杂度：O(n)，其中 nn 为二叉搜寻树节点的个数。每个节点在中序遍历中都会被拜访一次且只会被拜访一次，因而总工夫复杂度为 O(n)。 ...

class Solution { public int[] countBits(int num) { int[] dp = new int[num+1]; dp[0] = 0; for(int i = 1; i <= num; i++) { dp[i] = dp[i/2] + i%2; } return dp; }}

原文链接：何晓东 博客 剑指 Offer 57 - II. 和为s的间断负数序列输出一个正整数 target ，输入所有和为 target 的间断正整数序列（至多含有两个数）。 序列内的数字由小到大排列，不同序列依照首个数字从小到大排列。 示例 1： 输出：target = 9输入：[[2,3,4],[4,5]]示例 2： 输出：target = 15输入：[[1,2,3,4,5],[4,5,6],[7,8]]限度： 1 <= target <= 10^5 起源：力扣（LeetCode）链接：https://leetcode-cn.com/probl... 解题思路经典滑动窗口，间接限度最多滑到一半，能省很多计算。 代码实现： class Solution { /** * @param Integer $target * @return Integer[][] */ function findContinuousSequence($target) { $i = 1; $j = 2; $result = []; # 滑动窗口的右边界不能超过 target 的中值 while ($j <= $target / 2 + 1) { # 计算以后窗口内数字之和 $curSum = array_sum(range($i, $j + 1)); # 若和小于指标，右指针向右挪动，扩充窗口 if ($curSum < $target) { $j++; # 若和大于指标，左指针向右挪动，减小窗口 } elseif ($curSum > $target) { $i++; } # 相等就把指针造成的窗口增加进输入列表中 # 别忘了，这里还要持续扩充寻找下一个可能的窗口 else { $result[] = range($i, $j + 1); # 这里用j+=1，i+=1，i+=2都能够的 $j++; } } return $result; }}剑指 Offer 42. 间断子数组的最大和输出一个整型数组，数组中的一个或间断多个整数组成一个子数组。求所有子数组的和的最大值。 ...

力扣 APP 全新改版，史诗级加强！ 这次的改版真的是判若两人，PC 端的简直所有性能都能够在新版 APP 中看到，并且体验更好。 不仅之前令我不爽的中央全副不见了，而且多了一些我想都没想到的好用性能。 比方摇一摇性能。 我拿到了体验版第一工夫就给大家写了这篇体验报告。上面，西法就带你看看全新版本都有啥。 每日一题 & 举荐题库这可能是大家最关注的一个性能了。我想看一个每日一题还必须去 PC 端能力看到，这就不不便了。 新榜的 APP 间接就能够在题库标签的顶部看到。 除了每日一题， 新榜的 APP 还把其余题库一起装进来了。比方大家相熟的《剑指 Offer》 和 《程序员面试金典》。 代码展现之前 APP 代码真的不是给人看的，还会换行，所以我个别都只能是复制进去到别的中央看。 前面力扣对代码进行了优化， 使得代码不换行，而是通过左右滑动的形式查看，相比之前体验好了很多。而当初新版 APP 对代码的展现又进行了优化，真的是丝滑般柔顺了，大家看下比照成果。 （旧版成果） （新版成果） 这比照应该很显著了。手动点赞 o(￣ ▽ ￣)ｄ 音讯性能加强相比之前手机 APP 只能是关注的人参加了社区探讨才会收到告诉，写个题解什么的基本就不会承受到告诉。 当初大家能够在明天标签页下间接能看到你关注的所有人的动静。 这才是关注应该有的样子嘛。 小提示：力扣的小伙伴的点下我头像的关注按钮，这样就会第一工夫收到我的动静啦~ 除此之外，告诉性能也对齐 PC 端，对音讯内容进行了分组展现。 其余性能摇一摇切换中英文形容，摇一摇随机一题 学习剖析 下载当初还在灰度内测阶段，内测的话须要填写一份问卷 https://shimo.im/forms/8CDdY3... 。不想填问卷也没关系，正式版也快和大家见面了，等到正式版公布大家就能够去各大 APP Store 中进行下载了。 以上就是本文的全部内容了。大家对此有何认识，欢送给我留言，我有工夫都会一一查看答复。更多算法套路能够拜访我的 LeetCode 题解仓库：https://github.com/azl3979858... 。 目前曾经 38K star 啦。大家也能够关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

No.1 较量中的配对次数 解题思路 模仿过程即可，较简略。 代码展现 class Solution { public int numberOfMatches(int n) { int res = 0; while (n > 1) { res += n / 2; n = (n + 1) / 2; } return res;}} No.2十-二进制数的起码数目 解题思路 取决于最大的数字是多少。 代码展现 class Solution { public int minPartitions(String n) { int res = 0; for (int i = 0; i < n.length(); i++) { res = Math.max(res, n.charAt(i) - '0'); } return res; }}No.3 石子游戏VII ...

LeetCode深度优先算法之树(门路相干)树的问题个别都能够由深度优先算法和广度优先算法解决，门路相干的问题个别都能够用DFS或者基于DFS实现的回溯算法实现，咱们通过上面几道题来温习&训练DFS和回溯算法。 112.门路总和形容给定一个二叉树和一个指标和，判断该树中是否存在根节点到叶子节点的门路，这条门路上所有节点值相加等于指标和。 阐明: 叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及指标和 sum = 22， 5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1返回 true, 因为存在指标和为 22 的根节点到叶子节点的门路 5->4->11->2。 思路首先，题目形容的是存在从根节点到叶子节点的门路，也就是须要先确定什么状况下遍历到了叶子节点了。依据题目形容，叶子节点指的是没有左右节点的节点。 if (node.left == null && node.right == null)sum的和与其判断的是节点的总和，所以这是一个累加的和。咱们须要记录每个节点的和，先记录后遍历子节点，这种场景就是dfs典型的场景。 addVal();recursion();dfs能够应用递归进行实现，目前曾经确定了能够应用dfs进行解决，递归的完结的条件是节点为null或者以后节点的左右节点为null。还有一个问题，咱们如何确定以后叶子节点累加的值等于目标值呢？ if sum == node1.val + node2.val + node3.val;then node3.val = sum - node2.val - node1.val; 所以咱们把子节点的目标值设置为sum - curNode.val,如果curNode.val = target的话，就代表存在一条从根节点到子节点的门路和等于目标值。 代码class Solution { public boolean hasPathSum(TreeNode root, int sum) { if (root == null) return false; if (root.left == null && root.right == null) return sum == root.val; return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val); }}113.门路总和II题目形容给定一个二叉树和一个指标和，找到所有从根节点到叶子节点门路总和等于给定指标和的门路。 ...

原文链接： 何晓东 博客 在排序数组中查找元素的第一个和最初一个地位给定一个依照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始地位和完结地位。 如果数组中不存在目标值 target，返回 [-1, -1]。 进阶： 你能够设计并实现工夫复杂度为 O(log n) 的算法解决此问题吗？  示例 1： 输出：nums = [5,7,7,8,8,10], target = 8输入：[3,4]示例 2： 输出：nums = [5,7,7,8,8,10], target = 6输入：[-1,-1]示例 3： 输出：nums = [], target = 0输入：[-1,-1]提醒： 0 <= nums.length <= 105-109 <= nums[i] <= 109nums 是一个非递加数组-109 <= target <= 109起源：力扣（LeetCode）链接：https://leetcode-cn.com/probl...著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。 解题思路 1暴力查找加解决非凡后果 class Solution { /** * @param Integer[] $nums * @param Integer $target * @return Integer[] */ function searchRange($nums, $target) { // 设置默认值 $result = [-1, -1]; if (empty($nums)) { return $result; } // 循环 + 暴力赋值 $result $i = 0; foreach ($nums as $key => $num) { if ($num == $target) { if ($i == 0) { $result[0] = $key; } else { $result[1] = $key; } $i++; } } // 兼容只呈现一次的状况 if ($result[0] !== -1 && $result[1] == -1) { return [$result[0], $result[0]]; } return $result; }}解题思路 2利用二分法思路，先利用二分法找到合乎 target 的值，再别离用二分法求 target 起始的地位和完结的地位。 ...

序本文次要钻研一下leetcode之交易股票的最佳时机 题目给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。如果你最多只容许实现一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。留神：你不能在买入股票前卖出股票。 示例 1:输出: [7,1,5,3,6,4]输入: 5解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 留神利润不能是 7-1 = 6, 因为卖出价格须要大于买入价格；同时，你不能在买入前卖出股票。示例 2:输出: [7,6,4,3,1]输入: 0解释: 在这种状况下, 没有交易实现, 所以最大利润为 0。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int maxProfit(int[] prices) { if(prices.length <= 1) { return 0; } int min = prices[0]; int max = 0; for(int i = 1; i < prices.length; i++) { max = Math.max(max, prices[i] - min); min = Math.min(min, prices[i]); } return max; }}小结这里用第一天的价格作为最小值，以0作为最大值，而后从第二天开始遍历，计算每天最大获利及股票的最小值，最初得出最大收益。 ...

序本文次要钻研一下leetcode之第三大的数 题目给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法工夫复杂度必须是O(n)。示例 1:输出: [3, 2, 1]输入: 1解释: 第三大的数是 1.示例 2:输出: [1, 2]输入: 2解释: 第三大的数不存在, 所以返回最大的数 2 .示例 3:输出: [2, 2, 3, 1]输入: 1解释: 留神，要求返回第三大的数，是指第三大且惟一呈现的数。存在两个值为2的数，它们都排第二。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/third-maximum-number著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int thirdMax(int[] nums) { int max1 = Integer.MIN_VALUE; int max2 = Integer.MIN_VALUE; int max3 = Integer.MIN_VALUE; int duplicatedCount = 0; for(int num : nums) { if (num == max1 || num == max2 || num == max3) { if (num != Integer.MIN_VALUE) { duplicatedCount++; } continue; } if (num > max1) { max3 = max2; max2 = max1; max1 = num; continue; } if (num > max2) { max3 = max2; max2 = num; continue; } if (num > max3) { max3 = num; } } if ((nums.length < 3) || (max3 == Integer.MIN_VALUE && duplicatedCount != 0)) { return max1; } return max3; }}小结这里顺次保护最大，第二大，第三大的数字，遍历数组判断元素值是否大于最大值或者第二大值或者第三大的值，而后对应更新相应的值。 ...

序本文次要钻研一下leetcode之重新排列数组 题目给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,...,xn,y1,y2,...,yn] 的格局排列。请你将数组按 [x1,y1,x2,y2,...,xn,yn] 格局重新排列，返回重排后的数组。 示例 1：输出：nums = [2,5,1,3,4,7], n = 3输入：[2,3,5,4,1,7] 解释：因为 x1=2, x2=5, x3=1, y1=3, y2=4, y3=7 ，所以答案为 [2,3,5,4,1,7]示例 2：输出：nums = [1,2,3,4,4,3,2,1], n = 4输入：[1,4,2,3,3,2,4,1]示例 3：输出：nums = [1,1,2,2], n = 2输入：[1,2,1,2] 提醒：1 <= n <= 500nums.length == 2n1 <= nums[i] <= 10^3起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/shuffle-the-array著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int[] shuffle(int[] nums, int n) { int[] result = new int[nums.length]; for(int i = 0,j = 0; i<nums.length-1; i+=2,j++){ result[i] = nums[j]; result[i+1] = nums[n+j]; } return result; }}小结这里应用双指针，两个指针都从0开始，一个每次加2，一个每次加1，每次遍历给i及i+1赋值。 ...

序本文次要记录一下leetcode之失落的数字 题目给定一个蕴含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范畴内没有呈现在数组中的那个数。 进阶：你是否实现线性工夫复杂度、仅应用额定常数空间的算法解决此问题? 示例 1：输出：nums = [3,0,1]输入：2解释：n = 3，因为有 3 个数字，所以所有的数字都在范畴 [0,3] 内。2 是失落的数字，因为它没有呈现在 nums 中。示例 2：输出：nums = [0,1]输入：2解释：n = 2，因为有 2 个数字，所以所有的数字都在范畴 [0,2] 内。2 是失落的数字，因为它没有呈现在 nums 中。示例 3：输出：nums = [9,6,4,2,3,5,7,0,1]输入：8解释：n = 9，因为有 9 个数字，所以所有的数字都在范畴 [0,9] 内。8 是失落的数字，因为它没有呈现在 nums 中。示例 4：输出：nums = [0]输入：1解释：n = 1，因为有 1 个数字，所以所有的数字都在范畴 [0,1] 内。1 是失落的数字，因为它没有呈现在 nums 中。 提醒：n == nums.length1 <= n <= 1040 <= nums[i] <= nnums 中的所有数字都 举世无双起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/missing-number著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int missingNumber(int[] nums) { int result = nums.length; for (int i = 0; i < nums.length; ++i){ result ^= nums[i]; result ^= i; } return result; }}小结这里利用nums中的所有数字都举世无双这个条件，应用异或运算来对数组index及值进行运算，遍历完得出的后果就是失落的数字。 ...

序本文次要记录一下leetcode之少数元素 题目给定一个大小为 n 的数组，找到其中的少数元素。少数元素是指在数组中呈现次数大于 ⌊ n/2 ⌋ 的元素。你能够假如数组是非空的，并且给定的数组总是存在少数元素。 示例 1:输出: [3,2,3]输入: 3示例 2:输出: [2,2,1,1,1,2,2]输入: 2起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/majority-element著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int majorityElement(int[] nums) { int vote = 0; int result = nums[0]; for (int num : nums) { if (vote <= 0) { result = num; } vote = vote + (result == num ? 1 : -1); } return result; }}小结这里采纳投票法来解题，遍历数组，若vote小于等于0则给以后计数对象从新赋值，之后判断以后值是否为计数对象，是的话投票数加1，否则减1，遍历完即失去后果。 doc少数元素

序本文次要记录一下leetcode之复写零 题目给你一个长度固定的整数数组 arr，请你将该数组中呈现的每个零都复写一遍，并将其余的元素向右平移。留神：请不要在超过该数组长度的地位写入元素。要求：请对输出的数组 就地 进行上述批改，不要从函数返回任何货色。 示例 1：输出：[1,0,2,3,0,4,5,0]输入：null解释：调用函数后，输出的数组将被批改为：[1,0,0,2,3,0,0,4]示例 2：输出：[1,2,3]输入：null解释：调用函数后，输出的数组将被批改为：[1,2,3] 提醒：1 <= arr.length <= 100000 <= arr[i] <= 9起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/duplicate-zeros著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public void duplicateZeros(int[] arr) { int count = 0; for (int i = 0; i < arr.length; i++) { count += arr[i] == 0 ? 1 : 0; } for(int i=arr.length-1; i>=0; i--) { if(arr[i] == 0){ count--; } if(i + count < arr.length){ arr[i + count] = arr[i]; if(arr[i] == 0 && i + count + 1 < arr.length){ arr[i + count + 1] = 0; } } } }}小结这里遍历数组，计算值为0的个数count，而后从后遍历数据，遇到0就递加该值，而后判断i + count是否超出数组长度，没有的话则将i的值设置到i + count，紧接着再以后地位值为0且i + count + 1不超出数组长度的时候将i + count + 1的值设置为0。 ...

序本文次要记录一下leetcode之挪动零 题目给定一个数组 nums，编写一个函数将所有 0 挪动到数组的开端，同时放弃非零元素的绝对程序。示例:输出: [0,1,0,3,12]输入: [1,3,12,0,0]阐明:必须在原数组上操作，不能拷贝额定的数组。尽量减少操作次数。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/move-zeroes著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public void moveZeroes(int[] nums) { if (nums == null || nums.length <= 1) { return; } int idx = 0; for(int i=0; i<nums.length; i++) { if (nums[i] != 0) { nums[idx] = nums[i]; idx++; } } for (int i = idx; i < nums.length; i++) { nums[i] = 0; } }}小结这里遍历数组，保护一个下标，当值不为0时则进行挪动同时递增下标，遍历完一次之后，在从该下标起往后遍历，赋值为0。 doc挪动零

序本文次要记录一下leetcode之最小相对差 题目给你个整数数组 arr，其中每个元素都 不雷同。请你找到所有具备最小相对差的元素对，并且按升序的程序返回。 示例 1：输出：arr = [4,2,1,3]输入：[[1,2],[2,3],[3,4]]示例 2：输出：arr = [1,3,6,10,15]输入：[[1,3]]示例 3：输出：arr = [3,8,-10,23,19,-4,-14,27]输入：[[-14,-10],[19,23],[23,27]] 提醒：2 <= arr.length <= 10^5-10^6 <= arr[i] <= 10^6起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/minimum-absolute-difference著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public List<List<Integer>> minimumAbsDifference(int[] arr) { Arrays.sort(arr); int delta = Integer.MAX_VALUE; int tmp; List<List<Integer>> result = new ArrayList<>(); for (int i=1; i<arr.length; i++) { tmp = Math.abs(arr[i] - arr[i-1]); if (tmp < delta) { result.clear(); result.add(Arrays.asList(arr[i-1],arr[i])); delta = tmp; continue; } if (tmp == delta) { result.add(Arrays.asList(arr[i-1],arr[i])); } } return result; }}小结这里先对数组进行排序，而后遍历数据判断前后差的绝对值，看是否比存储的相对差小，若小则状况后果集，更新最小相对差；若等于则追加该记录到后果集。 ...

序本文次要记录一下leetcode之判断是否造成等差数列 题目给你一个数字数组 arr 。如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。如果能够重新排列数组造成等差数列，请返回 true ；否则，返回 false 。 示例 1：输出：arr = [3,5,1]输入：true解释：对数组从新排序失去 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差别离为 2 或 -2 ，能够造成等差数列。示例 2：输出：arr = [1,2,4]输入：false解释：无奈通过从新排序失去等差数列。 提醒：2 <= arr.length <= 1000-10^6 <= arr[i] <= 10^6起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/can-make-arithmetic-progression-from-sequence著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean canMakeArithmeticProgression(int[] arr) { Arrays.sort(arr); int delta = arr[1] - arr[0]; for (int i = 2; i < arr.length; i++) { if (arr[i] - arr[i - 1] != delta) { return false; } } return true; }}小结这里先对数组进行排序，而后遍历数据判断前后差是否相等，不等则立即返回false，遍历完返回true。 ...

No.1设计有序流 解题思路 依照题意编码即可. 代码展现 class OrderedStream { private final String[] strings; private int ptr; public OrderedStream(int n) { strings = new String[n]; ptr = 0; } public List<String> insert(int id, String value) { id--; // 数组下标从 0 开始 strings[id] = value; List<String> res = new ArrayList<>(); for (; ptr < strings.length && strings[ptr] != null; ptr++) { res.add(strings[ptr]); } return res; }}No.2确定两个字符串是否靠近 解题思路 解读、剖析失去两个字符串靠近的条件: 字符集雷同每种字符呈现的次数形成的序列雷同代码展现 class Solution { public boolean closeStrings(String word1, String word2) { int[] cnt1 = new int[26]; for (int i = 0; i < word1.length(); i++) { cnt1[word1.charAt(i) - 'a']++; } int[] cnt2 = new int[26]; for (int i = 0; i < word2.length(); i++) { cnt2[word2.charAt(i) - 'a']++; } // 字符集雷同 for (int i = 0; i < 26; i++) { // 字符 i 若在 word1 中呈现, 那么在 word2 中也必须呈现 if (cnt1[i] + cnt2[i] != 0 && cnt1[i] * cnt2[i] == 0) { return false; } } // 次数序列雷同 Arrays.sort(cnt1); Arrays.sort(cnt2); for (int i = 0; i < 26; i++) { if (cnt1[i] != cnt2[i]) { return false; } } return true; }}No.3将x减到0的最小操作数 ...

序本文次要记录一下leetcode之移除元素 题目给你一个数组 nums 和一个值 val，你须要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要应用额定的数组空间，你必须仅应用 O(1) 额定空间并 原地 批改输出数组。元素的程序能够扭转。你不须要思考数组中超出新长度前面的元素。 示例 1:给定 nums = [3,2,2,3], val = 3,函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不须要思考数组中超出新长度前面的元素。示例 2:给定 nums = [0,1,2,2,3,0,4,2], val = 2,函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。留神这五个元素可为任意程序。你不须要思考数组中超出新长度前面的元素。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/remove-element著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int removeElement(int[] nums, int val) { if (nums == null || nums.length == 0) { return 0; } int count = 0; for (int i=0; i< nums.length; i++) { if (nums[i] == val) { continue; } nums[count] = nums[i]; count++; } return count; }}小结这里遍历数组，而后保护一个下标，从0开始，每遇到不为val的时候就给赋值给该下标，而后递增下标，最初返回该下标。 ...

序本文次要记录一下leetcode之缀点成线 题目在一个 XY 坐标系中有一些点，咱们用数组 coordinates 来别离记录它们的坐标，其中 coordinates[i] = [x, y] 示意横坐标为 x、纵坐标为 y 的点。请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。示例 1：输出：coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]输入：true示例 2：输出：coordinates = [[1,1],[2,2],[3,4],[4,5],[5,6],[7,7]]输入：false 提醒：2 <= coordinates.length <= 1000coordinates[i].length == 2-10^4 <= coordinates[i][0], coordinates[i][1] <= 10^4coordinates 中不含反复的点起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/check-if-it-is-a-straight-line著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean checkStraightLine(int[][] coordinates) { if (coordinates.length == 2) { return true; } int x1 = coordinates[0][0]; int y1 = coordinates[0][1]; int x2 = coordinates[1][0]; int y2 = coordinates[1][1]; for(int i=2; i< coordinates.length; i++) { int x = coordinates[i][0]; int y = coordinates[i][1]; if ((x-x1)*(y2-y1) != (y-y1)*(x2-x1)) { return false; } } return true; }}小结这里利用斜率公式来判断两个坐标是否在同一直线上。 ...

序本文次要记录一下leetcode之斐波那契数 题目斐波那契数，通常用 F(n) 示意，造成的序列称为斐波那契数列。该数列由 0 和 1 开始，前面的每一项数字都是后面两项数字的和。也就是：F(0) = 0,   F(1) = 1F(N) = F(N - 1) + F(N - 2), 其中 N > 1.给定 N，计算 F(N)。 示例 1：输出：2输入：1解释：F(2) = F(1) + F(0) = 1 + 0 = 1.示例 2：输出：3输入：2解释：F(3) = F(2) + F(1) = 1 + 1 = 2.示例 3：输出：4输入：3解释：F(4) = F(3) + F(2) = 2 + 1 = 3. 提醒：0 ≤ N ≤ 30起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/fibonacci-number著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int fib(int N) { if(N==0 ||N==1) { return N; } int fn0 = 0; int fn1 = 1; for (int i=2; i<=N; i++) { int tmp = fn0 + fn1; fn0 = fn1; fn1 = tmp; } return fn1; }}小结这里应用公式办法来计算，F(0) = 0, F(1) = 1，在N>1时，F(N) = F(N - 1) + F(N - 2)。 ...

序本文次要记录一下leetcode之第k个缺失的正整数 题目给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。请你找到这个数组里第 k 个缺失的正整数。 示例 1：输出：arr = [2,3,4,7,11], k = 5输入：9解释：缺失的正整数包含 [1,5,6,8,9,10,12,13,...] 。第 5 个缺失的正整数为 9 。示例 2：输出：arr = [1,2,3,4], k = 2输入：6解释：缺失的正整数包含 [5,6,7,...] 。第 2 个缺失的正整数为 6 。 提醒：1 <= arr.length <= 10001 <= arr[i] <= 10001 <= k <= 1000对于所有 1 <= i < j <= arr.length 的 i 和 j 满足 arr[i] < arr[j] 起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/kth-missing-positive-number著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int findKthPositive(int[] arr, int k) { int len = arr.length; for (int i=0; i<len; i++) { if (arr[i] >= k+i+1) { return k+i; } } return k+len; }}小结这里依据严格升序排序的条件来解题，遍历数组，对于数组的值是否大于等于k+i+1(因为i从0开始，这里+1变为第N个的语义)，是的话间接返回k+i，遍历到最初没有提前返回的话，返回k+len。 ...

序本文次要记录一下leetcode之合并两个有序数组 题目给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。 阐明：初始化 nums1 和 nums2 的元素数量别离为 m 和 n 。你能够假如 nums1 有足够的空间（空间大小大于或等于 m + n）来保留 nums2 中的元素。 示例：输出：nums1 = [1,2,3,0,0,0], m = 3nums2 = [2,5,6], n = 3输入：[1,2,2,3,5,6] 提醒：-10^9 <= nums1[i], nums2[i] <= 10^9nums1.length == m + nnums2.length == n起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/merge-sorted-array著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { int cursor = m + n -1; m--; n--; while(m >= 0 && n >= 0) { nums1[cursor] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--]; cursor--; } while(n >= 0) { nums1[cursor] = nums2[n]; n--; cursor--; } }}小结这里从后往前遍历，每次比拟两个数组的值，取大的笼罩到nums1数组，同时挪动对应的index；最初在判断下nums2数组有没有比拟完，没有的话将nums2残余的元素复制到nums1。 ...

序本文次要记录一下leetcode之有序数组的平方 题目给定一个按非递加程序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递加程序排序。 示例 1：输出：[-4,-1,0,3,10]输入：[0,1,9,16,100]示例 2：输出：[-7,-3,2,3,11]输入：[4,9,9,49,121] 提醒：1 <= A.length <= 10000-10000 <= A[i] <= 10000A 已按非递加程序排序。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int[] sortedSquares(int[] A) { int i = 0; int j = A.length - 1; int cursor = A.length - 1; int[] result = new int[A.length]; while (i <= j) { if(A[i] * A[i] > A[j] * A[j]) { result[cursor] = A[i] * A[i]; cursor--; i++; continue; } result[cursor] = A[j] * A[j]; cursor--; j--; } return result; }}小结这里应用双指针，每次比照前后平方之后的数据，大的则将新增赋值给后果集，而后挪动对应的指针及后果集的游标。 ...

序本文次要记录一下leetcode之山羊拉丁文 题目给定一个由空格宰割单词的句子 S。每个单词只蕴含大写或小写字母。咱们要将句子转换为 “Goat Latin”（一种相似于 猪拉丁文 - Pig Latin 的虚构语言）。山羊拉丁文的规定如下：如果单词以元音结尾（a, e, i, o, u），在单词后增加"ma"。例如，单词"apple"变为"applema"。如果单词以辅音字母结尾（即非元音字母），移除第一个字符并将它放到开端，之后再增加"ma"。例如，单词"goat"变为"oatgma"。依据单词在句子中的索引，在单词最初增加与索引雷同数量的字母'a'，索引从1开始。例如，在第一个单词后增加"a"，在第二个单词后增加"aa"，以此类推。返回将 S 转换为山羊拉丁文后的句子。示例 1:输出: "I speak Goat Latin"输入: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"示例 2:输出: "The quick brown fox jumped over the lazy dog"输入: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"阐明:S 中仅蕴含大小写字母和空格。单词间有且仅有一个空格。1 <= S.length <= 150。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/goat-latin著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { Set<Character> set = new HashSet<>(){{ add('a'); add('e'); add('i'); add('o'); add('u'); add('A'); add('E'); add('I'); add('O'); add('U'); }}; public String toGoatLatin(String S) { String[] words = S.split(" "); StringBuilder builder = new StringBuilder(); for(int i=0; i<words.length; i++) { if (set.contains(words[i].charAt(0))){ builder.append(words[i] + "ma"); } else { builder.append(words[i].substring(1) + words[i].charAt(0) + "ma"); } for (int j = 0; j < i + 1; j++) { builder.append('a'); } builder.append(' '); } return builder.toString().trim(); }}小结这里先将字符串按空格宰割为单词，而后遍历每个单词，判断首字母是否为元音，是的话在前面增加ma，不是的话将首字母移到前面再拼接ma，最初再依据单词在句子中的index拼接指定个数的a。 ...

序本文次要记录一下leetcode之最初一个单词的长度 题目给定一个仅蕴含大小写字母和空格 ' ' 的字符串 s，返回其最初一个单词的长度。如果字符串从左向右滚动显示，那么最初一个单词就是最初呈现的单词。如果不存在最初一个单词，请返回 0 。阐明：一个单词是指仅由字母组成、不蕴含任何空格字符的 最大子字符串。 示例:输出: "Hello World"输入: 5起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/length-of-last-word著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int lengthOfLastWord(String s) { int result = 0; char[] chars = s.toCharArray(); for (int i= s.length()-1; i >=0; i--) { if (chars[i] != ' ') { result++; continue; } if (result != 0) { return result; } } return result; }}小结这里从后往前遍历字符串数组，遇到非空格的累加长度，遇到空格则判断后果是否为0，不为0则返回后果。 doc最初一个单词的长度

序本文次要记录一下leetcode之反转字符串中的元音字母 题目编写一个函数，以字符串作为输出，反转该字符串中的元音字母。 示例 1：输出："hello"输入："holle"示例 2：输出："leetcode"输入："leotcede" 提醒：元音字母不蕴含字母 "y" 。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/reverse-vowels-of-a-string著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { Set<Character> set = new HashSet(){{ add('a'); add('e'); add('i'); add('o'); add('u'); add('A'); add('E'); add('I'); add('O'); add('U'); }}; public String reverseVowels(String s) { int i = 0; int j = s.length() - 1; char[] chars = s.toCharArray(); while(i < j) { while (!set.contains(chars[i]) && i<j) { i++; } while (!set.contains(chars[j]) && i<j) { j--; } if (i < j) { char tmp = chars[i]; chars[i] = chars[j]; chars[j] = tmp; i++; j--; } } return new String(chars); }}小结这里先应用HashSet寄存大小写的元音字母，之后应用头尾指针同时对字符串数组进行遍历，当i指向的字符与j指向的字符都是元音时，进行替换同时更新指针，不是元音字符时仅仅更新指针。 ...

序本文次要记录一下leetcode之判断门路是否相交 题目给你一个字符串 path，其中 path[i] 的值能够是 'N'、'S'、'E' 或者 'W'，别离示意向北、向南、向东、向西挪动一个单位。机器人从二维立体上的原点 (0, 0) 处开始登程，按 path 所批示的门路行走。如果门路在任何地位上呈现相交的状况，也就是走到之前曾经走过的地位，请返回 True ；否则，返回 False 。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/path-crossing著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean isPathCrossing(String path) { int x = 0; int y = 0; Set<String> pathSet = new HashSet<String>(); pathSet.add("00"); for (char c : path.toCharArray()) { if (c == 'N') { y++; } else if (c == 'S') { y--; } else if (c == 'W') { x--; } else if (c == 'E') { x++; } String p = String.valueOf(x) + String.valueOf(y); if (pathSet.contains(p)) { return true; } pathSet.add(p); } return false; }}小结这里保护走过的点，而后遍历path的字符，对x,y坐标进行相应挪动，每次挪动之后都判断下该点是否走过，走过则返回true，没有则将改点记录到走过的的点中，遍历完都没有符合条件就返回false。 ...

序本文次要记录一下leetcode之机器人是否返回原点 题目在二维立体上，有一个机器人从原点 (0, 0) 开始。给出它的挪动程序，判断这个机器人在实现挪动后是否在 (0, 0) 处完结。挪动程序由字符串示意。字符 move[i] 示意其第 i 次挪动。机器人的无效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在实现所有动作后返回原点，则返回 true。否则，返回 false。留神：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右挪动一次，“L” 将始终向左挪动等。此外，假如每次移动机器人的挪动幅度雷同。 示例 1:输出: "UD"输入: true解释：机器人向上挪动一次，而后向下挪动一次。所有动作都具备雷同的幅度，因而它最终回到它开始的原点。因而，咱们返回 true。示例 2:输出: "LL"输入: false解释：机器人向左挪动两次。它最终位于原点的左侧，距原点有两次 “挪动” 的间隔。咱们返回 false，因为它在挪动完结时没有返回原点。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/robot-return-to-origin著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean judgeCircle(String moves) { int x = 0; int y = 0; for (char c : moves.toCharArray()) { if (c == 'U') { y++; continue; } if (c == 'D') { y--; continue; } if (c == 'L') { x--; continue; } if (c == 'R') { x++; continue; } } return x == 0 && y == 0; }}小结这里保护x,y坐标的值，针对不同的操作来增减x,y，最初判断x,y是否为0即可。 ...

序本文次要记录一下leetcode之赎金信 题目给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 外面的字符形成。如果能够形成，返回 true ；否则返回 false。(题目阐明：为了不裸露赎金信字迹，要从杂志上搜寻各个须要的字母，组成单词来表白意思。杂志字符串中的每个字符只能在赎金信字符串中应用一次。) 留神：你能够假如两个字符串均只含有小写字母。canConstruct("a", "b") -> falsecanConstruct("aa", "ab") -> falsecanConstruct("aa", "aab") -> true起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/ransom-note著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean canConstruct(String ransomNote, String magazine) { int[] charCount = new int[26]; for(char c : magazine.toCharArray()) { charCount[c-'a'] += 1; } for(char c : ransomNote.toCharArray()) { charCount[c-'a'] -= 1; if (charCount[c-'a'] < 0) { return false; } } return true; }}小结这里保护一个字符呈现次数的数组，而后先统计magazine的字符的呈现次数，而后在遍历ransomNote，每呈现一个字符就将对应的计数减一，一旦发现计数小于0则返回false，否则遍历完返回true。 doc赎金信

序本文次要记录一下leetcode之最常见的单词 题目给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回呈现次数最多，同时不在禁用列表中的单词。题目保障至多有一个词不在禁用列表中，而且答案惟一。禁用列表中的单词用小写字母示意，不含标点符号。段落中的单词不辨别大小写。答案都是小写字母。 示例：输出: paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."banned = ["hit"]输入: "ball"解释: "hit" 呈现了3次，但它是一个禁用的单词。"ball" 呈现了2次 (同时没有其余单词呈现2次)，所以它是段落里呈现次数最多的，且不在禁用列表中的单词。 留神，所有这些单词在段落里不辨别大小写，标点符号须要疏忽（即便是紧挨着单词也疏忽， 比方 "ball,"）， "hit"不是最终的答案，尽管它呈现次数更多，但它在禁用单词列表中。 提醒：1 <= 段落长度 <= 10000 <= 禁用单词个数 <= 1001 <= 禁用单词长度 <= 10答案是惟一的, 且都是小写字母 (即便在 paragraph 里是大写的，即便是一些特定的名词，答案都是小写的。)paragraph 只蕴含字母、空格和下列标点符号!?',;.不存在没有连字符或者带有连字符的单词。单词里只蕴含字母，不会呈现省略号或者其余标点符号。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/most-common-word著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String mostCommonWord(String paragraph, String[] banned) { Set<String> bannedSet = new HashSet<>(); for (String ban : banned) { bannedSet.add(ban); } Map<String,Integer> countMap = new HashMap<>(); String[] words = paragraph.toLowerCase().replaceAll("[^a-z]"," ").split("\\s+"); for (String word : words) { if (bannedSet.contains(word)) { continue; } countMap.put(word, countMap.getOrDefault(word, 0) + 1); } int max = 0; String result = ""; for (Map.Entry<String,Integer> entry : countMap.entrySet()) { if (max < entry.getValue()) { max = entry.getValue(); result = entry.getKey(); } } return result; }}小结这里应用Map来统计单词，并应用Set来查问是否为禁用词，若为禁用词则不退出Map中统计，最初遍历Map取出计数最大的单词。 ...

题目链接4. 寻找两个正序数组的中位数 难度：hard 有点相似TopK问题,只是这里是有有序的，二分找到中位数即可。 解法1.合并排序暴力解法，略过不提 2.二分求中位数将两个数组切割，假如A数组长度为m，切割地位为i，B数组长度为n，切割地位为j，则有： 左半局部的长度等于右半局部，即：i + j = m - i + n - j , 也就是 j = ( m + n ) / 2 - i（当 A 数组和 B 数组的总长度是奇数时，j = ( m + n + 1) / 2 - i）因为向下取整，故而j = ( m + n ) / 2 - i和j = ( m + n + 1) / 2 - i后果是统一的此时，只有满足max ( A [ i - 1 ] , B [ j - 1 ]）） <= min ( A [ i ] , B [ j ]））即找到了中位数复杂度剖析工夫复杂度：O(min(m,n))，其中 m,n 为两个数组的长度。咱们对长度较短的数组进行二分。空间复杂度：O(1)。以下为PHP语言实现~~~~ ...

java程序猿转go语言，通过leetcode刷题来相熟go语言，实现语言根底和语法根底的相熟 1.两数之和暴力破解: func twoSum(nums []int, target int) []int { for i := 0; i < len(nums) - 1; i++ { for j := i + 1; j < len(nums); j++ { if (nums[j] + nums[i] == target) { return []int {i, j}; } } } return nil}哈希表： func twoSum(nums []int, target int) []int { hashmap := make(map[int] int) for index, value := range nums { if v, ok := hashmap[value]; ok { return []int{index, v} } hashmap[target - value] = index } return nil}2.两数相加递归版本（链表或者树的问题都要尽量想一个递归的） ...

序本文次要记录一下leetcode之断定是否互为字符重排 题目给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，是否变成另一个字符串。示例 1：输出: s1 = "abc", s2 = "bca"输入: true 示例 2：输出: s1 = "abc", s2 = "bad"输入: false阐明： 0 <= len(s1) <= 100 0 <= len(s2) <= 100 起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/check-permutation-lcci著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean CheckPermutation(String s1, String s2) { if(s1.length() != s2.length()) { return false; } int len = 'z' + 1; int[] idx1 = new int[len]; int[] idx2 = new int[len]; for(int i=0; i<s1.length(); i++){ idx1[s1.charAt(i)] = idx1[s1.charAt(i)] + 1; idx2[s2.charAt(i)] = idx2[s2.charAt(i)] + 1; } for(int i=0; i<len; i++){ if (idx1[i] != idx2[i]) { return false; } } return true; }}小结这里别离保护两个字符串的字符的个数，而后遍历下判断每个字符的个数是否相等。 ...

题目：给定一个整数数组 A，如果它是无效的山脉数组就返回 true，否则返回 false。 让咱们回顾一下，如果 A 满足下述条件，那么它是一个山脉数组： A.length >= 3在 0 < i < A.length - 1 条件下，存在 i 使得：A[0] < A[1] < ... A[i-1] < A[i]A[i] > A[i+1] > ... > A[A.length - 1] 思路：首先想到应该是一个线性的解法，也就是先从左往右寻找第一个山峰，再从右往左寻找如果两个山峰是同一个即正确，否则谬误。须要判断几个边界状况，首先是数组有余3，还有山峰再0和len（A）-1三种非凡不满足的状况。 func validMountainArray(A []int) bool { if len(A)<3{ return false } end := len(A)-1 start := 0 for ; start+1 < len(A) && A[start] < A[start+1]; start++ { } for ;A[end]<A[end-1] && end-1 >= 0;end--{} if start==0 || start == len(A)-1{ return false } if start == end {return true} return false} ...

D132 7. Reverse Integer题目链接7. Reverse Integer 题目剖析这个题目比较简单，就是给你一个-2^31~2^31-1的数字，要你翻转过去。若超出这个范畴，须要返回0。 解题思路比较简单的办法是用strrev函数翻转，也能够用for循环翻转，但要留神符号。 先用是否小于0来判断有没有符号。有的话，须要把第一个元素用array\_shift函数弹出来。或者对给定的数字乘以-1也是一个方法。 接下来把数字用str\_split函数转换成数组，因为咱们只须要把数字的前半部分和后半局部对调，所以for的终止条件只有到一半就好了。 最初，要判断是否大于给定的区间。这里要留神，不能用PHP的内置常量PHP\_INT\_MAX和PHP\_INT\_MIN。因为这个是依据以后机器的位数决定的。如果是64位的处理器，它必定是会大于32位的。 在这里咱们间接算出这个数字，作为类常量存储。判断翻转后的后果是否超出范围，超出则返回0即可。 最终代码<?phpclass Solution { /** * @param Integer $x * @return Integer */ const MAX = 2147483647; const MIN = -2147483648; function reverse($x) { $x_arr = str_split($x); $symbol = 1; if($x < 0){ $symbol = -1; array_shift($x_arr); } $len = count($x_arr); for($i = 0; $i< $len / 2; $i++){ $temp = $x_arr[$i]; $x_arr[$i] = $x_arr[$len-$i-1]; $x_arr[$len-$i-1] = $temp; } $final = $symbol * implode($x_arr); if($final < self::MIN || $final >= self::MAX){ return 0; } return $final; }}若感觉本文章对你有用，欢送用爱发电赞助。 ...

题目：给定两个数组，编写一个函数来计算它们的交加。 思路：零个数组的交加次要问题集中在如何查找另一数组中的元素，我这里首先想到的是hash表查找的办法，因为这样能够在常熟工夫内查问到。思路上并没有什么难点，代码如下： func intersection(nums1 []int, nums2 []int) []int { hSection := make(map[int]int,0) ans := make([]int,0) for _,val:= range nums1{ hSection[val]=val } for _,val := range nums2{ _,ok :=hSection[val] if ok{ ans = append(ans,val) delete(hSection,val) } } return ans}

将一个给定字符串依据给定的行数，以从上往下、从左到右进行 Z 字形排列。 比方输出字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下： L C I RE T O E S I I GE D H N之后，你的输入须要从左往右逐行读取，产生出一个新的字符串，比方："LCIRETOESIIGEDHN"。思路：这道题实际上就是实现字符串的蛇形排列，达到了最大行数之后，就须要折头。所以对每行设置一个byte类型的数组，设置变量a实现达到n行后的转换，判断条件为减少了n-1次。因为第一次i=0也能被n-1整除，也会产生一次a的变换，所以设置a的值为-1.tip:因为判断为n-1次的整除，如果numRows为1会呈现除0的状况，并且numRows=1不须要进行变换，所以一开始须要进行判断。 func convert(s string, numRows int) string { if(numRows == 1){ return s } chars := make([][]byte,numRows) ans := make([]byte,0) n := len(s) j := 0 a := -1 for i :=0;i<n;i++{ chars[j] = append(chars[j],s[i]) if(i % (numRows-1) == 0){ a = -a } j =j+a } for i:=0;i<numRows;i++{ ans = append(ans,chars[i]...) } return string(ans)}运行后果如下： ...

题目：给定一个字符串 s，找到 s 中最长的回文子串。你能够假如 s 的最大长度为 1000。 思路：看到这道题目，首先想到回文字符串，是一个沿正中字符串对称的字符串，一个字符串如果时回文字符串，去除两端的字符串也必为回文字符串，由此设两头的字符串为子状态，应该能够用动静布局的形式求解。这里设置贮存状态的数组为dpi,为字符串（i~j）子串是否为回文字符串。编程思路如下：具体代码如下所示：定义了一个paliInfo构造体，用于贮存最长子串的信息。相比起光放给出的算法删除了对于j>i局部的循环。理论的运行后果中，也体现出了这一点，比起官网的节俭了差不多一半的工夫，和空间。官网动静布局运行后果集体的动静布局后果 type paliInfo struct { size int start int end int}func longestPalindrome(s string) string{ //1.设定数组保留回文字符串信息 n := len(s) dp := make([][]bool,n) for k := 0;k<n;k++{ dp[k] = make ([]bool,n) } var ans paliInfo //2.如果一个字符串中i~j为回文字符串，则（i+1）~（j-1）为回文字符串 //3.第一个字符和第二个字符的回文字符串不能够用此判断,设置初始值 for i:=0;i<n;i++{ dp[i][i] = true } ans.size = 1 ans.start = 0 ans.end = 0 for i := 0;i<n;i++{ for j := i-1;j>=0;j--{ if i-j == 1{ if s[i] == s[j]{ dp[j][i] = true if i-j+1>ans.size{ ans.start = j ans.end = i ans.size =i-j+1 } } else { dp[j][i]=false } } if i-j >1{ if dp[j+1][i-1]&&s[i]==s[j]{ dp[j][i]=true if i-j+1>ans.size{ ans.start = j ans.end = i ans.size =i-j+1 } }else { dp[j][i]=false } } } } return s[ans.start:ans.end+1]}

序本文次要记录一下leetcode之二进制求和 题目给你两个二进制字符串，返回它们的和（用二进制示意）。输出为 非空 字符串且只蕴含数字 1 和 0。 示例 1:输出: a = "11", b = "1"输入: "100"示例 2:输出: a = "1010", b = "1011"输入: "10101" 提醒：每个字符串仅由字符 '0' 或 '1' 组成。1 <= a.length, b.length <= 10^4字符串如果不是 "0" ，就都不含前导零。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/add-binary著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String addBinary(String a, String b) { StringBuilder builder = new StringBuilder(); int i = a.length() - 1; int j = b.length() - 1; int sum = 0; while(i >= 0 || j >= 0) { if(i >= 0) { sum += a.charAt(i) - '0'; i--; } if(j >= 0) { sum += b.charAt(j) - '0'; j--; } builder.append(sum % 2); sum = sum/2; } String result = builder.reverse().toString(); return sum > 0 ? '1' + result : result; }}小结这里对两个字符串从后开始遍历，而后进行累加，对2取余数增加到后果集，而后对2取模，持续循环，最初将后果反转一下，最初再判断一下sum是否大于0，大于0的话，再补下前缀1。 ...

题目：设计一个反对 push ，pop ，top 操作，并能在常数工夫内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。pop() —— 删除栈顶的元素。top() —— 获取栈顶元素。getMin() —— 检索栈中的最小元素。 思路:栈相干的进栈、出栈的操作不在赘述，这道题目的次要问题出在了在常数工夫内查问栈内最小数，这里采纳辅助栈的形式，每次压栈是，除了把须要压入的数压入贮存栈的同时，将以后最小数比拟后压入最小栈。出栈时也同时删除两栈的栈顶元素。一下为代码实现。 type MinStack struct {stack []intminStack []int}func Constructor() MinStack { return MinStack{ stack: []int{}, minStack: []int{}, }}func (this *MinStack) Push(x int) { this.stack = append(this.stack,x) if len(this.minStack) != 0{ minNum := min(x,this.minStack[len(this.minStack)-1]) this.minStack = append(this.minStack,minNum) }else{ this.minStack = append(this.minStack,x) } return}func (this *MinStack) Pop()(x int){ x = this.stack[len(this.stack)-1] this.minStack = append(this.minStack[:len(this.minStack)-1]) this.stack = append(this.stack[:len(this.stack)-1]) return}func (this *MinStack) Top() int { return this.stack[len(this.stack)-1]}func (this *MinStack) GetMin() int { return this.minStack[len(this.minStack)-1]}func min(x, y int) int {if x < y {return x}return y} ...

序本文次要记录一下leetcode之转变日期格局 题目给你一个字符串 date ，它的格局为 Day Month Year ，其中：Day 是汇合 {"1st", "2nd", "3rd", "4th", ..., "30th", "31st"} 中的一个元素。Month 是汇合 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"} 中的一个元素。Year 的范畴在 [1900, 2100] 之间。请你将字符串转变为 YYYY-MM-DD 的格局，其中：YYYY 示意 4 位的年份。MM 示意 2 位的月份。DD 示意 2 位的天数。 示例 1：输出：date = "20th Oct 2052"输入："2052-10-20"示例 2：输出：date = "6th Jun 1933"输入："1933-06-06"示例 3：输出：date = "26th May 1960"输入："1960-05-26" 提醒：给定日期保障是非法的，所以不须要解决异样输出。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/reformat-date著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { Map<String, String> monthMap = new HashMap<>(){{ put("Jan", "01"); put("Feb", "02"); put("Mar", "03"); put("Apr", "04"); put("May", "05"); put("Jun", "06"); put("Jul", "07"); put("Aug", "08"); put("Sep", "09"); put("Oct", "10"); put("Nov", "11"); put("Dec", "12"); }}; public String reformatDate(String date) { String[] dates = date.split(" "); String month = monthMap.get(dates[1]); String year = dates[2]; String day = dates[0].substring(0,dates[0].length()-2); if (day.length() == 1) { day = "0"+ day; } return year+"-"+month+"-"+day; }}小结这里应用HashMap来映射英文的month，而后针对日期移除后缀，最初针对天有余两位的往前补零，最初拼接为指定的格局。 ...

D131 746. Min Cost Climbing Stairs题目链接746. Min Cost Climbing Stairs 题目剖析给定一个数组，每走一步须要消耗肯定代价。每次能够走1步或2步。寻找走到底所须要的起码步数。 解题思路一开始想到的是用底杰斯特拉\(Dijkstra\)算法。 然而底杰斯特拉应用的是以后最优，因而，如果前面所须要的步数比拟小，这个算法就不实用了。 其次想到的是递归的办法。 每走一步都尝试两种，即一步和两步。对一些短的数组能顺利执行，然而，提交代码后呈现了Time exceed的谬误。在本地调试之后呈现了“嵌套层数达到最高层256层”，嵌套层数过多的谬误。 于是开始剖析有没有更优的算法。 通过剖析发现，后面的步骤和前面的步骤并没有太大的关系。能够把后面走过的步数，加起来造成新的数组，最初剩下两个元素中最小的那个便是起码步数。 最终代码<?phpclass Solution { /** * @param Integer[] $cost * @return Integer */ protected $minimumCost = PHP_INT_MAX; function minCostClimbingStairs($cost) { $costBySteps = []; foreach($cost as $key => $value){ if($key<2){ continue; } $cost[$key] += min($cost[$key-1], $cost[$key-2]); } $amount = count($cost); return min($cost[$amount-1], $cost[$amount-2]); }}若感觉本文章对你有用，欢送用爱发电赞助。

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。 进阶：你能设计一个工夫复杂度为 O(log (m+n)) 的算法解决此问题吗？ 思路：看到这道题的第一个思路是应用相似归并排序的形式，将两个数组合并成一个有序数组，在对这个有序数组求中位数。 func findMedianSortedArrays(nums1 []int, nums2 []int) float64 { nums := newNums(nums1, nums2) if len(nums)%2 == 1 { return float64(nums[len(nums)/2]) } else { return float64(nums[len(nums)/2]+nums[len(nums)/2-1]) / 2.0 }}func newNums(nums1, nums2 []int) []int { newnums := make([]int, len(nums1)+len(nums2)) for i, j, k := 0, 0, 0; i < len(nums1) || j < len(nums2); k++ { //如果有一个数组被读取完，则将另一个数组剩下的数字退出新创建数组的开端 if i == len(nums1) { for ; j < len(nums2); j, k = j+1, k+1 { newnums[k] = nums2[j] } return newnums } if j == len(nums2) { for ; i < len(nums1); i, k = i+1, k+1 { newnums[k] = nums1[i] } return newnums } //比拟两个数组将较小的退出新数组当中，并将指针的后移 if nums1[i] < nums2[j] { newnums[k] = nums1[i] i++ } else { newnums[k] = nums2[j] j++ } } return newnums} ...

序本文次要记录一下leetcode之字符串相加 题目给定两个字符串模式的非负整数 num1 和num2 ，计算它们的和。 提醒：num1 和num2 的长度都小于 5100num1 和num2 都只蕴含数字 0-9num1 和num2 都不蕴含任何前导零你不能应用任何內建 BigInteger 库， 也不能间接将输出的字符串转换为整数模式起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/add-strings著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String addStrings(String num1, String num2) { StringBuilder builder = new StringBuilder(); int sum = 0; int i = num1.length()-1; int j = num2.length()-1; while (i >= 0 || j >= 0 || sum != 0){ if (i>=0) { sum += num1.charAt(i)-'0'; i--; } if (j>=0) { sum += num2.charAt(j)-'0'; j--; } builder.append(sum % 10); sum /= 10; } return builder.reverse().toString(); }}小结这里对两个字符串从后开始遍历，而后进行累加，取余数增加到后果集，而后取模，持续循环，最初将后果反转一下。 ...

序本文次要记录一下leetcode之间断字符 题目给你一个字符串 s ，字符串的「能量」定义为：只蕴含一种字符的最长非空子字符串的长度。请你返回字符串的能量。 示例 1：输出：s = "leetcode"输入：2解释：子字符串 "ee" 长度为 2 ，只蕴含字符 'e' 。示例 2：输出：s = "abbcccddddeeeeedcba"输入：5解释：子字符串 "eeeee" 长度为 5 ，只蕴含字符 'e' 。示例 3：输出：s = "triplepillooooow"输入：5示例 4：输出：s = "hooraaaaaaaaaaay"输入：11示例 5：输出：s = "tourist"输入：1 提醒：1 <= s.length <= 500s 只蕴含小写英文字母。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/consecutive-characters著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int maxPower(String s) { char[] chars = s.toCharArray(); int count = 1; int result = 1; for (int i = 1; i < chars.length; i++) { count = chars[i] == chars[i - 1] ? count + 1 : 1; result = Math.max(result, count); } return result; }}小结这里对字符数组进行遍历，从第二个字符开始，每次与前一个字符比拟，如果相等则递增count，如果不等则重置count为1，而后从新计算result ...

序本文次要记录一下leetcode之整顿字符串 题目给你一个由大小写英文字母组成的字符串 s 。一个整顿好的字符串中，两个相邻字符 s[i] 和 s[i+1]，其中 0<= i <= s.length-2 ，要满足如下条件:若 s[i] 是小写字符，则 s[i+1] 不能够是雷同的大写字符。若 s[i] 是大写字符，则 s[i+1] 不能够是雷同的小写字符。请你将字符串整顿好，每次你都能够从字符串中选出满足上述条件的 两个相邻 字符并删除，直到字符串整顿好为止。请返回整顿好的 字符串 。题目保障在给出的约束条件下，测试样例对应的答案是惟一的。留神：空字符串也属于整顿好的字符串，只管其中没有任何字符。 示例 1：输出：s = "leEeetcode"输入："leetcode"解释：无论你第一次选的是 i = 1 还是 i = 2，都会使 "leEeetcode" 缩减为 "leetcode" 。示例 2：输出：s = "abBAcC"输入：""解释：存在多种不同状况，但所有的状况都会导致雷同的后果。例如："abBAcC" --> "aAcC" --> "cC" --> """abBAcC" --> "abBA" --> "aA" --> ""示例 3：输出：s = "s"输入："s" 提醒：1 <= s.length <= 100s 只蕴含小写和大写英文字母起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/make-the-string-great著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { int delta = 'a' - 'A'; public String makeGood(String s) { StringBuilder builder = new StringBuilder(s); int len = -1; while (len != builder.length()) { len = builder.length(); for (int i = 0; i < builder.length() -1; i++) { if (Math.abs(builder.charAt(i) - builder.charAt(i+1)) == delta) { builder.delete(i,i+2); break; } } } return builder.toString(); }}小结这里采取while循环，在遍历builder没有删除字符的时候跳出循环，在遍历builder的时候，比照相邻的char，都符合条件则删除。 ...

题目链接2. Add-Two-Numbers 难度：$\color{#00965e}{medium}$ 知识点1.数据结构单链表数据结构根底，此处不赘述 2.链表尾插法C 单链表头插法/尾插法/删除指定值结点 解法简略累加留心进位用head记录头结点，head->next即题解须要的头结点复杂度剖析工夫复杂度：O(max(m,n))，其中 m,nm,n 为两个链表的长度。咱们要遍历两个链表的全副地位，而解决每个地位只须要 O(1)O(1) 的工夫。空间复杂度：O(max(m,n))，答案链表的长度最多为较长链表的长度 +1+1。以下为PHP语言实现~~~~ /** * Definition for a singly-linked list. * class ListNode { * public $val = 0; * public $next = null; * function __construct($val = 0, $next = null) { * $this->val = $val; * $this->next = $next; * } * } */class Solution { /** * @param ListNode $l1 * @param ListNode $l2 * @return ListNode */ function addTwoNumbers($l1, $l2) { $carry = 0; $tmp_int = 0; $head = new ListNode(); $end = new ListNode(); $end = $head; //$head = $end;//与下面的写法其实是一样的，这里的head是保留了头结点 while($l1 !=NULL || $l2!=NULL || $carry > 0){ if ($l1 != NULL){ $tmp_int += $l1->val; $l1 = $l1->next; } if ($l2 != NULL){ $tmp_int += $l2->val; $l2 = $l2->next; } $tmp_int += $carry; $node = new ListNode(); $node->val= $tmp_int%10; $carry = floor($tmp_int/10); $tmp_int = 0; $end->next= $node; $end = $node; } return $head->next; }}

序本文次要记录一下leetcode之罗马数字转整数 题目罗马数字蕴含以下七种字符: I， V， X， L，C，D 和 M。字符 数值I 1V 5X 10L 50C 100D 500M 1000例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。通常状况下，罗马数字中小的数字在大的数字的左边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的右边，所示意的数等于大数 5 减小数 1 失去的数值 4 。同样地，数字 9 示意为 IX。这个非凡的规定只实用于以下六种状况：I 能够放在 V (5) 和 X (10) 的右边，来示意 4 和 9。X 能够放在 L (50) 和 C (100) 的右边，来示意 40 和 90。 C 能够放在 D (500) 和 M (1000) 的右边，来示意 400 和 900。给定一个罗马数字，将其转换成整数。输出确保在 1 到 3999 的范畴内。 示例 1:输出: "III"输入: 3示例 2:输出: "IV"输入: 4示例 3:输出: "IX"输入: 9示例 4:输出: "LVIII"输入: 58解释: L = 50, V= 5, III = 3.示例 5:输出: "MCMXCIV"输入: 1994解释: M = 1000, CM = 900, XC = 90, IV = 4. 提醒：题目所给测试用例皆合乎罗马数字书写规定，不会呈现跨位等状况。IC 和 IM 这样的例子并不合乎题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。对于罗马数字的详尽书写规定，能够参考 罗马数字 - Mathematics 。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/roman-to-integer著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { static Map<Character,Integer> map = new HashMap<>(); static { map.put('I',1); map.put('V',5); map.put('X',10); map.put('L',50); map.put('C',100); map.put('D',500); map.put('M',1000); map.put('A',4); map.put('B',9); map.put('Q',40); map.put('P',90); map.put('E',400); map.put('F',900); } public int romanToInt(String s) { s = s.replace("IV","A"). replace("IX","B"). replace("XL","Q"). replace("XC","P"). replace("CD","E"). replace("CM","F"); Integer result=0; for(char num : s.toCharArray()){ result += map.get(num); } return result; }}小结这里采纳HashMap对罗马数字与阿拉伯数字进行映射，另外对于非凡的组合罗马数字进行替换，最初遍历char数字查找映射进行累加。 ...

序本文次要记录一下leetcode之仅仅反转字母 题目给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的地位产生反转。 示例 1：输出："ab-cd"输入："dc-ba"示例 2：输出："a-bC-dEf-ghIj"输入："j-Ih-gfE-dCba"示例 3：输出："Test1ng-Leet=code-Q!"输入："Qedo1ct-eeLg=ntse-T!" 提醒：S.length <= 10033 <= S[i].ASCIIcode <= 122 S 中不蕴含 \ or "起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/reverse-only-letters著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String reverseOnlyLetters(String S) { char[] chars = S.toCharArray(); int startIdx = 0; int endIdx = chars.length - 1; while (startIdx < endIdx) { boolean isStartLetter = true; boolean isEndLetter = true; if (!Character.isLetter(chars[startIdx])) { startIdx++; isStartLetter = false; } if (!Character.isLetter(chars[endIdx])) { endIdx--; isEndLetter = false; } if (isStartLetter && isEndLetter) { char tmp = chars[startIdx]; chars[startIdx] = chars[endIdx]; chars[endIdx] = tmp; startIdx++; endIdx--; } } return new String(chars); }}小结这里应用前后两个索引，在两个索引没相遇之前始终循环，若以后char不是字母则后退一位，若都是字母则替换并后退一位，最初返回后果。 ...

序本文次要记录一下leetcode之字符串压缩 题目字符串压缩。利用字符反复呈现的次数，编写一种办法，实现根本的字符串压缩性能。比方，字符串aabcccccaaa会变为a2b1c5a3。若“压缩”后的字符串没有变短，则返回原先的字符串。你能够假如字符串中只蕴含大小写英文字母（a至z）。示例1: 输出："aabcccccaaa" 输入："a2b1c5a3"示例2: 输出："abbccd" 输入："abbccd" 解释："abbccd"压缩后为"a1b2c2d1"，比原字符串长度更长。提醒：字符串长度在[0, 50000]范畴内。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/compress-string-lcci著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String compressString(String S) { if (S == null || S.length() == 0) { return S; } char pre = S.charAt(0); int count = 1; StringBuilder result = new StringBuilder(); for (int i=1; i< S.length(); i++) { char cur = S.charAt(i); if (cur == pre) { count++; } else { result.append(pre) .append(count); pre = cur; count = 1; } } result.append(pre) .append(count); if (result.length() >= S.length()) { return S; } return result.toString(); }}小结这里保护前一个字符及其count的字段，之后从第二个字符开始遍历，判断与前一个字符是否相等，相等则累加，不相等则将该字符的压缩增加到后果中，最初再将最初一个字符的压缩增加到后果中。 ...

题目：给出两个 非空 的链表用来示意两个非负的整数。其中，它们各自的位数是依照 逆序 的形式存储的，并且它们的每个节点只能存储 一位 数字。如果，咱们将这两个数相加起来，则会返回一个新的链表来示意它们的和。您能够假如除了数字 0 之外，这两个数都不会以 0 结尾。起源：力扣（LeetCode） 思路一：拿到这道题，我的第一思路是先将链表的数字转化为int的形识，相加之后再进行一次向链表的转化（多少有些做无用功的感觉），代码如下： /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode { var i,j,k int ll1 := l1 ll2 := l2 k = 1 for i=0;;k *=10{ i += ll1.Val*k ll1 = ll1.Next if ll1 ==nil{break} } k = 1 for j=0;;k *=10{ j += ll2.Val*k ll2 = ll2.Next if ll2 == nil {break} } aim := i + j ll := new(ListNode) final := ll for{ ll.Val = aim % 10 aim = aim/10 ll.Next = new(ListNode) if aim == 0{ ll.Next = nil break } ll = ll.Next } return final}起初测试的时候也没有什么问题，然而当提交的时候问题呈现了，提交的测试用例比起测试时的大的多，超出了int类型的下限，这是相加的后果就不在正确了。所以咱们能够转换一下思路，既然总的加在一起太大了，那么就离开在每一位相加就好了。 ...

序本文次要记录一下leetcode之Bigram分词 题目给出第一个词 first 和第二个词 second，思考在某些文本 text 中可能以 "first second third" 模式呈现的状况，其中 second 紧随 first 呈现，third 紧随 second 呈现。对于每种这样的状况，将第三个词 "third" 增加到答案中，并返回答案。 示例 1：输出：text = "alice is a good girl she is a good student", first = "a", second = "good"输入：["girl","student"]示例 2：输出：text = "we will we will rock you", first = "we", second = "will"输入：["we","rock"] 提醒：1 <= text.length <= 1000text 由一些用空格分隔的单词组成，每个单词都由小写英文字母组成1 <= first.length, second.length <= 10first 和 second 由小写英文字母组成起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/occurrences-after-bigram著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String[] findOcurrences(String text, String first, String second) { String[] textArr = text.split(" "); List<String> result = new ArrayList<>(); for (int i=0; i< textArr.length-2 ; i++) { if (textArr[i].equals(first) && textArr[i + 1].equals(second)) { result.add(textArr[i + 2]); } } return result.toArray(new String[result.size()]); }}小结这里先对text按空格分隔为字符串数组，之后遍历数组判断是否满足first及second，都满足则将third增加到后果中。 ...

序本文次要记录一下leetcode之单词法则 题目给定一种法则 pattern 和一个字符串 str ，判断 str 是否遵循雷同的法则。这里的 遵循 指齐全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连贯的对应法则。示例1:输出: pattern = "abba", str = "dog cat cat dog"输入: true示例 2:输出:pattern = "abba", str = "dog cat cat fish"输入: false示例 3:输出: pattern = "aaaa", str = "dog cat cat dog"输入: false示例 4:输出: pattern = "abba", str = "dog dog dog dog"输入: false阐明:你能够假如 pattern 只蕴含小写字母， str 蕴含了由单个空格分隔的小写字母。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/word-pattern著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean wordPattern(String pattern, String s) { Map<Character,String> patternMap = new HashMap<>(); String[] data = s.split(" "); if (pattern.length() != data.length) { return false; } for(int i=0; i<pattern.length(); i++) { char c = pattern.charAt(i); String str = patternMap.get(c); if (str != null) { if (!str.equals(data[i])) { return false; } } else { if (patternMap.containsValue(data[i])) { return false; } patternMap.put(c, data[i]); } } return true; }}小结这里采纳HashMap记录每个pattern跟文字的映射，不过这里要判断下pattern的个数与文字的个数，另外同一个value不能映射到不同的key。 ...

序本文次要记录一下leetcode之最长回文串 题目给定一个蕴含大写字母和小写字母的字符串，找到通过这些字母结构成的最长的回文串。在结构过程中，请留神辨别大小写。比方 "Aa" 不能当做一个回文字符串。留神:假如字符串的长度不会超过 1010。示例 1:输出:"abccccdd"输入:7解释:咱们能够结构的最长的回文串是"dccaccd", 它的长度是 7。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/longest-palindrome著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int longestPalindrome(String s) { Map<Character, Integer> countMap = new HashMap<>(); for (char c : s.toCharArray()) { countMap.put(c, countMap.getOrDefault(c, 0) + 1); } int result = 0; for (Integer value : countMap.values()) { if (value % 2 == 0) { result = result + value; } else { result = result + value / 2 * 2; if (result % 2 == 0) { result++; } } } return result; }}小结这里先统计一下每个字符的个数，之后对于偶数个间接累加，对于奇数个先累加偶数局部，最初再判断后果是否是偶数，若是偶数则残余的一个奇数能够算进去。 ...

D129 836. Rectangle Overlap题目链接836. Rectangle Overlap 题目剖析给两个矩形的左下角和右上角的坐标，判断该矩形有没有重叠。边线和角雷同不算重叠。 解题思路咱们先疏忽Y轴，只思考X轴。在x轴上，矩形A和矩形B的横坐标从小到大排列有6种关系： Ax1, Ax2, Bx1, Bx2Ax1, Bx1, Ax2, Bx2Ax1, Bx1, Bx2, Ax2Bx1, Ax1, Bx1, Ax2Bx1, Ax1, Ax2, Bx2Bx1, Bx2, Ax1, Ax2其中，第一个和最初一个是不重叠的状况，两头4种都是会重叠的。 在拿到坐标后，判断坐标之间是否有这种关系。Y轴同理。 最终代码<?phpclass Solution { /** * @param Integer[] $rec1 * @param Integer[] $rec2 * @return Boolean */ const BOTTOM_LEFT_X = 0; const BOTTOM_LEFT_Y = 1; const TOP_RIGHT_X = 2; const TOP_RIGHT_Y = 3; function isRectangleOverlap($rec1, $rec2) { if($rec1[self::TOP_RIGHT_X]<=$rec2[self::BOTTOM_LEFT_X] || $rec2[self::TOP_RIGHT_X]<=$rec1[self::BOTTOM_LEFT_X] ){ return false; } if($rec1[self::TOP_RIGHT_Y]<=$rec2[self::BOTTOM_LEFT_Y] || $rec2[self::TOP_RIGHT_Y]<=$rec1[self::BOTTOM_LEFT_Y] ){ return false; } return true; }}若感觉本文章对你有用，欢送用爱发电赞助。 ...

D128 202. Happy Number题目链接202. Happy Number 题目剖析这道题目不简单，就是给定一个数字，把每一位拆开来算个平方再相加。始终加到和为1就是高兴数字Happy Number返回true，或者失去循环就返回false。 解题思路我感觉这个题目的“难点”在于怎么晓得循环了。比较简单的方法是把求过的和都记录进一个数组外面，每次求完一次和就判断一下是否呈现过，即可知是否循环。这种计划的毛病就是每算一次要遍历一遍数组了。 我想另辟蹊径换种办法。 我先通过剖析100以内的数字种，有哪些数字是符合要求的。通过计算发现：和为100时，只可能从68或86而得来。而这两个数字又是从28或82得来的。再往前就是19和91了。而这两个数字是不可能通过100以内的数字每一位拆开求平方和得来。咱们能够画出19/91=>28/82=>68/86=>100这样的链条来。 同理、还有另外两个链条： 7/70=>49/94=>79/97=>130=>10 44=>23/32=>13/31=>10 在链条里呈现的数字都能保障最初失去的是1。因而咱们把这些数字保存起来用来对照。一旦在计算过程中，呈现了这个数字，那就阐明这个数肯定是高兴数字了。 最终代码<?phpclass Solution { /** * @param Integer $n * @return Boolean */ function isHappy($n) { $safe = [1,7,10,13,19,23,28,31,28,31,32,44,49,68,70,79,82,86,91,94,97,100]; $total = $n; do{ $digits = str_split($total); $total = array_reduce($digits, function($val, $s){ $val += $s*$s; return $val; }, 0); }while($total>100); if(in_array($total, $safe)){ return true; } return false; }}若感觉本文章对你有用，欢送用爱发电赞助。

序本文次要记录一下leetcode之键盘行 题目给定一个单词列表，只返回能够应用在键盘同一行的字母打印进去的单词。键盘如下图所示。示例：输出: ["Hello", "Alaska", "Dad", "Peace"]输入: ["Alaska", "Dad"] 留神：你能够重复使用键盘上同一字符。你能够假如输出的字符串将只蕴含字母。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/keyboard-row著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String[] findWords(String[] words) { List<String> result = new ArrayList<>(); for (String word : words) { String str = word.toLowerCase(); if (str.matches("[qwertyuiop]+") || str.matches("[asdfghjkl]+") || str.matches("[zxcvbnm]+")) { result.add(word); } } return result.toArray(new String[result.size()]); }}小结这里利用java的String的matches办法来进行正则匹配，将满足条件的增加到后果集中。 doc键盘行

序本文次要记录一下leetcode之有多少小于以后数字的数字 题目给你一个数组 nums，对于其中每个元素 nums[i]，请你统计数组中比它小的所有数字的数目。换而言之，对于每个 nums[i] 你必须计算出无效的 j 的数量，其中 j 满足 j != i 且 nums[j] < nums[i] 。以数组模式返回答案。 示例 1：输出：nums = [8,1,2,2,3]输入：[4,0,1,1,3]解释： 对于 nums[0]=8 存在四个比它小的数字：（1，2，2 和 3）。 对于 nums[1]=1 不存在比它小的数字。对于 nums[2]=2 存在一个比它小的数字：（1）。 对于 nums[3]=2 存在一个比它小的数字：（1）。 对于 nums[4]=3 存在三个比它小的数字：（1，2 和 2）。示例 2：输出：nums = [6,5,4,8]输入：[2,1,0,3]示例 3：输出：nums = [7,7,7,7]输入：[0,0,0,0] 提醒：2 <= nums.length <= 5000 <= nums[i] <= 100起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/how-many-numbers-are-smaller-than-the-current-number著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int[] smallerNumbersThanCurrent(int[] nums) { int[] countArr = new int[100+1]; int[] countAgg = new int[100+1]; for (int num : nums) { countArr[num] = countArr[num] + 1; countAgg[num] = countAgg[num] + 1; } for (int i = 1; i< countAgg.length; i++) { countAgg[i] = countAgg[i-1] + countAgg[i]; } int[] result = new int[nums.length]; for (int i=0; i< nums.length; i++) { result[i] = nums[i] == 0 ? 0 : countAgg[nums[i]] - countArr[nums[i]]; } return result; }}小结这里先用countArr来统计每个nums元素的个数，之后对countAgg用后面的元素值进行累加，最初遍历nums来计算小于以后数字的个数，这里会在利用countArr，因为存在反复的元素值。 ...

序本文次要记录一下leetcode之最短补全词 题目给定一个字符串牌照 licensePlate 和一个字符串数组 words ，请你找出并返回 words 中的 最短补全词 。如果单词列表（words）中的一个单词蕴含牌照（licensePlate）中所有的字母，那么咱们称之为 补全词 。在所有残缺词中，最短的单词咱们称之为 最短补全词 。单词在匹配牌照中的字母时要： 疏忽牌照中的数字和空格。 不辨别大小写，比方牌照中的 "P" 仍然能够匹配单词中的 "p" 字母。 如果某个字母在牌照中呈现不止一次，那么该字母在补全词中的呈现次数该当统一或者更多。例如：licensePlate = "aBc 12c"，那么它由字母 'a'、'b' （疏忽大写）和两个 'c' 。可能的 补全词 是 "abccdef"、"caaacab" 以及 "cbca" 。题目数据保障肯定存在一个最短补全词。当有多个单词都合乎最短补全词的匹配条件时取单词列表中最靠前的一个。 示例 1：输出：licensePlate = "1s3 PSt", words = ["step", "steps", "stripe", "stepple"]输入："steps"阐明：最短补全词应该包含 "s"、"p"、"s" 以及 "t"。在匹配过程中咱们疏忽牌照中的大小写。"step" 蕴含 "t"、"p"，但只蕴含一个 "s"，所以它不符合条件。"steps" 蕴含 "t"、"p" 和两个 "s"。"stripe" 缺一个 "s"。"stepple" 缺一个 "s"。因而，"steps" 是惟一一个蕴含所有字母的单词，也是本样例的答案。示例 2：输出：licensePlate = "1s3 456", words = ["looks", "pest", "stew", "show"]输入："pest"阐明：存在 3 个蕴含字母 "s" 且有着最短长度的补全词，"pest"、"stew"、和 "show" 三者长度雷同，但咱们返回最先呈现的补全词 "pest" 。示例 3：输出：licensePlate = "Ah71752", words = ["suggest","letter","of","husband","easy","education","drug","prevent","writer","old"]输入："husband"示例 4：输出：licensePlate = "OgEu755", words = ["enough","these","play","wide","wonder","box","arrive","money","tax","thus"]输入："enough"示例 5：输出：licensePlate = "iMSlpe4", words = ["claim","consumer","student","camera","public","never","wonder","simple","thought","use"]输入："simple" 提醒： 1 <= licensePlate.length <= 7 licensePlate 由数字、大小写字母或空格 ' ' 组成 1 <= words.length <= 1000 1 <= words[i].length <= 15 words[i] 由小写英文字母组成起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/shortest-completing-word著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String shortestCompletingWord(String licensePlate, String[] words) { Map<Character,Integer> charCountMap = new HashMap<>(); for(Character c : licensePlate.toCharArray()) { if (Character.isLetter(c)) { char lower = Character.toLowerCase(c); charCountMap.put(lower, charCountMap.getOrDefault(lower, 0) + 1); } } Integer length = null; String result = null; for(String word : words) { Map<Character,Integer> tmpMap = new HashMap<>(); for (Character c : word.toCharArray()) { char lower = Character.toLowerCase(c); tmpMap.put(lower, tmpMap.getOrDefault(lower, 0) + 1); } boolean matched = true; for (Map.Entry<Character,Integer> entry : charCountMap.entrySet()) { int c = tmpMap.getOrDefault(entry.getKey(), 0); if (c < entry.getValue()) { matched = false; break; } } if (matched && (length == null || length > word.length())) { result = word; length = word.length(); } } return result; }}小结这里就暴力求解，先统计licensePlate中字母的个数；之后遍历words，挨个统计每个word的字母个数，而后去校验是否蕴含licensePlate中的字母以及个数是否相符，最初在对合乎的word的长度进行判断，取最短的，如果都一样取最先呈现的。 ...

序本文次要记录一下leetcode之谬误的汇合 题目汇合 S 蕴含从1到 n 的整数。可怜的是，因为数据谬误，导致汇合外面某一个元素复制了成了汇合外面的另外一个元素的值，导致汇合失落了一个整数并且有一个元素反复。给定一个数组 nums 代表了汇合 S 产生谬误后的后果。你的工作是首先寻找到反复呈现的整数，再找到失落的整数，将它们以数组的模式返回。示例 1:输出: nums = [1,2,2,4]输入: [2,3]留神: 给定数组的长度范畴是 [2, 10000]。 给定的数组是无序的。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/set-mismatch著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int[] findErrorNums(int[] nums) { int n = nums.length; int[] count = new int[n+1]; int[] result = new int[2]; int sum = 0; for (int i : nums) { count[i]++; if (count[i] == 2) { result[0] = i; } sum = sum + i; } int rightSum = n * (n + 1) / 2; result[1] = rightSum - sum + result[0]; return result; }}小结这里遍历一次数组，求出总和，并计算每个元素的count，同时找出反复的元素，之后依据自然数求和公式与现有总和的差值及反复的元素计算得出缺失的元素。 ...

序本文次要记录一下leetcode之找不同 题目给定两个字符串 s 和 t，它们只蕴含小写字母。字符串 t 由字符串 s 随机重排，而后在随机地位增加一个字母。请找出在 t 中被增加的字母。 示例 1：输出：s = "abcd", t = "abcde"输入："e"解释：'e' 是那个被增加的字母。示例 2：输出：s = "", t = "y"输入："y"示例 3：输出：s = "a", t = "aa"输入："a"示例 4：输出：s = "ae", t = "aea"输入："a" 提醒： 0 <= s.length <= 1000 t.length == s.length + 1 s 和 t 只蕴含小写字母起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/find-the-difference著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public char findTheDifference(String s, String t) { int result = 0; for (char c : t.toCharArray()) { result = result + c; } for (char c : s.toCharArray()) { result = result - c; } return (char)result; }}小结这里通过汇总t的每个char的值再减去s的每个char的值，便能够得出在t中被增加的字母。 ...

序本文次要记录一下leetcode之单词替换 题目在英语中，咱们有一个叫做 词根(root)的概念，它能够跟着其余一些词组成另一个较长的单词——咱们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其余)，能够造成新的单词 another(另一个)。当初，给定一个由许多词根组成的词典和一个句子。你须要将句子中的所有继承词用词根替换掉。如果继承词有许多能够造成它的词根，则用最短的词根替换它。你须要输入替换之后的句子。 示例 1：输出：dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery"输入："the cat was rat by the bat"示例 2：输出：dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"输入："a a b c"示例 3：输出：dictionary = ["a", "aa", "aaa", "aaaa"], sentence = "a aa a aaaa aaa aaa aaa aaaaaa bbb baba ababa"输入："a a a a a a a a bbb baba a"示例 4：输出：dictionary = ["catt","cat","bat","rat"], sentence = "the cattle was rattled by the battery"输入："the cat was rat by the bat"示例 5：输出：dictionary = ["ac","ab"], sentence = "it is abnormal that this solution is accepted"输入："it is ab that this solution is ac" 提醒： 1 <= dictionary.length <= 1000 1 <= dictionary[i].length <= 100 dictionary[i] 仅由小写字母组成。 1 <= sentence.length <= 10^6 sentence 仅由小写字母和空格组成。 sentence 中单词的总量在范畴 [1, 1000] 内。 sentence 中每个单词的长度在范畴 [1, 1000] 内。 sentence 中单词之间由一个空格隔开。 sentence 没有前导或尾随空格。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/replace-words著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public String replaceWords(List<String> dictionary, String sentence) { String[] words = sentence.split("\\s+"); for (int i = 0; i < words.length; i++) { for (String dic : dictionary) { if (words[i].startsWith(dic)) { words[i] = dic; } } } return Arrays.asList(words) .stream() .collect(Collectors.joining(" ")); } }小结这里用双层循环应用startsWith来判断是否命中词根，如果是则替换，如果后面命中的词根不是最短的，则前面遇到会被替换掉，最初再将替换后的words数组拼接为sentence。 ...

LeetCode 第 4 号问题：寻找两个正序数组的中位数题目地址https://leetcode-cn.com/probl...题目形容给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。 请你找出这两个正序数组的中位数，并且要求算法的工夫复杂度为 O(log(m + n))。 你能够假如 nums1 和 nums2 不会同时为空。 示例 1: nums1 = [1, 3]nums2 = [2]则中位数是 2.0示例 2:nums1 = [1, 2]nums2 = [3, 4]则中位数是 (2 + 3)/2 = 2.5思路暴力解决办法:拼接后找中位数 代码一const findMedianSortedArrays = function(nums1, nums2) { let arr=nums1.concat(nums2)// 合并两个数组 arr.sort((a, b) => a - b)// 新数组从小到大排序 let length = arr.length if(length%2==0){ /** * 数组长度为偶数，输入两头两数之和的平均值 */ return (arr[length/2]+arr[length/2-1])/2 }else{ /** * 数组长度为奇数，输入两头数 */ return arr[(length-1)/2] }};代码二代码起码的办法，工夫复杂度为O((m + n)log(m + n)) ...

1.暴力双循环略过不提；2.哈希表(桶);对于数组A，结构一个哈希，首次遍历时候就记录下值和数组下标，再遍历过程中，先判断哈希表里是否曾经有target - A[i]，有的话，间接返回就好了; 复杂度剖析工夫复杂度：O(N)，其中 N是数组中的元素数量。对于每一个元素 x，咱们能够 O(1) 地寻找 target - x。空间复杂度：O(N)，其中 N 是数组中的元素数量。次要为哈希表的开销。 class Solution { /** * @param Integer[] $nums * @param Integer $target * @return Integer[] */ function twoSum($nums, $target) { $len = count($nums); $table = []; $result = []; //php数组的底层实现就是hash表，这里就不像c一样计算最小值那些了步骤了，间接一把梭 for($i=0;$i < $len;$i++) { //先判断是否有，有的话间接返回下标 if (isset($table[$target - $nums[$i]])) { return [$table[$target - $nums[$i]],$i]; }else{ //否则hash里的数字 => 下标 $table[$nums[$i]] = $i; } } }}

D127 455. Assign Cookies题目链接455. Assign Cookies 题目剖析给定两个数组，第一个数组代表每个容器的容量，第二个数组代表每种物品的个数。须要把物品塞入容器外面，然而有两个条件。 条件一：一个容器内只能塞一种物品； 条件二：一种物品只能塞入一个容器，但能够不塞完。 例如，容器大小为1，物品数量为3时，该物品能够塞入该容器内，但残余的2件物品不能再拿去塞入其余容器内。 尽可能地塞满所有容器，返回塞满了的容器个数。 解题思路一开始我没留神到能够不塞完这个条件，于是间接返回计算交加元素个数。 首先，为了尽可能塞满以及缩小节约，须要对两个数组进行降序排序。否则容器内会呈现较多空档。 接下来，就要开始调配物品了。因为调配的物品能够有剩，因而咱们从物品数量数组登程，如果以后物品数量大于或等于以后容器容量，既调配给它。如果小于，就阐明曾经无奈给容器塞入物品了。一旦调配胜利，间接开始调配下一个物品。 最终代码<?phpclass Solution { /** * @param Integer[] $g * @param Integer[] $s * @return Integer */ function findContentChildren($g, $s) { $total = 0; foreach($s as $key => $value){ while( !is_null(key($g)) ){ if (current($g)<=$value ){ $total++; next($g); break; } next($g); } } return $total; }}若感觉本文章对你有用，欢送用爱发电赞助。

序本文次要记录一下leetcode哈希表之好数对的数目 题目给你一个整数数组 nums 。如果一组数字 (i,j) 满足 nums[i] == nums[j] 且 i < j ，就能够认为这是一组 好数对 。返回好数对的数目。 示例 1：输出：nums = [1,2,3,1,1,3]输入：4解释：有 4 组好数对，别离是 (0,3), (0,4), (3,4), (2,5) ，下标从 0 开始示例 2：输出：nums = [1,1,1,1]输入：6解释：数组中的每组数字都是好数对示例 3：输出：nums = [1,2,3]输入：0 提醒： 1 <= nums.length <= 100 1 <= nums[i] <= 100起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/number-of-good-pairs著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int numIdenticalPairs(int[] nums) { Map<Integer, Integer> map = new HashMap<>(); for (int num : nums) { map.put(num, map.getOrDefault(num, 0) + 1); } int result = 0; for (int key : map.keySet()) { int count = map.get(key); result += count * (count - 1) / 2; } return result; }}小结这里先利用HashMap统计一下元素的个数，依据一个数呈现了n次的话，这个数的好数对就是n*(n-1)/2来计算结果。 ...

序本文次要记录一下leetcode哈希表之前K个高频元素 题目给定一个非空的整数数组，返回其中呈现频率前 k 高的元素。 示例 1:输出: nums = [1,1,1,2,2,3], k = 2输入: [1,2]示例 2:输出: nums = [1], k = 1输入: [1] 提醒： 你能够假如给定的 k 总是正当的，且 1 ≤ k ≤ 数组中不雷同的元素的个数。 你的算法的工夫复杂度必须优于 O(n log n) , n 是数组的大小。 题目数据保障答案惟一，换句话说，数组中前 k 个高频元素的汇合是惟一的。 你能够按任意程序返回答案。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/top-k-frequent-elements著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int[] topKFrequent(int[] nums, int k) { if (nums == null || nums.length <= k) { return nums; } Map<Integer,Integer> countMap = new HashMap<>(); for (int num : nums) { countMap.put(num, countMap.getOrDefault(num, 0) + 1); } PriorityQueue<Integer> queue=new PriorityQueue<>(new Comparator<Integer> () { @Override public int compare(Integer o1, Integer o2) { return countMap.get(o1)-countMap.get(o2); } }); for (Map.Entry<Integer,Integer> entry : countMap.entrySet()) { if (queue.size() < k) { queue.add(entry.getKey()); continue; } if (countMap.get(queue.peek()) < entry.getValue()) { queue.poll(); queue.add(entry.getKey()); } } int[] result = new int[k]; for (int i = 0; i < k; ++i) { result[i] = queue.poll(); } return result; }}小结这里先借助HashMap来统计元素呈现的频次，而后再借助PriorityQueue来保护topK的元素，最初取出来topK元素转换为数组。 ...

序本文次要记录一下leetcode哈希表之举世无双的呈现次数 题目给你一个整数数组 arr，请你帮忙统计数组中每个数的呈现次数。如果每个数的呈现次数都是举世无双的，就返回 true；否则返回 false。 示例 1：输出：arr = [1,2,2,1,1,3]输入：true解释：在该数组中，1 呈现了 3 次，2 呈现了 2 次，3 只呈现了 1 次。没有两个数的呈现次数雷同。示例 2：输出：arr = [1,2]输入：false示例 3：输出：arr = [-3,0,1,-3,1,1,1,-3,10,0]输入：true 提醒： 1 <= arr.length <= 1000 -1000 <= arr[i] <= 1000起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/unique-number-of-occurrences著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean uniqueOccurrences(int[] arr) { Map<Integer, Integer> map = new HashMap<>(); for (int i : arr) { Integer count = map.get(i); map.put(i, count == null ? 1 : count + 1); } return map.size() == map.values().stream().distinct().count(); }}小结这里利用HashMap来计数，最初在判断一下map大小与values去重之后的大小。 ...

序本文次要记录一下leetcode哈希表之第一个只呈现一次的字符 题目在字符串 s 中找出第一个只呈现一次的字符。如果没有，返回一个单空格。 s 只蕴含小写字母。示例:s = "abaccdeff"返回 "b"s = "" 返回 " " 限度：0 <= s 的长度 <= 50000起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/di-yi-ge-zhi-chu-xian-yi-ci-de-zi-fu-lcof著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public char firstUniqChar(String s) { if (s == null || s.length() == 0) { return ' '; } Map<Character, Integer> map = new LinkedHashMap<>(); char[] arr = s.toCharArray(); for (Character e : arr) { Integer count = map.get(e); if (count == null) { map.put(e, 1); } else { map.put(e, count + 1); } } for(Map.Entry<Character,Integer> entry : map.entrySet()) { if (entry.getValue() == 1) { return entry.getKey(); } } return ' '; }}小结这里借助LinkedHashMap来计数，最初按程序遍历，找出count为1的失去第一个只呈现一次的字符。 ...

原文链接：何晓东 博客 环形链表 II给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了示意给定链表中的环，咱们应用整数 pos 来示意链表尾连贯到链表中的地位（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 阐明：不容许批改给定的链表。 起源：力扣（LeetCode）链接：https://leetcode-cn.com/probl... 解题思路 1遍历链表，同时将每次的后果放到 map 中，首次遇到反复元素，则间接返回这个元素就行，代码和上一篇文章的相似。 解题思路 2快慢指针求解：咱们定义两个指针，一快一满。慢指针每次只挪动一步，而快指针每次挪动两步。初始时，慢指针在地位 head，而快指针在地位 head.next。这样一来，如果在挪动的过程中，快指针反过来追上慢指针，就阐明该链表为环形链表。否则快指针将达到链表尾部，该链表不为环形链表。 确定有环形之后，就是推理找到入环点：咱们应用两个指针，fast 与 slow。它们起始都位于链表的头部。随后，slow 指针每次向后挪动一个地位，而 fast 指针向后挪动两个地位。如果链表中存在环，则 fast 指针最终将再次与 slow 指针在环中相遇。 如下图所示，设链表中环外局部的长度为 aa。slow 指针进入环后，又走了 bb 的间隔与 fast 相遇。此时，fast 指针曾经走完了环的 nn 圈，因而它走过的总间隔为 a + n(b + c) + b = a + (n + 1)b + nc。 依据题意，任意时刻，fast 指针走过的间隔都为 slow 指针的 22 倍。因而，咱们有 a + (n + 1)b + nc = 2(a+b) ⟹ a = c + (n − 1)(b + c) ...

D126 717. 1-bit and 2-bit Characters题目链接717. 1-bit and 2-bit Characters 题目剖析这道题目的形容很难懂，我看了Discussion区别人解释才看懂了。 当初采纳2位的霍夫曼编码，即：只有0、10和11三种。 给定一个数组，每一个值为1位。当初固定最初一位为0，判断这最初一位是1位的还是2位的。即：是10的0，还是0的0。 解题思路思考应用栈来实现，遇到1则入栈，0则把“最初一位为1位编码”标记置1。如果栈里曾经有值了，阐明以后是2位编码。把标记置0。 最终代码<?phpclass Solution { /** * @param Integer[] $bits * @return Boolean */ function isOneBitCharacter($bits) { $stack = []; $isOneBit = false; foreach($bits as $bit){ if(isset($stack[0])){ array_pop($stack); $isOneBit = false; } else{ if($bit == 1){ $stack[] = $bit; } else{ $isOneBit = true; } } } return $isOneBit; }}若感觉本文章对你有用，欢送用爱发电赞助。

序本文次要记录一下leetcode哈希表之两数之和 题目给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你能够假如每种输出只会对应一个答案。然而，数组中同一个元素不能应用两遍。 示例:给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/two-sum著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public int[] twoSum(int[] nums, int target) { int[] result = new int[2]; Map<Integer,Integer> map = new HashMap<>(); for(int i = 0; i < nums.length; i++){ if(map.containsKey(nums[i])){ result[0] = i; result[1] = map.get(nums[i]); return result; } map.put(target-nums[i], i); } return result; }}小结这里利用HashMap来存储目标值与以后值的差值及其索引，遍历nums数组，遇到存在的key则间接返回。 ...

序本文次要记录一下leetcode队列之设计循环双端队列 题目设计实现双端队列。你的实现须要反对以下操作： MyCircularDeque(k)：构造函数,双端队列的大小为k。 insertFront()：将一个元素增加到双端队列头部。 如果操作胜利返回 true。 insertLast()：将一个元素增加到双端队列尾部。如果操作胜利返回 true。 deleteFront()：从双端队列头部删除一个元素。 如果操作胜利返回 true。 deleteLast()：从双端队列尾部删除一个元素。如果操作胜利返回 true。 getFront()：从双端队列头部取得一个元素。如果双端队列为空，返回 -1。 getRear()：取得双端队列的最初一个元素。 如果双端队列为空，返回 -1。 isEmpty()：查看双端队列是否为空。 isFull()：查看双端队列是否满了。示例：MyCircularDeque circularDeque = new MycircularDeque(3); // 设置容量大小为3circularDeque.insertLast(1); // 返回 truecircularDeque.insertLast(2); // 返回 truecircularDeque.insertFront(3); // 返回 truecircularDeque.insertFront(4); // 曾经满了，返回 falsecircularDeque.getRear(); // 返回 2circularDeque.isFull(); // 返回 truecircularDeque.deleteLast(); // 返回 truecircularDeque.insertFront(4); // 返回 truecircularDeque.getFront(); // 返回 4 提醒： 所有值的范畴为 [1, 1000] 操作次数的范畴为 [1, 1000] 请不要应用内置的双端队列库。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/design-circular-deque著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class MyCircularDeque { int[] data; int size; /** Initialize your data structure here. Set the size of the deque to be k. */ public MyCircularDeque(int k) { data = new int[k]; } /** Adds an item at the front of Deque. Return true if the operation is successful. */ public boolean insertFront(int value) { if(isFull()){ return false; } for(int i=size-1; i>=0; i--){ data[i+1] = data[i]; } data[0] = value; size++; return true; } /** Adds an item at the rear of Deque. Return true if the operation is successful. */ public boolean insertLast(int value) { if(isFull()){ return false; } data[size] = value; size++; return true; } /** Deletes an item from the front of Deque. Return true if the operation is successful. */ public boolean deleteFront() { if(isEmpty()){ return false; } data[0] = 0; for(int i=0; i<size-1; i++){ data[i]=data[i+1]; } size--; return true; } /** Deletes an item from the rear of Deque. Return true if the operation is successful. */ public boolean deleteLast() { if(isEmpty()){ return false; } data[size-1] = 0; size--; return true; } /** Get the front item from the deque. */ public int getFront() { return size == 0 ? -1 : data[0]; } /** Get the last item from the deque. */ public int getRear() { return size == 0 ? -1 : data[size-1]; } /** Checks whether the circular deque is empty or not. */ public boolean isEmpty() { return size == 0; } /** Checks whether the circular deque is full or not. */ public boolean isFull() { return size == data.length; }}/** * Your MyCircularDeque object will be instantiated and called as such: * MyCircularDeque obj = new MyCircularDeque(k); * boolean param_1 = obj.insertFront(value); * boolean param_2 = obj.insertLast(value); * boolean param_3 = obj.deleteFront(); * boolean param_4 = obj.deleteLast(); * int param_5 = obj.getFront(); * int param_6 = obj.getRear(); * boolean param_7 = obj.isEmpty(); * boolean param_8 = obj.isFull(); */小结这里采纳数组实现，insert操作之前都要先判断是否满了，delete操作之前都要先判断是否空了，对于insertFront及deleteFront都要设置数组元素的拷贝。 ...

序本文次要记录一下leetcode队列之最近的申请次数 题目写一个 RecentCounter 类来计算特定工夫范畴内最近的申请。请你实现 RecentCounter 类： RecentCounter() 初始化计数器，申请数为 0 。 int ping(int t) 在工夫 t 增加一个新申请，其中 t 示意以毫秒为单位的某个工夫，并返回过来 3000 毫秒内产生的所有申请数（包含新申请）。确切地说，返回在 [t-3000, t] 内产生的申请数。保障每次对 ping 的调用都应用比之前更大的 t 值。 示例 1：输出：["RecentCounter", "ping", "ping", "ping", "ping"][[], [1], [100], [3001], [3002]]输入：[null, 1, 2, 3, 3]解释：RecentCounter recentCounter = new RecentCounter();recentCounter.ping(1); // requests = [1]，范畴是 [-2999,1]，返回 1recentCounter.ping(100); // requests = [<u>1</u>, <u>100</u>]，范畴是 [-2900,100]，返回 2recentCounter.ping(3001); // requests = [<u>1</u>, <u>100</u>, <u>3001</u>]，范畴是 [1,3001]，返回 3recentCounter.ping(3002); // requests = [1, <u>100</u>, <u>3001</u>, <u>3002</u>]，范畴是 [2,3002]，返回 3 提醒： 1 <= t <= 104 保障每次对 ping 的调用都应用比之前更大的 t 值 至少调用 ping 办法 104 次起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/number-of-recent-calls著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class RecentCounter { Queue<Integer> queue = new LinkedList<>(); public RecentCounter() { } public int ping(int t) { while(!queue.isEmpty()){ int data = queue.peek(); if (data < t-3000) { queue.poll(); } else { break; } } queue.add(t); return queue.size(); }}/** * Your RecentCounter object will be instantiated and called as such: * RecentCounter obj = new RecentCounter(); * int param_1 = obj.ping(t); */小结这里应用java内置的queue，在ping的时候，先看下队头元素值是否小于t-3000，若小于则取出来，持续循环；最初将t增加到队列，返回队列的大小。 ...

序本文次要记录一下leetcode栈之二叉树的前序遍历 题目给定一个二叉树，返回它的 前序 遍历。 示例:输出: [1,null,2,3] 1 \ 2 / 3 输入: [1,2,3]进阶: 递归算法很简略，你能够通过迭代算法实现吗？起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-tree-preorder-traversal著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */class Solution { public List<Integer> preorderTraversal(TreeNode root) { List<Integer> result = new ArrayList<>(); preTraverse(root, result); return result; } private void preTraverse(TreeNode node, List<Integer> result) { if (node == null) { return ; } Stack<TreeNode> stack = new Stack<>(); stack.push(node); while (!stack.empty()) { TreeNode treeNode = stack.pop(); result.add(treeNode.val); if (treeNode.right != null) { stack.push(treeNode.right); } if (treeNode.left != null) { stack.push(treeNode.left); } } }}小结这里借助栈来实现二叉树的前序遍历；在每个preTraverse办法外头新建一个栈，push以后node，而后循环pop栈，将元素增加到result中，之后先push右子节点，再push左子节点。 ...

序本文次要记录一下leetcode栈之比拟含退格的字符串 题目给定 S 和 T 两个字符串，当它们别离被输出到空白的文本编辑器后，判断二者是否相等，并返回后果。 # 代表退格字符。留神：如果对空文本输出退格字符，文本持续为空。 示例 1：输出：S = "ab#c", T = "ad#c"输入：true解释：S 和 T 都会变成 “ac”。示例 2：输出：S = "ab##", T = "c#d#"输入：true解释：S 和 T 都会变成 “”。示例 3：输出：S = "a##c", T = "#a#c"输入：true解释：S 和 T 都会变成 “c”。示例 4：输出：S = "a#c", T = "b"输入：false解释：S 会变成 “c”，但 T 依然是 “b”。 提醒： 1 <= S.length <= 200 1 <= T.length <= 200 S 和 T 只含有小写字母以及字符 '#'。 进阶： 你能够用 O(N) 的工夫复杂度和 O(1) 的空间复杂度解决该问题吗？起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/backspace-string-compare著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean backspaceCompare(String S, String T) { Stack<Character> stackS = processBackspace(S); Stack<Character> stackT = processBackspace(T); if(stackS.size()!=stackT.size()){ return false; } while (!stackS.isEmpty()){ if(stackS.pop()!=stackT.pop()){ return false; } } return true; } public Stack<Character> processBackspace(String str) { Stack<Character> result = new Stack<>(); for(char data: str.toCharArray()){ if(data == '#'){ if(!result.isEmpty()){ result.pop(); } } else { result.push(data); } } return result; }}小结这里借助栈，遍历string的char，遇到#时在栈不为空的时候pop一下，非#时则push数据到栈中；之后比照两个栈的元素来判断是否相等。 ...

class Solution { public int removeElement(int[] nums, int val) { int i; for(i = 0; i < nums.length ; i++) { if(nums[i]==val) { int j; for(j = nums.length - 1; j > i; j--) { if(nums[j]!=val) { break; } } if(j == i) break; nums[i]=nums[j]; nums[j]=val; } } return i; }}

序本文次要记录一下leetcode栈之最小栈 题目设计一个反对 push ，pop ，top 操作，并能在常数工夫内检索到最小元素的栈。 push(x) —— 将元素 x 推入栈中。 pop() —— 删除栈顶的元素。 top() —— 获取栈顶元素。 getMin() —— 检索栈中的最小元素。 示例:输出：["MinStack","push","push","push","getMin","pop","top","getMin"][[],[-2],[0],[-3],[],[],[],[]]输入：[null,null,null,null,-3,null,0,-2]解释：MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.getMin(); --> 返回 -3.minStack.pop();minStack.top(); --> 返回 0.minStack.getMin(); --> 返回 -2. 提醒： pop、top 和 getMin 操作总是在 非空栈 上调用。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/min-stack著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class MinStack { private int min = Integer.MAX_VALUE; private Stack<Integer> stack; /** initialize your data structure here. */ public MinStack() { stack = new Stack<>(); } public void push(int x) { if (x <= min) { stack.push(min); min = x; } stack.push(x); } public void pop() { if (stack.pop() == min) { min = stack.pop(); } } public int top() { return stack.peek(); } public int getMin() { return min; }}/** * Your MinStack object will be instantiated and called as such: * MinStack obj = new MinStack(); * obj.push(x); * obj.pop(); * int param_3 = obj.top(); * int param_4 = obj.getMin(); */小结这里再push的时候，计算了min值，同时再min值有更新的时候，先push了上一个min值，最初再push以后的min值；在pop的时候，判断是否等于min值，等于的话，再pop一次，更新以后min值为上一个min值，这里这样子实现是基于题目的假如(pop、top 和 getMin 操作总是在 非空栈 上调用)以及MinStack的调用程序。 ...

序本文次要记录一下leetcode栈之用队列实现栈 题目应用队列实现栈的下列操作： push(x) -- 元素 x 入栈 pop() -- 移除栈顶元素 top() -- 获取栈顶元素 empty() -- 返回栈是否为空留神: 你只能应用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是非法的。 你所应用的语言兴许不反对队列。 你能够应用 list 或者 deque（双端队列）来模仿一个队列 , 只有是规范的队列操作即可。 你能够假如所有操作都是无效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/implement-stack-using-queues著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class MyStack { private Queue<Integer> a; private Queue<Integer> b; /** Initialize your data structure here. */ public MyStack() { a = new LinkedList<>(); b = new LinkedList<>(); } /** Push element x onto stack. */ public void push(int x) { a.offer(x); // 将b队列中元素全副转给a队列 while(!b.isEmpty()) a.offer(b.poll()); // 替换a和b,使得a队列没有在push()的时候始终为空队列 Queue temp = a; a = b; b = temp; } /** Removes the element on top of the stack and returns that element. */ public int pop() { return b.poll(); } /** Get the top element. */ public int top() { return b.peek(); } /** Returns whether the stack is empty. */ public boolean empty() { return b.isEmpty(); }}/** * Your MyStack object will be instantiated and called as such: * MyStack obj = new MyStack(); * obj.push(x); * int param_2 = obj.pop(); * int param_3 = obj.top(); * boolean param_4 = obj.empty(); */小结这里应用了两个LinkedList，在push的时候，offer到a队列，而后再将b队列的元素offer到a队列，再替换a、b队列；pop、top、empty的时候间接操作b队列。 ...

序本文次要记录一下leetcode栈之用两个栈实现队列 题目用两个栈实现一个队列。队列的申明如下，请实现它的两个函数 appendTail 和 deleteHead ，别离实现在队列尾部插入整数和在队列头部删除整数的性能。(若队列中没有元素，deleteHead 操作返回 -1 ) 示例 1：输出：["CQueue","appendTail","deleteHead","deleteHead"][[],[3],[],[]]输入：[null,null,3,-1]示例 2：输出：["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"][[],[],[5],[2],[],[]]输入：[null,-1,null,null,5,2]提醒： 1 <= values <= 10000 最多会对 appendTail、deleteHead 进行 10000 次调用起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class CQueue { Stack<Integer> in; Stack<Integer> out; public CQueue() { in = new Stack<>(); out = new Stack<>(); } public void appendTail(int value) { while(!out.isEmpty()){ in.push(out.pop()); } in.push(value); } public int deleteHead() { while(!in.isEmpty()){ out.push(in.pop()); } if(out.isEmpty()){ return -1; } return out.pop(); }}/** * Your CQueue object will be instantiated and called as such: * CQueue obj = new CQueue(); * obj.appendTail(value); * int param_2 = obj.deleteHead(); */小结这里应用两个栈，一个用于进栈，一个用于出栈；appendTail的时候先遍历out栈将其元素取出来push到in栈外头，最初在push该value；deleteHead的时候先遍历in栈将其元素取出来push到out栈外头，最初在pop进去。 ...

D125 107. Binary Tree Level Order Traversal II题目链接107. Binary Tree Level Order Traversal II 题目剖析给定一个二叉树，把同一层的值放在同一键下的数组内，以左节点的值为先，逆序返回。 思路从给出的样例可知，越在顶层的值，它的键值越大。 左节点的值在后面，这个就简略了，用先序遍历，把值间接塞入数组开端即可。 因为层高是不确定的，我决定先把顶层的值存在后面，最初用array_reverse倒转数据来解决。 最终代码<?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 Solution { private $vals = []; /** * @param TreeNode $root * @return Integer[][] */ function levelOrderBottom($root) { $this->preOrder($root, 0); return array_reverse($this->vals); } function preOrder($node, $level){ if(is_null($node)){ return; } if(!isset($this->vals[$level])){ $this->vals[$level] = []; } $this->vals[$level][] = $node->val; if($node->left){ $this->preOrder($node->left, $level+1); } if($node->right){ $this->preOrder($node->right, $level+1); } }}若感觉本文章对你有用，欢送用爱发电赞助。 ...

序本文次要记录一下leetcode栈之无效的括号 题目给定一个只包含 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否无效。无效字符串需满足： 左括号必须用雷同类型的右括号闭合。 左括号必须以正确的程序闭合。留神空字符串可被认为是无效字符串。示例 1:输出: "()"输入: true示例 2:输出: "()[]{}"输入: true示例 3:输出: "(]"输入: false示例 4:输出: "([)]"输入: false示例 5:输出: "{[]}"输入: true起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/valid-parentheses著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解class Solution { public boolean isValid(String s) { Stack<Character>stack = new Stack<Character>(); for(char c: s.toCharArray()){ if(c=='(')stack.push(')'); else if(c=='[')stack.push(']'); else if(c=='{')stack.push('}'); else if(stack.isEmpty()||c!=stack.pop())return false; } return stack.isEmpty(); }}小结这里借助栈，而后遍历每个char，针对(、[、{别离push对应配对的char，其余的则判断stack是否为空或者pop进去的值是否与之相等，如果不等则返回false，如果遍历完之后，stack不为空则返回false，为空返回true。 doc无效的括号

D124 1175. Prime Arrangements题目链接1175. Prime Arrangements 题目剖析这道题，给一个数字n，生成一个从1到n的数组，有多少种排列形式使得 质数位的数字为质数？其中1<=n<=100 因为最终返回值可能比拟大，请返回mod(10**9 +7)后的后果。 思路也就是说，在质数位的数字是能够任意排列的，而剩下的非质数位也是能够任意排列的，因而咱们离开计算两种状况，再相乘就能够了。 因为n的范畴到100，因而能够手写质数，用空间换工夫。 其次，咱们须要晓得，给定的数字n及之前有多少个质数。这个比较简单，只须要把咱们在后面生成的质数数组的键和值用array_flip函数颠倒过去就能够了。失去后，应用阶乘就能够算出排列数。 对于非质数，咱们用range函数生成1到100的值，而后用array_diff函数生成非质数数组。值减去键就是非质数的个数。 因而，咱们先用is_set判断给出的n是在质数数组还是在非质数数组外面。在质数数组的话，间接把n当作键，去数组里获取值就能够了。在非质数数组的话，从非质数数组把n当键获取值+1，即可失去n及之前有多少个非质数了。为什么要+1是因为array_diff返回的是下标是从0开始的。n减去非质数数字个数就等于质数个数了。 好了，当初有了质数数量和非质数数量，须要做的是阶乘了。咱们都晓得阶乘后的值回升的十分快，所以我采纳的是每乘一个数字就取一次模。 先用range函数生成须要参加阶乘的数字，再用array_values获取这些数字，最初用array_reduce把一维数组变成一个数。这里质数和非质数一样，就不多做解释了。 须要留神的是，n的返回中包含1，也就是说会呈现质数数量为0的状况。此时进行array_reduce的话，会返回0。再进行相乘的话，会返回0。因而我在计算后还用max函数设置了最小值为1。 最终代码<?phpclass Solution { /** * @param Integer $n * @return Integer */ function numPrimeArrangements($n) { $primes = [1 =>2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]; $nonPrimes = array_values(array_diff(range(1,100), $primes)); $primesBeforeIndex = array_flip($primes); $nonPrimesBeforeIndex = array_flip($nonPrimes); if(isset($primesBeforeIndex[$n])){ $primeAmount = $primesBeforeIndex[$n]; $nonePrimeAmount = $n - $primeAmount; } else{ $nonePrimeAmount = $nonPrimesBeforeIndex[$n]+1; $primeAmount = $n - $nonePrimeAmount; } $primesPermutation = array_reduce(array_values(range(1,$primeAmount)), function($carry, $item){ $carry *= $item; return $carry%(pow(10,9)+7); },1); $primesPermutation = max(1, $primesPermutation); $nonPrimePermutation = array_reduce(array_values(range(1,$nonePrimeAmount)), function($carry, $item){ $carry *= $item; return $carry%(pow(10,9)+7); },1); $nonPrimePermutation = max(1, $nonPrimePermutation); return ($primesPermutation * $nonPrimePermutation)%(pow(10,9)+7); }}若感觉本文章对你有用，欢送用爱发电赞助。 ...

序本文次要记录一下leetcode树之对称二叉树 题目给定一个二叉树，查看它是否是镜像对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \3 4 4 3 然而上面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 1 / \ 2 2 \ \ 3 3 进阶：你能够使用递归和迭代两种办法解决这个问题吗？起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/symmetric-tree著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean isSymmetric(TreeNode root) { if (root == null) { return true; } return compare(root.left, root.right); } public boolean compare(TreeNode left, TreeNode right) { if (left == null && right == null){ return true; } if (left == null || right == null || left.val != right.val) { return false; } return compare(left.left, right.right) && compare(left.right, right.left); }}小结这里采纳递归的形式解决，定义一个compare，而后比照left及right节点，若二者都为null返回true，若其中一个不为null或者值不相等则返回false，值相等的状况下递归执行compare(left.left, right.right)及compare(left.right, right.left)进行比拟。 ...

背景: 写博客的时候每当新增 LeetCode 题解时都须要在 LeetCode/README 手动更新表格, 十分吃力。因而构思了 crd-leetcode-cli 插件实现自动化同步更新 leetcode ac 题解为 markdown table 。 crd-leetcode-clicrd-leetcode-cli 提供将 leetcode 中已 AC 的题目转化为 markdown 表格的能力。 Install执行 yarn add crd-leetcode-cli -g, 国内用户能够执行 cnpm install crd-leetcode-cli -g Usageleetcode download // 增量拉取 AC 题目(若无登录, 则会先执行登录逻辑)leetcode download -a // 全量拉取 AC 题目leetcode login // 登录leetcode logout // 登出接入我的项目示例Render Markdown Table Customly插件提供了自定义渲染 markdown table 的能力。 在我的项目根目录创立 config.js 文件。在 config.js 内自定义生成 markdown 的 transform_markdown_table 函数。const transform_markdown_table = (dataArr) => { const beforeDescription = `The markdown table is generated by [crd-leetcode-cli](https://github.com/MuYunyun/create-react-doc/tree/master/packages/leetcode-cli)`; let result = beforeDescription + '\n' + '| # | Title | Explanation | Difficulty | Type |' + '\n' + '|:---:|:---:|:---:|:---:|:---:|'; for (let i = 0; i < dataArr.length; i++) { result += `\n| ${dataArr[i].questionId} | [${dataArr[i].title }](https://leetcode.com/problems/${dataArr[i].titleSlug }/) | [Analyze](https://github.com/MuYunyun/blog/blob/master/LeetCode/${dataArr[i].questionId }.${dataArr[i].title.split(' ').join('_')}.md) | ${dataArr[i].difficulty } | ${dataArr[i].topicTags} |`; } return result;};module.exports = { transform_markdown_table }通过自定义 transform_markdown_table 函数, 便可失去如下 markdown table: ...

✨ 一个 LeetCode 答题看板的生成插件， 反对一键部署到 Hugo 站点。 残缺记录刷题的心路历程 ✨ <!--more--> 在线预览 Demo Screenshots Installation下载 Repo 到本地： git clone https://github.com/lryong/hugo-leetcode-dashboard装置依赖： 本我的项目须要用到 requests 和 aiohttp 包， 通过 pip 装置即可。更新仓库根目录下的 config.json文件： { "username": "leetcode-cn@leetcode", // LeetCode-cn 账号 "password": "leetcode", // 对应的明码 "outputDir": "../LeetCode" // dashboard 生成门路。 留神： 这里配置为 hugo 站点的文档门路， 如：/Users/XXX/my_blogs/content}能够依据需要批改 templates.py 定义的 dashboard 模板。因为 Hugo 默认只反对 markdown 文档, 能够在站点，新建 layouts/shortcodes/rawhtml.html文件，增加以下配置即可： <!-- raw html -->{{.Inner}}(具体能够参考这里) 最初一键部署到 Hugo 站点， 参考以下命令： echo "2" | python3 run.py && cp imgs/leetcode-logo.png /Users/XXX/my_blogs/static/imagesFeatures答题状况总览（实现的题目和整体过程）LeetCode 集体答题看板， 包含展现 题号，题目，珍藏标签，解答的语言， 题目通过率， 难度和题目类型间接展现 LeetCode 问题形容间接展现 LeetCode 集体的答题计划LicenseReleased under the MIT License. ...

序本文次要记录一下leetcode树之将有序数组转换为二叉搜寻树 题目将一个依照升序排列的有序数组，转换为一棵高度均衡二叉搜寻树。本题中，一个高度均衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。示例:给定有序数组: [-10,-3,0,5,9],一个可能的答案是：[0,-3,9,-10,null,5]，它能够示意上面这个高度均衡二叉搜寻树： 0 / \ -3 9 / / -10 5起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeNode sortedArrayToBST(int[] nums) { return nums == null ? null : buildTree(nums, 0, nums.length - 1); } private TreeNode buildTree(int[] nums, int l, int r) { if (l > r) { return null; } int m = l + (r - l) / 2; TreeNode root = new TreeNode(nums[m]); root.left = buildTree(nums, l, m - 1); root.right = buildTree(nums, m + 1, r); return root; }}小结这里采纳递归的思路，先取l与r的两头值m，依据m构建一个TreeNode，而后通过递归buildTree(nums, l, m - 1)及buildTree(nums, m + 1, r)来设置该node的左右子节点。 ...

序本文次要记录一下leetcode树之二叉树的所有门路 题目给定一个二叉树，返回所有从根节点到叶子节点的门路。阐明: 叶子节点是指没有子节点的节点。示例:输出: 1 / \2 3 \ 5输入: ["1->2->5", "1->3"]解释: 所有根节点到叶子节点的门路为: 1->2->5, 1->3起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/binary-tree-paths著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public List<String> binaryTreePaths(TreeNode root) { List<String> result = new ArrayList<>(); if(root == null) { return result; } solve(root, "", result); return result; } public void solve(TreeNode root, String cur, List<String> result){ if(root == null) { return; } cur += root.val; if(root.left==null && root.right==null) { result.add(cur); return; } solve(root.left, cur+"->", result); solve(root.right, cur+"->", result); }}小结这里采纳递归的思维，设计了solve办法，办法有个汇合类型的参数用于收集门路，另外还有一个参数用于示意门路的前缀；每次执行solve办法都将以后节点的val追加在门路前缀，在节点为叶子节点时，将前缀增加到result中并返回；若不为叶子节点则将->拼接到门路前缀中，递归其左右子节点。 ...

序本文次要记录一下leetcode树之二叉树的深度 题目输出一棵二叉树的根节点，求该树的深度。从根节点到叶节点顺次通过的节点（含根、叶节点）造成树的一条门路，最长门路的长度为树的深度。例如：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。 提醒： 节点总数 <= 10000留神：本题与主站 104 题雷同：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public int maxDepth(TreeNode root) { if(root == null) { return 0; } int leftDepth = maxDepth(root.left) ; int rightDepth = maxDepth(root.right) ; return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1; }}小结这里采纳递归的形式，递归计算maxDepth(root.left)及maxDepth(root.right)，最初取它们的最大值+1。 ...

序本文次要记录一下leetcode树之二叉树的层平均值 题目给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。 示例 1：输出： 3 / \ 9 20 / \ 15 7输入：[3, 14.5, 11]解释：第 0 层的平均值是 3 , 第1层是 14.5 , 第2层是 11 。因而返回 [3, 14.5, 11] 。 提醒： 节点值的范畴在32位有符号整数范畴内。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/average-of-levels-in-binary-tree著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public List<Double> averageOfLevels(TreeNode root) { if (root == null) { return Collections.emptyList(); } List<Double> result = new ArrayList<Double>(); Queue queue = new LinkedList(); queue.offer(root); while(!queue.isEmpty()) { int size = queue.size(); double sum = 0; for(int i=0; i< size; i++){ TreeNode node = (TreeNode)queue.poll(); sum += node.val; if (node.left != null) { queue.offer(node.left); } if (node.right !=null) { queue.offer(node.right); } } result.add(sum*1.0/size); } return result; }}小结这里借助队列进行档次遍历，每次先记录queue的size，而后按size来poll，取出元素累加sum，而后把不为null的node.left及node.right放入到queue中，最初计算sum/size放入到result中。 ...

序本文次要记录一下leetcode树之从根到叶的二进制数之和 题目给出一棵二叉树，其上每个结点的值都是 0 或 1 。每一条从根到叶的门路都代表一个从最高无效位开始的二进制数。例如，如果门路为 0 -> 1 -> 1 -> 0 -> 1，那么它示意二进制数 01101，也就是 13 。对树上的每一片叶子，咱们都要找出从根到该叶子的门路所示意的数字。以 10^9 + 7 为模，返回这些数字之和。 示例：输出：[1,0,1,0,1,0,1]输入：22解释：(100) + (101) + (110) + (111) = 4 + 5 + 6 + 7 = 22 提醒： 树中的结点数介于 1 和 1000 之间。 node.val 为 0 或 1 。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/sum-of-root-to-leaf-binary-numbers著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */class Solution { public int sumRootToLeaf(TreeNode root) { return sumNode(root, 0); } public int sumNode(TreeNode node, int sum) { if (node == null) { return 0; } sum = 2 * sum + node.val; if (node.left == null && node.right == null) { return sum; } return sumNode(node.left, sum) + sumNode(node.right, sum); }}小结这里采纳递归的办法，当node为null时返回0；之后对sum累加以后node.val；若node.left及node.right为null则返回sum，否则递归计算sumNode(node.left, sum)再累加上sumNode(node.right, sum)。 ...

序本文次要记录一下leetcode树之雷同的树 题目给定两个二叉树，编写一个函数来测验它们是否雷同。如果两个树在结构上雷同，并且节点具备雷同的值，则认为它们是雷同的。示例 1:输出: 1 1 / \ / \ 2 3 2 3 [1,2,3], [1,2,3]输入: true示例 2:输出: 1 1 / \ 2 2 [1,2], [1,null,2]输入: false示例 3:输出: 1 1 / \ / \ 2 1 1 2 [1,2,1], [1,1,2]输入: false起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/same-tree著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */class Solution { public boolean isSameTree(TreeNode p, TreeNode q) { if(p==null && q==null) { return true; } if(p!=null && q!=null && p.val==q.val) { return isSameTree(p.left,q.left) && isSameTree(p.right,q.right); } return false; }}小结这里采纳递归的思路，当p及q都为null返回true；若p和q都不为null且p.val等于q.val那么则递归判断isSameTree(p.left,q.left)及isSameTree(p.right,q.right)；其余状况返回false。 ...

序本文次要记录一下leetcode树之二叉搜寻树的最近公共先人 题目给定一个二叉搜寻树, 找到该树中两个指定节点的最近公共先人。百度百科中最近公共先人的定义为：“对于有根树 T 的两个结点 p、q，最近公共先人示意为一个结点 x，满足 x 是 p、q 的先人且 x 的深度尽可能大（一个节点也能够是它本人的先人）。”例如，给定如下二叉搜寻树: root = [6,2,8,0,4,7,9,null,null,3,5] 示例 1:输出: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8输入: 6 解释: 节点 2 和节点 8 的最近公共先人是 6。示例 2:输出: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4输入: 2解释: 节点 2 和节点 4 的最近公共先人是 2, 因为依据定义最近公共先人节点能够为节点自身。 阐明: 所有节点的值都是惟一的。 p、q 为不同节点且均存在于给定的二叉搜寻树中。留神：本题与主站 235 题雷同：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if (root == null) { return null; } if (root.val > p.val && root.val > q.val) { return lowestCommonAncestor(root.left, p, q); } if (root.val < p.val && root.val < q.val) { return lowestCommonAncestor(root.right, p, q); } return root; }}小结这里采纳递归的思路，并利用二叉搜寻树的个性来解题；针对root.val大于p.val及q.val的递归执行lowestCommonAncestor(root.left, p, q)；针对root.val小于p.val及q.val的递归执行lowestCommonAncestor(root.right, p, q)。 ...

序本文次要记录一下leetcode树之从翻转二叉树 题目翻转一棵二叉树。示例：输出： 4 / \ 2 7 / \ / \1 3 6 9输入： 4 / \ 7 2 / \ / \9 6 3 1备注:这个问题是受到 Max Howell 的 原问题 启发的 ： 谷歌：咱们90％的工程师应用您编写的软件(Homebrew)，然而您却无奈在面试时在白板上写出翻转二叉树这道题，这太蹩脚了。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/invert-binary-tree著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeNode invertTree(TreeNode root) { if (root == null) { return root; } TreeNode tmp = root.left; root.left = invertTree(root.right); root.right = invertTree(tmp); return root; }}小结这里采纳递归的思路，首先用tmp保留一下left节点，之后递归翻转right节点赋值给left，再递归翻转tmp赋值为right。 ...

序本文次要记录一下leetcode树之上到下打印二叉树 题目从上到下按层打印二叉树，同一层的节点按从左到右的程序打印，每一层打印到一行。 例如:给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7返回其档次遍历后果：[ [3], [9,20], [15,7]] 提醒： 节点总数 <= 1000留神：本题与主站 102 题雷同：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public List<List<Integer>> levelOrder(TreeNode root) { if (root == null) { return Collections.emptyList(); } Queue queue = new LinkedList(); queue.offer(root); List<List<Integer>> result = new ArrayList(); while (!queue.isEmpty()) { List<Integer> list = new ArrayList<>(); int length = queue.size(); for (int i=0; i< length; i++) { TreeNode node = (TreeNode)queue.poll(); if (node != null) { list.add(node.val); queue.offer(node.left); queue.offer(node.right); } } if (!list.isEmpty()){ result.add(list); } } return result; }}小结这是二叉树档次遍历的一个变种，区别在于每次poll的之前须要先记录下以后queue的size，即以后层的节点个数，而后按这个size去pull。 ...

ARTSARTS 是陈浩（网名左耳朵耗子）在极客工夫专栏里发动的一个流动，目标是通过分享的形式来保持学习。 每人每周写一个 ARTS：Algorithm 是一道算法题，Review 是读一篇英文文章，Technique/Tips 是分享一个小技术，Share 是分享一个观点。本周内容这周的 ARTS 你将看到: N皇后网网红题.什么是软件系统适度设计?Algorithm本周的算法题是网红面试题 N皇后问题: LeetCode 51 N-Queens. 这是一道十分经典的应用 回溯 + 剪支 的搜寻类题目, 这道题尽管是 hard 难度, 但我感觉最难得中央在于想到应用深度优先搜寻的办法. 上面是代码, 思路详见正文. func solveNQueens(n int) [][]string {ans := make([][]int, 0)// 上面是回溯记忆操作, 用于剪支// 因为每次回溯都按行 row 从上到下进行, 因而同一行的皇后互斥曾经在回溯流程被排除了// 只须要思考列和两种对角线col := make(map[int]struct{}, 0) // 代表列中是否已存在皇后pie := make(map[int]struct{}, 0) // 代表撇(右上到左下)是否已存在皇后na := make(map[int]struct{}, 0) // 代表捺(左上到右下)是否已存在皇后queens := make([]int, 0)// i 示意搜寻进行到第 i 行var dfs func(i int)dfs = func(i int) {if i == n {// 这里必须对 queens 进行深拷贝, 否则后续回溯会影响 ans 中的后果tmp := make([]int, len(queens))copy(tmp, queens)ans = append(ans, tmp)}for j := 0; j < n; j++ {_, a := col[j]; _, b := pie[i+j]; _, c := na[i-j]// 剪支if !a && !b && !c {col[j], pie[i+j], na[i-j] = struct{}{}, struct{}{}, struct{}{}queens = append(queens, j)dfs(i+1)delete(col, j); delete(pie, i+j); delete(na, i-j)// 因为底层数据没有变, 所以必须删除本次增加的元素, 后续回溯能力失常应用 queensqueens = queens[:len(queens)-1]}}}dfs(0)return genMetric(ans, n)}func genMetric(ans [][]int, n int) [][]string {ret := make([][]string, 0)s := ""for i := 0; i < n; i++ {s += "."}for _, queens := range ans {metric := make([]string, 0)for _, q := range queens {l := []byte(s)l[q] = 'Q'metric = append(metric, string(l))}ret = append(ret, metric)}return ret}Review 文章举荐本周的文章举荐是对于软件架构中的适度设计的: 十个软件系统适度设计的例子. ...

序本文次要记录一下leetcode树之N叉树的前序遍历 题目给定一个 N 叉树，返回其节点值的前序遍历。例如，给定一个 3叉树 :返回其前序遍历: [1,3,5,6,2,4]。 阐明: 递归法很简略，你能够应用迭代法实现此题吗?起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/*// Definition for a Node.class Node { public int val; public List<Node> children; public Node() {} public Node(int _val) { val = _val; } public Node(int _val, List<Node> _children) { val = _val; children = _children; }};*/class Solution { List<Integer> result = new ArrayList<Integer>(); public List<Integer> preorder(Node root) { if(root == null) { return result; } result.add(root.val); for(Node child:root.children){ preorder(child); } return result; }}小结这里采纳递归的办法，与二叉树前序遍历不同的时，N叉树不是遍历左右子树，而是遍历其children。 ...

序本文次要记录一下leetcode树之均衡二叉树 题目给定一个二叉树，判断它是否是高度均衡的二叉树。本题中，一棵高度均衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。示例 1:给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7返回 true 。示例 2:给定二叉树 [1,2,2,3,3,null,null,4,4] 1 / \ 2 2 / \ 3 3 / \ 4 4返回 false 。起源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/balanced-binary-tree著作权归领扣网络所有。商业转载请分割官网受权，非商业转载请注明出处。题解/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public boolean isBalanced(TreeNode root) { return height(root) >= 0; } private int height(TreeNode root) { if(root == null) { return 0; } int lh = height(root.left); int rh = height(root.right); if(lh >= 0 && rh >= 0 && Math.abs(lh - rh) <= 1) { return Math.max(lh, rh) + 1; } return -1; }}小结这里采纳递归的解法，当root为null的时候返回0，之后递归计算root.left的高度lh，及root.right的高度rh，而后判断左右子树的高度差是否小于等于1，是的话返回该节点的高度，否则返回-1 ...