weixin_45367847的博客

class Solution { public boolean isValid(String s) { int n = s.length(); if(n % 2 == 1) return false; Map<Character, Character> map = new HashMap<>(){{ put(')','('); put(']','[');

我们需要找出给定数组中两个数字之间的最大差值（即，最大利润）。此外，第二个数字（卖出价格）必须大于第一个数字（买入价格）。形式上，对于每组 i 和 j（其中 j >i）我们需要找出 max(prices[j]−prices[i])。暴力法：超时public class Solution { public int maxProfit(int prices[]) { int maxprofit = 0; for (int i = 0; i < pric.

思路：动态规划或者中心拓展算法动态规划class Solution { public String longestPalindrome(String s) { int len = s.length(); if(len < 2) return s; int maxLen = 0; int start = 0; // dp[i][j] 表示 s[i..j] 是否是回文串 boolean dp[][.

摩尔投票法169. 多数元素229. 求众数 II摩尔投票法分为两个阶段：配对阶段和计数阶段169. 多数元素class Solution { public int majorityElement(int[] nums) { int candidate = nums[0], count = 0; // 配对阶段 for(int num : nums){ if(count == 0){ can

这里写目录标题226. 翻转二叉树105. 从前序与中序遍历序列构造二叉树106. 从中序与后序遍历序列构造二叉树889. 根据前序和后序遍历构造二叉树226. 翻转二叉树class Solution { public TreeNode invertTree(TreeNode root) { if(root == null) return null; invertTree(root.left); invertTree(root.right);

数字排列剑指 Offer 45. 把数组排成最小的数179. 最大数这类题主要是自定义排序规则，比如 22和33，显然组合 2233 > 3322所以如果组成最小数，应该定义(x + y).compareTo(y + x)，表示 x 如果 小于 y，则 x 排在前面。所以如果组成最小数，应该定义(y + x).compareTo(x + y)，表示 y 如果 大于 x，则 y 排在前面。剑指 Offer 45. 把数组排成最小的数class Solution { public Str

翻转链表系列翻转链表K个一组翻转链表翻转链表 ListNode reverse(ListNode head){ if(head == null || head.next == null) return head; ListNode dum = new ListNode(0); ListNode pre = dum; ListNode cur = head; while(cur != null){ .

旋转数组思路：  将数组一分为二，其中一定有一个是有序的，另一个可能是有序，也能是部分有序。此时有序部分用二分法查找。无序部分再一分为二，其中一个一定有序，另一个可能有序，可能无序。就这样循环。旋转排序数组153. 寻找旋转排序数组中的最小值（无重复值）154. 寻找旋转排序数组中的最小值 II（有重复值）33. 搜索旋转排序数组（无重复值）81. 搜索旋转排序数组（有重复值）153. 寻找旋转排序数组中的最小值（无重复值）思路：class Solution { public int

思路：等差数列的性质 A[i] - A[i - 1] == A[i - 1] - A[i - 2]方法1：暴力，一旦当前区间不满足等差数列了，那就不需要继续判断了。class Solution { public int numberOfArithmeticSlices(int[] A) { int n = A.length; if(n < 3) return 0; int count = 0; for(int i = .

思路：双指针  由于同一个字母只能出现在同一个片段，显然同一个字母的第一次出现的下标位置和最后一次出现的下标位置必须出现在同一个片段。  在遍历的过程中相当于是要找每一个字母的边界，如果找到之前遍历过的所有字母的最远边界，说明这个边界就是分割点了，此时前面出现过所有字母，最远也就到这个边界了。class Solution { public List<Integer> partitionLabels(String S) { List<Integer> .

思路：双指针，二分双指针class Solution { public int[] searchRange(int[] nums, int target) { int low=0,high=nums.length-1; if(high==-1) return new int[]{-1,-1}; while(low<high){ if(nums[low]==target&&num.

思路：遍历一次矩阵，使用两个数组分别记录每一行每一列有多少个服务器。class Solution { public int countServers(int[][] grid) { int m = grid.length; int n = grid[0].length; int[] row = new int[m]; int[] col = new int[n]; for (int i = 0; i < m; .

思路：  首先考虑 k=1 的情况，当k=1 时，只有 arr[0] 和 arr[1] 之间有一回合游戏，由于一定能分出胜负，因此直接返回 arr[0] 和 arr[1] 中的最大值即可。  k > 1时，每回合游戏之后，较小的整数移至数组的末尾。**其实，并不需要对数组进行更新。在第一回合游戏之后，无论arr[0] 和arr[1] 当中谁取得胜利，第二回合游戏的另一个整数一定是 arr 中的下一个整数。**推广到一般的情况，当 2 ≤ i < arr.length 时，第 i 回合游戏一.

class Solution { public int[][] transpose(int[][] A) { int row = A.length; int col = A[0].length; int[][] f = new int[col][row]; for(int i = 0; i < col; i++){ for(int j = 0; j < row; j++){ .

跟54题相似，四个方向。循环次数为n2n^2n2。class Solution { public int[][] generateMatrix(int n) { int start = 1, end = n * n; int[][] m = new int[n][n]; int l = 0, r = n - 1, u = 0, d = n - 1; while(start <= end){ for(in.

思路：上下左右四个边界class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> list = new ArrayList<>(); if (matrix.length == 0) return list; int l = 0, r = matrix[0].length - 1, u = 0, d = matr.

思路：1.暴力，对于 num[i]，如果num[i]~num[j]的和 >= s，则返回其长度 j - i + 1   2.快慢指针，慢指针start，快指针end，变量sum记录 num[start]~num[end]的值，如果sum < s, end右移 如果sum >= s，更新其长度。然后将 nums[start] 从 sum 中减去并将 start 右移暴力法class Solution { public int minSubArrayLen(int s, in.

思路：实质上是找数组中后一个元素与之前元素的最大差值暴力法：对于每组 i 和 j（其中 j > i）我们需要找出 max(prices[j] - prices[i])class Solution { public int maxProfit(int[] prices) { int ans = 0; int n = prices.length; for (int i = 0; i < n; i++) { for .

思路：   当前柱子 i 能接受的雨水为左边最高的柱子l_max，右边最高的柱子r_max中较矮的一个min， 如果min > 当前柱子的高度height[i]， 则当前柱子能接收的水为 min - height[i]方法1：暴力法，左右维护一个最高柱子 public int trap(int[] height) { int n = height.length; int ans = 0; // 第一个柱子和最后一个柱子不会有雨水，所以 i .

思路：数组已经排好序，所以重复元素一定是相邻的。使用两个指针 i 和 j ，其中 i 是慢指针， j 是快指针，当 num[i] ！= num[j]时，将要求删除重复元素，实际上就是将不重复的元素移到数组的左侧。考虑用 2 个指针，一个在前记作 p，一个在后记作 q，算法流程如下：1.比较 p 和 q 位置的元素是否相等。如果相等，q 后移 1 位如果不相等，将 q 位置的元素复制到 p+1 位置上，p 后移一位，q 后移 1 位重复上述过程，直到 q 等于数组长度。返回 p + 1，即为.

思路：这题跟15题，最接近的三数之和很像，但是难点在于去重。注意点：   当 nums[i]+nums[L]+nums[R]==0时，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,R 移到下一位置，寻找新的解优化：如果 nums[i]大于 0 则三数之和必然无法等于 0 ，结束循环class Solution { public List<List<Integer>> threeSum(int[] nums) { Arrays.sort(.

思路：贪心算法，两种思路   1.胃口小的孩子先吃小饼干   2.胃口大的孩子先大小饼干class Solution { /** * * @param g 孩子的胃口值 * @param s 饼干大小 * @return */ // 胃口小的孩子先吃小饼干 public int findContentChildren(int[] g, int[] s) { Arrays.sort(g); A.

思想：递归，递归终止条件：左括号个数为0且右括号个数为0注意两个条件：1.剩余左右括号数相等，下一个只能用左括号       2.剩余左括号小于右括号，下一个可以用左括号也可以用右括号class Solution { List<String> res = new ArrayList<>(); public List<String> generateParenthesis(int n) { if(n <= 0){ .

思路：  滑动窗口  什么是滑动窗口？  其实就是一个队列,比如例题中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，我们要移动这个队列！  如何移动？  我们只要把队列的左边的元素移出就行了，直到满足题目要求！  一直维持这样的队列，找出队列出现最长的长度时候，求出解！class Solution { public int lengthOfLongestSubstring(String s) { .

思路1：自顶向下minimumTotal1：自顶向下从第0行开始计数， 第i行有i+1个数字边界条件：1.f[0][0] = triangle.get(0).get(0);2.每行最右端只能由上一行的最右端得到3.每行的最左端只能由上一行的最左端得到4.取 f[n-1][0] 到 f[n-1][n-1] 中的最小值，即为答案class Solution { // 从上至下，f中最后一行的最小值就是答案 public int minimumTotal(List<List.

思路1：跟对角线遍历相似， i+j 为偶数时向上走，i+j 为奇数时向下走所以偶数对角线从头部加入元素LinkedList.addFirst，奇数对角线从尾部加入元素LinkedList.addLast，注意，只有LinkedList才有头插法和尾插法class Solution { public static int[] findDiagonalOrder(int[][] matrix) { Map<Integer, LinkedList<Integer>&.

思路：矩阵对角线的规律 ：主对角线中 row + col 是唯一的副对角线中 col - row 是唯一的注意逆序输出注意点：LinkedHashMap和hashMap和TreeMap的区别，HashMap是无序的，当我们希望有顺序地去存储key-value时，就需要使用LinkedHashMap了，TreeMap中默认的排序为升序，如果要改变其排序可以自己写一个Comparator使用LinkedHashMap或者TreeMap都可以，但如果使用HashMap，最后一个测试用例不能通过。c.

思路：使用栈，将左括号入栈，如果来了左括号，继续入栈，如果来了右括号，判断栈顶元素与该右括号是否匹配，如果不匹配直接返回 false，如果匹配则弹出栈顶元素。注意stack.Peek 与 stack.pop 的异同点 :相同点：大家都返回栈顶的值不同点：peek 不改变栈的值(不删除栈顶的值)，pop会把栈顶的值删除class Solution { public boolean isValid(String s) { int n = s.length(); .

思路：排序+双指针class Solution { public int threeSumClosest(int[] nums, int target) { Arrays.sort(nums); int ans = nums[0] + nums[1] + nums[2]; for (int i = 0; i < nums.length; i++) { int l = i + 1, r = nums.length - 1; .

思路：回溯，注意复原现场。class Solution { public boolean exist(char[][] board, String word) { char[] words = word.toCharArray(); for (int i = 0; i < board.length; i++) { for (int j = 0; j < board[0].length; j++) { .

思路：用 f(x) 表示爬到第 x 级台阶的方案数，考虑最后一步可能跨了一级台阶，也可能跨了两级台阶，所以可以列出如下式子：f(x) = f(x - 1) + f(x - 2)，即斐波那契数列。斐波那契数列的方式：递归和动态规划class Solution { // 递归 public int climbStairs1(int n) { if (n <= 2) return n; return climbStairs1(n-.

思路1：实质上就是一颗树class Solution { public List<String> letterCombinations(String digits) { List<String> combinations = new ArrayList<String>(); if (digits.length() == 0) { return combinations; } .

思路1：实质上就是求无向图连通块的个数，我们从每个未被访问的节点开始深度优先遍历，每开始一次搜索就增加 count 计数器一次class Solution { public int findCircleNum(int[][] M) { int n = M.length; int[] visited = new int[n]; int count = 0; for(int i = 0; i < M.length; i++){ .

思路1：开辟两个数组row_zero, col_zero 用来记录哪一行哪一列有0，然后遍历数组，如果该行或者该列有0，就把matrix[i][j]改为0class Solution { public void setZeroes(int[][] matrix) { if(matrix.length == 0 || matrix[0].length == 0) return; int[] row_zero = new int[matrix.length]; .

思路1：双循环，矩形的长为 j - i, 宽为两根柱子中较矮的柱子的高度class Solution { public int maxArea(int[] height) { int ans = 0; for(int i = 0; i < height.length; i++){ for(int j = i + 1; j < height.length; j++){ ans = Math.max(.

class Solution { public static List<String> letterCombinations(String digits) { // 存储答案 List<String> combinations = new ArrayList<>(); // 特殊情况 if (digits.length() == 0) { return combination.

暴力法：class Solution {// 暴力法 public int maxArea(int[] height) { if(height.length <= 1) return 0; int res = 0;//保存结果 for(int i = 0; i < height.length - 1; i++)//以i为左挡板，从O开始 { for(int j = height.lengt.