waiter123321的博客

LeetCode必刷200题练习记录一、数据结构相关1. 链表1.相交链表给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。public class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { //处理特殊输入 if(headA == null ||

class Solution { private List<List<Integer>> res = new ArrayList<>(); private int count = 0; public int combinationSum4(int[] nums, int target) { Arrays.sort(nums); int[] visited = new int[target + 1];

a || b && c跟a || (b && c)是一样的，因为&&的优先级高于||class Solution { private Map<Integer, Integer> map = new HashMap<>(); public int numDecodings(String s) { if(s.charAt(0) == '0') return 0; r

排序调用CompareToclass Solution { public String largestNumber(int[] nums) { int len = nums.length; String[] tmp = new String[len]; for(int i = 0; i<len; i++){ tmp[i] = String.valueOf(nums[i]); } Array

思路1：插入排序class Solution { public static void merge(int[] nums1, int m, int[] nums2, int n) { //插入排序 把较长的链表看做已排序的 另一个往里面插入 for(int num : nums2){ int i; for(i = m - 1;i >= 0; i--){ if(nums1[i] &g

思路：找规律 分组处理class Solution { public int clumsy(int N) { if(N <= 2) return N; if(N == 3) return 6; int sum = (N) * Math.max(N - 1, 1) / Math.max(N - 2, 1); N -= 3; while(N > 0){

思路：最长递增子序列问题的二维化class Solution { public int maxEnvelopes(int[][] envelopes) { Arrays.sort(envelopes, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o1[0] - o2[0]); int n = envelopes.length;//有多少个信封 int[] dp = new int[n];//前i个元

做过最简单的中等题，纪念一下class Solution { public boolean searchMatrix(int[][] matrix, int target) { int rows = matrix.length; int cols = matrix[0].length; if(matrix[0][0] > target) return false; for(int i = 0; i < rows; i++)

思路：把后（k%length)个节点接到头部class Solution { public ListNode rotateRight(ListNode head, int k) { if (head == null || head.next == null || k == 0) return head; //辅助节点用来遍历长度 ListNode help = head; int len = 1; while(help

class Solution { public ListNode deleteDuplicates(ListNode head) { if(head == null || head.next == null) return head; ListNode next = head.next; if(head.val == next.val){ while(next != null && he

单调栈不熟练class Solution { public boolean find132pattern(int[] nums) { int len = nums.length; int ak = Integer.MIN_VALUE; Deque<Integer> queue = new ArrayDeque<>(); if(len < 3) { return false;

适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中。class Solution { public int evalRPN(String[] tokens) { Deque<Integer> stack = new ArrayDeque<>(); for(String s : tokens){ if(s.equals("+")){ int a = st

public ListNode reverseBetween(ListNode head, int left, int right) { ListNode newhead = new ListNode(), pre = newhead; newhead.next = head; for(int i = 1; i < left; i++){ pre = pre.next; } pre.next = r

动态规划和递归两种方法，但是递归会超时。class Solution { public int numDistinct(String s, String t) { if(s == null || t == null || s.length() < t.length()){ return 0; } int m = s.length(); int n = t.length(); char[]

思路：遍历的过程中处理好上、下、左、右的边界，别越界即可。class Solution { public List<Integer> spiralOrder(int[][] matrix) { List<Integer> res = new LinkedList<>(); int top = 0; int bottom = matrix.length - 1; int left = 0;

评论区看来的思路：把‘#’看成叶子节点，利用叶子节点数 = 非叶子节点数 + 1的特点class Solution { public boolean isValidSerialization(String preorder) { int nodeCount = 1, leafCount = 0; for(char c : preorder.toCharArray()){ if(leafCount > nodeCount - leafC

基本思路：因为运算式中没有括号，所以只需要比较 + - * / 的优先级即可，* / 优先计算后再入栈。class Solution { public int calculate(String s) { char[] arr = s.toCharArray(); int len = arr.length; Deque<Integer> num = new ArrayDeque<>(); Deque<Ch

超时与不超时只在两行代码的差别间class Solution { public int calculate(String s) { int res = 0; int sign = 1; int len = s.length(); char[] ch = s.toCharArray(); Deque<Integer> stack = new ArrayDeque<>(); for(

基础动态规划class Solution { public int minCut(String s) { int n = s.length(); int[] dp = new int[n]; for(int i = 0; i < n; i++){ if(isPalindrome(s,0,i)){ dp[i] = 0; } else {

基本的回溯，但是没有剪枝，下次测试用例再加点变态的估计就要超时了class Solution { public List<List<String>> partition(String s) { List<List<String>> res = new LinkedList<>(); func(s, new LinkedList<>(), res, 0); return res;

class Solution { public int maxProfit(int[] prices) { int n = prices.length; //dp[i][j][k]表示在第i天交易了j次后在k状态下的最大利润 int[][][] dp = new int[n][3][2]; //边界条件 dp[0][0][0] = 0;//第0天交易0次未持有的状态下收益为0 dp[0][0][1] =

又回到最初的起点，这是我做的第一道题，当时提交了44次，而且还是暴力解。但是已经知道用双端队列的方式来解。新年快乐~暴力解class Solution { public int[] maxSlidingWindow(int[] nums, int k) { int max[] = new int[0]; int start = 0; int temp[] = new int[0]; int test = 0; /

思路：总的区间数 - 最大的剩余区间 = 需要移除额最小区间数。所以用贪心的思想。首先按左端点升序排列，然后遍历看有无重叠，如果没有重叠最大剩余区间的计数+1.class Solution { public int eraseOverlapIntervals(int[][] intervals) { int n = intervals.length; if(intervals.length == 0 || intervals[0].length == 0)

class Solution { public int maximalRectangle(char[][] matrix) { if(matrix.length == 0 || matrix[0].length == 0) return 0; int col = matrix[0].length; int row = matrix.length; int res = 0; int[] height

简单的层序遍历我简单的BFS~/** * 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>> zigza

class Solution { public int minCostClimbingStairs(int[] cost) { //动态规划 //dp[i] 表示到达第 i 阶台阶花费的最少体力 int n = cost.length; int[] dp = new int[n]; //边界条件 dp[0] = cost[0]; dp[1] = cost[1]; for(i

class Solution { public String removeDuplicateLetters(String s) { Stack <Character> stack = new Stack<>(); for(int i = 0; i < s.length(); i++){ char c = s.charAt(i); if(stack.contains(c))

贪心算法class Solution { public int maxProfit(int[] prices, int fee) { if(prices.length < 2) return 0; int profit = 0; int min = prices[0]; for(int i = 1; i < prices.length; i++){ if(prices[i] < min){

简单的题我简单的hash~class Solution { public boolean wordPattern(String pattern, String s) { if(pattern == null || s == null) return false; String[] t = s.split(" ");//拆分字符串s if(t.length != pattern.length()) return false; Map&l

思路：从后向前遍历，如果前一位比后一位大，前一位减一。然后把后面的位都置成9。class Solution { public int monotoneIncreasingDigits(int N) { String s = String.valueOf(N); char[] arr = s.toCharArray(); int n = arr.length; int flag = n ; for(int i = n -

把每一个单词都重排序，排序后结果一样的添加到一个集合里。class Solution { public List<List<String>> groupAnagrams(String[] strs) { Map<String, ArrayList<String>> map = new HashMap<>(); for(String s : strs){ char[] c = s.to

思路：利用摆动序列，波峰之后就是波谷，波谷之后就是波峰的特点时间复杂度：O(n)感想：大神真厉害class Solution { public int wiggleMaxLength(int[] nums) { int n = nums.length; if(n < 2) return n; int up = 1; int down = 1; for(int i = 1; i <

方法一class Solution { public int uniquePaths(int m, int n) { //方法一：排列组合 //因为机器人从左上到右下肯定走了m + n - 2步(即m - 1 + n - 1)，只需要看m - 1有多少种情况即可 //C(m + n - 2, m - 1) = (m + n - 2)! / [(m - 1)! * (n - 1)!] double res = 1; fo

class Solution { public List<Integer> splitIntoFibonacci(String S) { List<Integer> res = new LinkedList<>(); return backtrace(S,0,res) ? res : new LinkedList<>(); } public boolean backtrace(String S, int

贪心class Solution { public int matrixScore(int[][] A) { //1.翻转保证第一列都是1 for(int i = 0; i < A.length;i++){ if(A[i][0] == 1){ continue; } else { for(int j = 0; j < A[0].length;

每天的好心情从EZ题开始class Solution { public List<List<Integer>> generate(int numRows) { List<List<Integer>> res = new ArrayList<>(); int[][] arr = new int[numRows][numRows]; for(int i = 0; i < numRows;

二分查找的考察class Solution { public int[] searchRange(int[] nums, int target) { int left = 0; int right = nums.length; int[] result = new int[2]; Arrays.fill(result, -1); while(left < right) { if(targ

1.两数之和的变形，直接mapclass Solution { public int fourSumCount(int[] A, int[] B, int[] C, int[] D) { Map<Integer,Integer> map = new HashMap<>(); for(int a : A){ for(int b : B) map.put(a + b, map.getOrDe

class Solution { public String sortString(String s) { //桶 int[] bucket = new int[26]; //把字符串的字符放入桶内 for(char i : s.toCharArray()) bucket[i - 'a']++; int index = 0; char[] res = new char[s.leng

不考虑完全二叉树的性质class Solution { public int countNodes(TreeNode root) { if(root == null) return 0; return countNodes(root.left) + countNodes(root.right) + 1; }}考虑完全二叉树的性质，可以先分别判断左右子树的高度。如果左子树高度等于右子树，说明左子树是满二叉树，那么左边的节点数就是