咸鱼之井的博客

/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val = val; } * ListNode(int val, ListNode next) { this.val = val; this.next = next; } * }

前面讲的都很复杂，其实就是每摇一个骰子就更新一下概率，乘1/6class Solution { public double[] dicesProbability(int n) { double[] res = new double[6]; Arrays.fill(res,1.0/6.0); for(int i=2; i<=n; i++){ double[] tmp = new double[5*i+1];

归并的思路是看懂了，但是写起来还是很迷茫class Solution { int[] nums,tmp; public int reversePairs(int[] nums) { this.nums = nums; tmp = new int[nums.length]; return manage(0,nums.length-1); } public int manage(int l,int r){ if(l

思路是对的，但是找count的时候，和n-1的细节处理要注意class Solution { public int findNthDigit(int n) { int digit=1; long count=9; long start=1; while(n>count){ n-=count; start*=10; digit++; c

这题看着简单，但是这个算每一位1个数的公式还是没有很推明白再慢慢想想吧class Solution { public int countDigitOne(int n) { int digit = 1, res = 0; int high = n/10, cur = n%10, low = 0; while(high !=0 || cur !=0){ if(cur == 0){ res += h

丑数，算是看明白递归了，只是之前没想好怎么递归class Solution { public int nthUglyNumber(int n) { int a=1,b=1,c=1; int[] dp = new int[n+1]; dp[1]=1; for(int i=2; i<=n; i++){ dp[i] = Math.min(Math.min(dp[a]*2,dp[b]*3),dp[c]*5);

递归回溯还没太想明白为什么用交换函数就可以实现排列class Solution { List<String> res = new LinkedList<>(); char[] c; public String[] permutation(String s) { c = s.toCharArray(); dfs(0); return res.toArray(new String[res.size()]);

递归写法class Solution { public boolean isMatch(String s, String p) { if(s.length() == 0){ if(p.length()%2 !=0 ) return false; for(int i=1; i<p.length(); i+=2){ if(p.charAt(i) != '*') return false;

思路是对的，用层序遍历解决但是层序遍历反推二叉树需要再熟悉一下/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */public class Codec { // Encodes a tree to a

大概的思路是对的，但是没有找到合适的数据结构注意判断弹出值是否相等的时候不能用==，要用equals，但是没想明白为什么class MaxQueue { Queue<Integer> q; Deque<Integer> dq; public MaxQueue() { q = new LinkedList<>(); dq = new LinkedList<>(); } publ

单调队列，滑动窗口思路还是要再缕清楚一些class Solution { public int[] maxSlidingWindow(int[] nums, int k) { if(nums.length==0||k==0) return new int[0]; int len = nums.length; Deque<Integer> q = new LinkedList<>(); int[] res =

java的int大小：-2147483648——2147483647这道题主要的难点是怎么判断出界class Solution { public int strToInt(String str) { int len = str.length(); int index = 0; int hasflag = 1; int res = 0; int bndry = Integer.MAX_VALUE / 10;

字符串的题就是很麻烦class Solution { public boolean isNumber(String s) { int len = s.length(); int index = 0; int hasE = 0, hasnum = 0, hasflag = 0, hasdot = 0; while(index<len&&s.charAt(index)==' ') index++; w

用一个辅助栈来解决问题不要想的太复杂class Solution { public boolean validateStackSequences(int[] pushed, int[] popped) { Stack<Integer> res = new Stack<>(); int i=0; for(int num : pushed){ res.push(num); whil

所谓的模拟就是，按想法写出来？注意定义的上下左右不是长度，是边界class Solution { public int[] spiralOrder(int[][] matrix) { if(matrix == null || matrix.length == 0) return new int[0]; int row = matrix.length, col = matrix[0].length; int[] res = new in

约瑟夫环问题反正是数学规律回推class Solution { public int lastRemaining(int n, int m) { int ans = 0; for(int i=2; i<=n; i++){ ans = (ans+m)%i; } return ans; }}

滑动窗口写法只能向右走，注意sum加减的顺序class Solution { public int[][] findContinuousSequence(int target) { List<int[]> res = new ArrayList<>(); int i=1, j=2, sum=3; while(i<j){ if(sum < target){ j

只看懂了贪心的写法动规的没太看明白class Solution { public int cuttingRope(int n) { if(n < 4) return n-1; int res = 1; while(n>4){ res *= 3; n -= 3; } return res*n; }}...

构建上下两个三角数组分别循环乘注意下标的问题class Solution { public int[] constructArr(int[] a) { int len = a.length; int[] b = new int[len]; if(len == 0) return b; b[0] = 1; for(int i=1; i<len; i++){ b[i] = b[i-

位操作还有很多地方需要细想class Solution { public int[] singleNumbers(int[] nums) { int n = 0; for(int num : nums){ n ^= num; } int m = 1; while((n&m)==0) m <<= 1; int x=0,y=0;

统计尾数，不能整除三的说明此位为1更新结果时也要左移 用或 |=class Solution { public int singleNumber(int[] nums) { int res = 0; for(int i=0; i<32; i++){ int cun = 0; for(int j=0; j<nums.length; j++){ cun += (nums[j]&

用异或和与左移，实现加法class Solution { public int add(int a, int b) { while(b != 0){ int c = (a&b)<<1; a ^= b; b = c; } return a; }}这样写，结果好像是对的，但是稍微大一点就超时了，，还不是很理解class Solutio

& 相同为1，不同为0，注意判断条件不能用>0，因为java存在负号的可能性，无符号位移用>>>public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { int res = 0; while(n!=0){ if((n&

二叉搜索树，后序遍历写树，就左右判断class Solution { public boolean verifyPostorder(int[] postorder) { return recur(postorder,0,postorder.length-1); } boolean recur(int[] postorder, int i, int j){ if(i>=j) return true; int p = i;

自己想不出来只能说学习一下寻找最近公共祖先的写法了/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeNode lowestCommonAnces

二叉搜索树自己学会了思路，但是写的时候出错，因为递归时需要加return/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public TreeNode lowest

不能用乘除法，和循环之类的，所以公式求和不行class Solution { public int sumNums(int n) { return (1+n)*n/2; }}递归需要判断，用&& || 的短路法class Solution { int res = 0; public int sumNums(int n) { boolean x = n > 1 && sumNums(n-1)>

快速幂；看下来其实就是幂运算拆成位运算的方法精简class Solution { public double myPow(double x, int n) { if(x==0) return 0; long b = n; if(b < 0){ x = 1/x; b = -b; } double res = 1.0; while(b>0){

时间复杂度比较高的一种写法，但是思路能想到，就是一层一层判断当前节点是否平衡。题解称之为先序遍历/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { public bool

递归参数的理解还是不到位/** * 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

主要思路是会用大顶堆和小顶堆，因为题意是保持排序，取中间值，刚好用两个堆来维持中间值。注意堆的更新class MedianFinder { /** initialize your data structure here. */ Queue<Integer> minQ,maxQ; public MedianFinder() { minQ = new PriorityQueue<>(); maxQ = new PriorityQ

一开始没看明白题意，其实就是找除了0意外的数字，相差不大于5，等于五也不行还有一个排序的方法也可class Solution { public boolean isStraight(int[] nums) { int minn = 0,maxn = 0; Set<Integer> set = new HashSet<>(); for(int i=0; i<nums.length; i++){ i

可以用冒泡，也可以用快排，改写内置函数class Solution { public String minNumber(int[] nums) { String strs[] = new String[nums.length]; for(int i=0; i<nums.length; i++) strs[i] = String.valueOf(nums[i]); Arrays.sort(strs,(x,y)->(x

思路还是差不多对的，但是其他参数的控制需要考虑清楚/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */class Solution { int res,index = 0; public int

能想到是中序遍历，但是链表的构造没有想到题解是类似指针标记/*// Definition for a Node.class Node { public int val; public Node left; public Node right; public Node() {} public Node(int _val) { val = _val; } public Node(int _val,Node _left,Node

思路是对的，但是路径在递归里的循环和存储需要注意/** * 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 l

HashMap方法class Solution { public int majorityElement(int[] nums) { int len = nums.length; Map<Integer,Integer> map = new HashMap<>(); for(int i=0; i<len; i++){ map.put(nums[i],map.getOrDefault(nums[i]

整体思路倒是大差不差，注意标记和细节class Solution { int res = 0; public int movingCount(int m, int n, int k) { boolean[][] visited = new boolean[m][n]; dfs(m,n,visited,k,0,0); return res; } void dfs(int m, int n,boolean[][] visited

自己思路的双指针指的不对，超时了，要前后相撞指针，排除法class Solution { public int[] twoSum(int[] nums, int target) { int[] res = new int[2]; if(nums.length == 0 || target <= nums[0]) return null; int i=0,j=nums.length - 1; while(i<j){

双指针，思路是对的，判断条件要注意class Solution { public int[] exchange(int[] nums) { //int[] res = new int[nums.length]; int i = 0, j = nums.length - 1; while(i<j){ while(i<j&&nums[i]%2!=0) i++; while(i&l