di_ko的博客

思路：背包问题，选和不选两种选择代码：二维数组class Solution { public int change(int amount, int[] coins) { int n=coins.length; int[][] dp=new int[n+1][amount+1]; for(int i=0;i<=n;i++){ //余额为0时只有“无为而治”一种解法 dp[i][0]=1; } //注意这里是取得到n的，也取得到amo

思路：进行2次翻转即可：水平翻转+主对角线翻转代码：class Solution { public void rotate(int[][] matrix) { int n=matrix.length; //水平翻转，只遍历行的一半即可 for(int i=0;i<n/2;i++){ for(int j=0;j<n;j++){ int temp=matrix[i][j]; matrix[i][j]=matrix[n-i-1][.

思路：类比84题，是84题的延续：相当于每一层都根据上一层加高度，每一层都算出最大面积代码：

思路：方法一：暴力方法二：循环不变量代码：暴力

思路：优先队列代码：class Solution { public int[] maxSlidingWindow(int[] nums, int k) { int n=nums.length; //int[]数组中0为元素，1为下标 PriorityQueue<int[]> queue=new PriorityQueue<int[]>(new Comparator<int[]>(){ public int compare(in.

思路：使用栈，来存储不大于的温度的下标代码：class Solution { public int[] dailyTemperatures(int[] T) { int n=T.length; Deque<Integer> stack=new ArrayDeque<>(); stack.addLast(0); int[] res=new int[n]; for(int i=1;i<n;i++){ //栈中存的是下标 .

思路：深度优先遍历分别遍历两个二叉树的左节点，右节点，分别相加代码：class Solution { public TreeNode mergeTrees(TreeNode root1, TreeNode root2) { if(root1==null){ return root2; } if(root2==null){ return root1; } TreeNode merge=new TreeNode(root1.val+root2.

思路：1.创建一个新array，保存排好序的数组，逐个比较哪个下标的值变化了2.双指针代码：public class Solution { public int findUnsortedSubarray(int[] nums) { int min=Integer.MAX_VALUE,max=Integer.MIN_VALUE; boolean flag=false; for(int i=1;i<nums.length;i++){ if(nums[.

思路：后序遍历，只是直径指的是边，而不是节点的个数代码：class Solution { int max=0; public int diameterOfBinaryTree(TreeNode root) { depth(root); return max; } private int depth(TreeNode root){ if(root==null){ return 0; } int left=depth(root.left.

思路：借鉴5.最长回文字串的写法代码：class Solution { public int countSubstrings(String s) { int len=s.length(); // if(len<2){ // return 1; // } int count=0; boolean[][] dp=new boolean[len][len]; //初始化 for(int i=0;i<len;i++){ dp[i].

思路：1.前缀和2.前缀和+哈希表代码：前缀和class Solution { public int subarraySum(int[] nums, int k) { int n=nums.length; int sum=0; int[] dp=new int[n+1]; dp[0]=0; //计算前缀和 for(int i=1;i<=n;i++){ //dp[i]代表不包括当前数nums[i]的前缀和 dp[i]=d.

思路：0-1背包问题，回溯（深度优先遍历）代码：class Solution { int count=0; public int findTargetSumWays(int[] nums, int target) { dfs(nums,target,0,0); return count; } private void dfs(int[] nums,int target,int index,int sum){ //index==nums.length表示.

思路：利于一个哈希表，把数据都存起来代码：class Solution { public List<Integer> findDisappearedNumbers(int[] nums) { List<Integer> res=new ArrayList<>(); Map<Integer,Integer> map=new HashMap<>(); for(int num:nums){ map.pu.

思路：0-1背包问题，就是选和不选的关系，动态规划dp代码：public class Solution { public boolean canPartition(int[] nums) { int n=nums.length; int sum=0; //先计算总和 for(int num:nums){ sum+=num; } //总和不能为奇数 if(sum%2==1){ return false;.

思路：先按身高降序排列，如果身高相等，就按人数升序排序代码：class Solution { public int[][] reconstructQueue(int[][] people) { Arrays.sort(people,new Comparator<int[]>(){ public int compare(int[] a,int[] b){ if(a[0]!=b[0]){ //按身高降序 return b[0]-a[0.

思路：双递归代码：class Solution { public int pathSum(TreeNode root, int sum) { //双递归，保证每个节点都作为一次根节点 if(root==null){ return 0; } return res(root,sum)+pathSum(root.left,sum)+pathSum(root.right,sum); } private int res(TreeNode root,int.

思路：位运算，分偶数和奇数2种情况代码：class Solution { public int[] countBits(int num) { int[] dp=new int[num+1]; dp[0]=0; for(int i=1;i<=num;i++){ if(i%2==1){ //奇数,前一个数的结果+1 dp[i]=dp[i-1]+1; } else{ //偶数,与前一个偶数相同 dp[i]=dp[.

思路：小根堆（优先队列）维护前k个元素+哈希表HashMap代码：class Solution { public int[] topKFrequent(int[] nums, int k) { //利于哈希表存储出现的频次 Map<Integer,Integer> map=new HashMap<>(); for(int num:nums){ map.put(num,map.getOrDefault(num,0)+1); } .

思路：动态规划dp，后序遍历（消除后效性）代码：class Solution { public int rob(TreeNode root) { //注意dfs返回的参数是int[]，2个值（根节点偷/不偷），还要比较哪一种比较大 int[] res=dfs(root); return Math.max(res[0],res[1]); } private int[] dfs(TreeNode root){ if(root==null){ ret.

思路：跟287.寻找重复数方法一致，动态规划dp代码：class Solution { public int coinChange(int[] coins, int amount) { int n=coins.length; //要将长度设置为amount+1 int[] dp=new int[amount+1]; //用amount+1的初始化长度来创建dp //目的是判断是否没有数字符合 Arrays.fill(dp,amount+1); .

思路：题目要求不能修改数组nums，也就是不能原地修改并且要求空间复杂度为O（1），表明不能使用哈希表则此题利于位运算或floy算法代码：class Solution { public int findDuplicate(int[] nums) { int f=0,s=0; //第一次循环找到相遇点 while(true){ f=nums[nums[f]]; s=nums[s]; if(f==s){ break; } } .

思路：将不是0的值进行覆盖，再把0添加到最后代码：class Solution { public void moveZeroes(int[] nums) { //index1来记录不为0的值 //index2用来遍历所有值 int index1=0,index2=0; int m=nums.length; for(int num:nums){ if(nums[index2]!=0){ nums[index1++]=num; } .

思路：使用广度优先，设置一个队列、一个记录表代码：class Solution { public int numSquares(int n) { if(n==0||n==1) return n; //创建队列 Queue<Integer> queue=new LinkedList<>(); queue.offer(n); //visited boolean[] visited=new boolean[n]; i.

思路：先通过快慢指针找到中间节点，把后半部分的链表翻转，再和前半部分的链表进行值比较，比较完后将后半部分的链表再翻转回来代码：class Solution { public boolean isPalindrome(ListNode head) { if(head==null){ return true; } ListNode tail=endOfHead(head); ListNode second=reverseList(tail.next); .

思路：后序遍历（递归）代码：class Solution { public TreeNode invertTree(TreeNode root) { if(root==null){ return null; } //后序遍历 TreeNode left=invertTree(root.left); TreeNode right=invertTree(root.right); root.left=right; root.right=left; .

思路：动态规划dp代码：class Solution { public int maximalSquare(char[][] matrix) { int max=0; if(matrix==null||matrix.length==0||matrix[0].length==0){ return max; } int m=matrix.length; int n=matrix[0].length; int[][] dp=new int[m][n].

思路：1.暴力快排Arrays.sort()2.分治（快速排序）代码：class Solution { public int findKthLargest(int[] nums, int k) { int target=nums.length-k; int index=partition(nums,0,nums.length-1,target); return nums[index]; } private int partition(int[] nums,.

思路：主要是插入和搜索的代码繁琐代码：class Trie { private Trie[] children; private boolean isEnd; /** Initialize your data structure here. */ public Trie() { children=new Trie[26]; isEnd=false; } /** Inserts a word into the trie. */ .

思路：广度优先遍历，是拓扑排序，主要是不能出现环利用一个入度表代码：class Solution { public boolean canFinish(int numCourses, int[][] prerequisites) { if(numCourses==0) return false; //这里若数组为空，返回的是true而不是false if(prerequisites.length==0) return true; .

思路：广度优先遍历，将每一块的第一个1加入队列，然后往外扩散开，直到遇到水（0）代码：class Solution { int row; int col; public int numIslands(char[][] grid) { row=grid.length; col=grid[0].length; //四个方位 int[][] directions={{-1,0},{0,-1},{1,0},{0,1}}; //设置marked记录已走.

class Solution { public int rob(int[] nums) { int n=nums.length; if(n==0) return 0; if(n==1) return nums[0]; int[] dp=new int[n]; dp[0]=nums[0]; //注意不是dp[1]=nums[1]，因为还有nums[0] dp[1]=Math.max(dp[0],nums[1]); for(int i=2;i<n;i..

思路：动态规划，但是此题不是使用dp，因为要记录2个数，min和max代码：class Solution { public int maxProduct(int[] nums) { //不能只使用dp，因为max和min都要记录 //imax和imin都初始化为1 int max=Integer.MIN_VALUE,imax=1,imin=1; for(int num:nums){ //当前数是负数时，调换最大和最小数 //因为负数*最小数就是最.

思路：使用一个辅助栈存储最小值，使得栈顶的数值是最小的代码：class MinStack { Deque<Integer> A; Deque<Integer> B; /** initialize your data structure here. */ public MinStack() { A=new ArrayDeque<>(); B=new ArrayDeque<>(); } pu.

思路：归并排序是链表排序的最佳方案，时间复杂度是O(nlogn)的排序算法包括归并排序、堆排序和快速排序（快速排序的最差时间复杂度是O(n^2）代码：class Solution { public ListNode sortList(ListNode head) { if(head==null){ return head; } int length=0; ListNode node=head; while(node!=null){ //...

思路：自定义一个链表+哈希表（哈希不需要自己写）代码：class LRUCache { //自定义一个链表 class DlinkedNode{ int key; int value; DlinkedNode pre; DlinkedNode next; public DlinkedNode(){}; public DlinkedNode(int _key,int _value){ key=_key; value=_value; } } .

思路：快慢指针，这类链表题目一般都是使用双指针法解决的例如：寻找距离尾部第K个节点、寻找环入口、寻找公共尾部入口等代码：public class Solution { public ListNode detectCycle(ListNode head) { if(head==null||head.next==null){ return null; } ListNode slow=head; ListNode fast=head; //第一次相遇.

思路：快慢指针，也就是龟兔赛跑代码：public class Solution { public boolean hasCycle(ListNode head) { if(head==null||head.next==null){ return false; } ListNode slow=head; ListNode fast=head.next; while(slow!=fast){ if(fast==null||fast.next==n.

思路：动态规划，哈希表代码：class Solution { public boolean wordBreak(String s, List<String> wordDict) { //直接放入set中，不用循环 Set<String> set=new HashSet<>(wordDict); boolean[] dp=new boolean[s.length()+1]; //一定要初始化 dp[0]=true; .

思路：位运算代码：class Solution { public int singleNumber(int[] nums) { int res=0; for(int num:nums){ res^=num; } return res; }}分解：1）2）如果先排序后判断，时间复杂度就不是线性的了，例如：Arrays.sort()时间复杂度为O（NlogN）3）也不能用哈希，会有额外空间复杂度分析：...

思路：哈希表代码：class Solution { public int longestConsecutive(int[] nums) { Set<Integer> set=new HashSet<>(); if(nums==null||nums.length==0){ return 0; } //哈希set去重 for(int num:nums){ set.add(num); .