qq_39227541的博客

mysql我来了

题：接雨水本题单调栈的作用：1.便于获取top的左墙；2.便于寻找右墙class Solution { public int trap(int[] height) { int len=height.length; int res=0; //利用双向队列实现“单调递减的栈”（栈内存放的是序号，栈顶元素最小） //因为需要维护单调栈，才会有出栈的操作 Deque<Integer> stack=ne.

计算本节点为起点的价值（路径和/节点数），进而计算遍历”经过本节点的价值“力扣124. 二叉树中的最大路径和/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } *

求解长度利用动态规划，求解数组，记录这个位置的前一个位置的序号索引是谁，这样可以逆序找到最后需要求解的那个最长递增子序列的数组public class Test { public static void main(String[] args) { Test t=new Test(); int[] nums={1,23,4,5,33,8,90,91}; t.lengthOfLIS(nums); } public int lengthOfLIS.

看清合法与不合法的要求！！！！单向链表（别忘了节点类）//创建链表的节点public class ListNode { int val; ListNode next; ListNode(int val){ this.val=val; }}//链表的尺寸和“假”头结点class MyLinkedList { int size; ListNode head; public MyLinked

用两个栈实现单向队列class MyQueue { Stack<Integer> stackin; Stack<Integer> stackout; public MyQueue() { stackin=new Stack<Integer>(); stackout=new Stack<Integer>(); } //保证队列非空 public void push(int

组合数（外层遍历物品+内层遍历背包）class Solution { public int change(int amount, int[] coins) { //属于完全背包问题（目标和就是背包容量，coin面值就是物品），dp[j]表示目标和为j的组合数 int[] dp=new int[amount+1]; dp[0]=1;//为了后续的推导，毕竟0本真也没有意义 //这里只能外层升序遍历物品，内层升序遍历背包容量（防止

解法一：双指针法公式思想推倒public class Solution { public ListNode detectCycle(ListNode head) { ListNode fast = head, slow = head;//此处两指针都从head开始（区别于环形链路1的题） //step1:进行第一次快慢指针相遇 while (true) { //情况：这不是环路（同时保证没有空指针异常） .

解题思路：遍历开始的节点序号，节点序号前的元素不会被选取—妙不可言class Solution { List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合 LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果 public List<List<Integer>> ..

官方题解：官方题解：public class Solution { public boolean canJump(int[] nums) { int n = nums.length; int rightmost = 0;//记录当前从初始位置到达的最右位置 for (int i = 0; i < n; ++i) { //这个if判断--保证了如果rightmost<i时，说明从初始位置压根不可能到达位置i及其后.

不去重的情况图去重+剪枝的情况：public class Solution { public List<List<Integer>> combinationSum(int[] candidates, int target) { int len = candidates.length; List<List<Integer>> res = new ArrayList<>(); if (.

暴力解法：class Solution { public ListNode mergeKLists(ListNode[] lists) { int len=lists.length; ListNode[] index=new ListNode[len]; for(int i=0;i<len;i++){ index[i]=lists[i]; } //新链表的假头和指针 L.

利用快排序确定第几小的元素位置，相较于快排序不用完全整个数组的排序，而只是确定想要的位置即可class Solution { Random random = new Random(); public int findKthLargest(int[] nums, int k) { // 要找到的元素所在索引: 前K大，即倒数索引第K个(转换逆序大，为正序小，降序排列) int index = nums.length - k; ..

1.动态规划更新当前列的左右最高墙的位置（妙）class Solution { public int trap(int[] height) { int n = height.length; if (n == 0) { return 0; } //正向遍历数组求解每列的左边最高墙高度 int[] leftMax = new int[n]; leftMax[0] = height.

我的暴力法（没有排除有些不可能的情况），穷尽了所有的 i<j 的所有组合情况<size=5>双指针法（双向奔赴）<color=blue>证明==直接去掉的可能不会影响查找最大的蓄水容量class Solution { public int maxArea(int[] height) { int left=0; int right=height.length-1; int max=0; .

类似对称二叉树的判断深度优先搜索：1. 判断首先判断结构，在判断数值(又不相同就返回false)2. 结构相同且当前节点的数值相同时，就继续递归判断左右节点的情况3. 递归结束的标志就是两个树都遍历到最后了class Solution { //直接在求解的类中进行递归，为了一有错就直接结束递归 public boolean isSameTree(TreeNode p, TreeNode q) { if(p==null&&q==null){ .

类似–图的深度优先&广度优先遍历深度搜索（递归+合并）class Solution { public int numIslands(char[][] grid) { //记录独立岛屿的个数 int count = 0; //重新寻找非独立的岛屿（有点类似遍历多张独立图） for(int i = 0; i < grid.length; i++) { for(int j = 0; j <.

我的flag翻转判断行号时递增还是递减行，但我的拼接字符串没用stringbuilder耗时class Solution { public String convert(String s, int numRows) { //当行数为1时直接输出 if(numRows==1){ return s; } //字符串行数的下标 int count=0; String[] stral.

深度优先遍历:类似二叉树的后序遍历那种，左右本的顺序（深度递归，横向回溯）后序遍历class Solution { public List<String> generateParenthesis(int n) { List<String> res=new ArrayList<>(); if(n==0){ //如果有效括号数是空 return res; }

文章目录==纵向扫描==横向遍历纵向扫描我的退出双循环的拙劣代码：class Solution { public String longestCommonPrefix(String[] strs) { //首先获取第一个字符串的长度，一旦又不相等就退出循环 //内层循环相当于遍历每个字符串 int length=strs[0].length(); int i=0; label:for(i=0;i<leng

动态规划（暴力解法，短的回文影响长的回文）–思想和代码很重要DP五部曲：step1：dp[i][j]数组的含义，对应字符串长度从i到j的子串是否是回文串，即为二进制boolean数组step2：递推公式，即从一个回文子串向左边和右边各扩一个字符P(i,j) = P(i+1,j−1)∩(S i ==S j )step3：dp数组的初始化，长度为1的回文子串均为true，即dp[i][i]=truestep4：如何确定遍历循环的顺序，外层遍历回文子串的长度（从小到大），内层遍历回文子串的左边..

== case1==：此时k/2都比数组的有效长度小case2:数组长度小于k/2case3：查找的只剩下一个数组注意：偶数长度的情况，可能出现0.5的小数位数，注意使用乘的0.5自动转换为double类型具体代码：class Solution {public double findMedianSortedArrays(int[] nums1, int[] nums2) { int n = nums1.length; int m = nums2.length; .

本题主要是越界的问题比较难处理：简单的解法，剥离出越界的所有情况直接返回0class Solution { public int reverse(int x) { int res=0;//从最低位一一往上升 while(x!=0){ //每次取出最低位 int temp=x%10; if((res>214748364) || (res==214748364 && .

类似全排列题目：全排列（不重复的数字版+递归回溯）字符串全排列（重复字符版）class Solution { int[] res;//存放最终的结果 /** nine:统计每一个n位数中出现9的个数 count：res[]数组中的下标 start：位有效数字的起始位的序号 */ int nine = 0, count = 0, start, n; char[] num, loop = {'0', '1', '2', '3', .

官方题解：注意：省事使用正的n的方法来求解-n的情况时，当 n = -2147483648时执行 n = -n 会因越界而赋值出错。解决方法是先将 n 存入 long 变量 b ，后面用 b操作即可！！！！！class Solution { public double myPow(double x, int n) { //int32 变量 n 属于 [-2147483648, 2147483647]，因此当 n = -2147483648时执行 n = -n 会因越界而赋值出.

我的暴力解法啊public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { //将整数转化为二进制数 String s=Integer.toBinaryString(n); int length=s.length(); int count=0; //暴力解法 .

大佬们的严谨解法class Solution { public int cuttingRope(int n) { if(n==2){ return 1; } if(n==3){ return 2; } if(n==4){ return 4; } int res=1; //当绳子长度为2或者3.

==官方题解思路：==注意这个可行解的特殊性，每次都是有特殊的形状的，考虑采用广度优先遍历！！！本题的思想和“二叉树的层序遍历”思想类似step:(妙蛙) 首先针对向下（右）移动一格，相当于行（列）位数增一，观察前后两个数的数位和的关系，仅针对题目的范围1-100观察可行解的范围特征：实际利用广度优先搜索（队列思想）时，相当于每次都是按照对角线元素来扫描，不管可行解的范围是不是等腰三角形、还是重叠的三个三角形、还是重叠的四个三角形...

我的思路分析:我知道和“迷宫回溯问题相类似”，但是我就是写不出来！！！！注意：这两句是一定会捆绑在一起使用的,有借有还(深度递归的时候就是在入栈操作，回溯的过程就是在按顺序出栈)class Solution { public boolean exist(char[][] board, String word) { //遍历数组的每个元素来找到word的第一个字符 for(int i=0;i<board.length;i++){ .

==官方的题解：==使用二分查找算法话不多说，打死我也不会想到

我的解题思路分析：

我的递推过程，被前一次楼梯数的情况加1所触发的灵感+末尾两个1的情况可以变为2+前面的楼梯数的情况肯定在未加上1或者2的情况下都是不重复的。最后的递推公式：f(1)=1,f(2)=2,n>=3,有：f(n)=f(n-1)+f(n-2)（类似斐波那契数，但是初始的几个值不相同！！！）class Solution { public int climbStairs(int n) { if(n<3){ return n; } .

贪心算法：carl哥版本：利用Integer.MIN_VALUE巧妙处理了数组全为负的情况！！！class Solution { public int maxSubArray(int[] nums) { if (nums.length == 1){ return nums[0]; } int sum = Integer.MIN_VALUE;//这是个最小的整数，没有比他小的了（即使遇到负数，也会比对方小） .

==官方的题解思路：==遍历每个字符，利用hashset记录每次的“滑动窗口”的存放字符，记录每次的长度和当前的最大值进行比较。外层循环移动窗口的左指针----保证了遍历了所有的情况，内循环移动窗口的右指针！！！！class Solution { //充分利用hashset的不重复特性+滑动窗口 public int lengthOfLongestSubstring(String s) { int ans=0; int right=-1;//从-1开始.

思路分析：照着hsp和carl哥的，利用一个部分匹配表（前缀表，KMP）来实现不重复冗余的查找算法KMP实现字符串的匹配问题class Solution { public int strStr(String haystack, String needle) { if(needle.length()==0){ return 0; } int[] next=getnext(needle); .

解题思路：完全利用了图的广度优先遍历，即利用队列先进先出的特点，但这里二叉树的层序遍历，麻烦的是需要区分每层的节点到底是哪几个（为了同层节点的值加入一个list中）。保证每次迭代后，队列中只剩下----下一次要遍历的那一层节点的数据。每层在队列中的节点，它们出队的时候，同时将自己的左右子节点入队，为下一层遍历服务。class Solution { //为了区分每层的节点：确保每次迭代结束后，一个队列中只有本层的节点, //这样方便遍历本层的节点，来进一步遍历完下一层的节点 .

==我的解题思路（双重递归）：==根据官方的思路，获得了所有节点左右子树的深度之和（暴力解法，将所有的结果装在了一个列表中），输出返回最大的深度即可。递归1：节点的深度+递归2：遍历所有的节点存储左右子树的深度之和class Solution { List<Integer> list=new ArrayList<>(); public int diameterOfBinaryTree(TreeNode root) { if(root==nul..

解题思路分析：我跟的HSP的方法，利用递归与回溯，按照 左-右-本顺序来打印节点。class Solution { //一个公共的存放容器 List<Integer> list=new ArrayList<Integer>(); public List<Integer> postorderTraversal(TreeNode root) { if(root==null){ return.

对比：对称二叉树的解题思路踩雷：翻转的是树，而不是翻转的左右子节点的值。直接交换左右子树的根节点，而不是交换左右子树根节点的val值(从下往上+从左往右：依次交换二叉树的左右节点)class Solution { public TreeNode invertTree(TreeNode root) { if(root==null){ return root;//结束递归，此时已经到达叶子结点 } //当前root节点的左节点.

踩雷题：carl哥说得对，null节点不是叶子节点