题记

  1. 感觉说的挺好的,值得学习
  2.  
  3. 1 版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
  4. 本文链接:https://blog.csdn.net/liujiaqi12345/article/details/88357041
  5. Leetcode JAVA 题解: https://github.com/mJackie/leetcode
  6. 自己日常刷题经过是这样的:
  7.  
  8. 拿到题目,看一眼Difficulty,然后自己思考一下解题思路。如果解不出来,就记下在哪里卡住了,难点在哪。
  9. 如果对应的题目有Solution,就看Solution,没有的话就点Discuss,按Most Votes排序,看排名最高的解法。
  10. 对比一下自己的解法与最优的解法的差别,总结一下为什么没想起来,记录下来这个思考的过程。
  11. 关掉别人的代码,开始CodingDebugSubmit
  12. 附上自己总结的几条经验:
  13.  
  14. 先刷两个Top专题。Leetcode 上有个List选项,里边有两个专题,分别是Top 100 Liked QuestionsTop Interview Questions。这两个List中有很多重复的题,加起来一共150道左右。都是经典的题目,将这150道刷完基本上所有的题型都见过了,而且多数经典题目都会涉及,是提升最快的一个方法。
  15.  
  16. 注意记录、总结与复习。自己写过的代码一定要保存下来,刷题的时候也要记下主要思路和注意点,这样在复习的时候也能对比发现自己哪里还能改进,之前犯得错误有没有重犯。可以将相互关联的题目对比着一起看,方便总结与记忆。一定要时常复习刷过的题,复习比一味的追求数量更重要。
  17.  
  18. 做好Easy,没必要死扣HardLeetCode上很多Easy的题目看似简单,实则想要写出Perfect的代码并非易事。多思考如何优化EasyMedium的解法实际上比花精力解Hard题更能提高自己。况且面试的时候Hard被问的概率太小了。
  19.  
  20. 切忌眼高手低。不要想着自己知道思路解法了就是会了,一定要亲自Coding,手撸出来。我在刷的过程中就经常在Debug的时候才发现自己忘记考虑了某些条件。不把代码写出来,只看别人的答案对自己是没有多大的提高的,只有亲自AC了题目,才能算做过一道题。
  21. ————————————————
  22. 版权声明:本文为CSDN博主「Jackie.Liu」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
  23. 原文链接:https://blog.csdn.net/liujiaqi12345/article/details/88357041

还有这注释方式也不错,学习

  • 语言: Java

  • 说明: 每道题在代码头部都添加了我的解题思路和批注,Eg:

    1. /*****
    2. * 287. Find the Duplicate Number
    3. * 题意:n+1个数属于[1~n],找出重复的那个数
    4. * 难度:Medium
    5. * 分类:Array, Two Pointers, Binary Search
    6. * 思路:如果nums[i]不在对应位置,则和对应位置交换。如果对应位置上也为该数,说明这个数就是重复的数字。这个方法改变了数组。是错误的。
    7. * 另一种方法,把问题转换成有环链表,找环的起始节点。O(n) O(1) lc142
    8. * 二分查找,每次看一边数字的个数, O(nlog(n)) O(1)
    9. * Tips:剑指offer原题
    10. */
  •  

  1.  

1. 两数之和

  1. 1 public int[] twoSum(int[] nums, int target) {
  2. 2 int[] result = new int[2];
  3. 3 Map<Integer, Integer> map = new HashMap<Integer, Integer>();
  4. 4 for (int i = 0; i < nums.length; i++) {
  5. 5 if (map.containsKey(target - nums[i])) {
  6. 6 result[1] = i;
  7. 7 result[0] = map.get(target - nums[i]);
  8. 8 return result;
  9. 9 }
  10. 10 map.put(nums[i], i);
  11. 11 }
  12. 12 return result;
  13. 13
  14. 14 }
  15. 15

2. Add Two Numbers

  1. /**
  2. * Input: (2 -> 4 -> 3) + (5 -> 6 -> 4) Output: 7 -> 0 -> 8 Explanation: 342 +
  3. * 465 = 807
  4. *
  5. * 题意:对于俩个链表。对应节点相加,满十进一
  6. * 思路:先判断对应节点是否至少存在一个有值,有则相加,然后移动节点向下,循环如此,如果说最后一次相加,进位(carry)不为0,则要显示,其次,返回值要从返回链表的第二个几点开始
  7. *
  8. * @param l1
  9. * @param l2
  10. * @return
  11. */
  12. public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
  13. ListNode resultNode = new ListNode(0);
  14. ListNode p = l1, q = l2, curr = resultNode;
  15. int carry = 0;
  16. while (p != null || q != null) {
  17. int x = p != null ? p.val : 0;
  18. int y = q != null ? q.val : 0;
  19. int sum = x + y + carry;
  20. carry = sum / 10;
  21. curr.next = new ListNode(sum % 10);
  22. curr = curr.next;
  23. if (p != null) {
  24. p = p.next;
  25. }
  26. if (q != null) {
  27. q = q.next;
  28. }
  29. }
  30. if (carry > 0) {
  31. curr.next = new ListNode(carry);
  32. }
  33. return resultNode.next;
  34. }

3. Longest Substring Without Repeating Characters

  1. 1 public static void main(String[] args) {
  2. 2 String s = "abbabc";
  3. 3 System.out.println(lengthOfLongestSubstring(s));
  4. 4 }
  5. 5
  6. 6 public static int lengthOfLongestSubstring(String s) {
  7. 7 int max = 0;
  8. 8 // ”记录当前重复字母的最新位置“
  9. 9 int j = 0;
  10. 10 HashMap<Character, Integer> resultMap = new HashMap<Character, Integer>();
  11. 11 for (int i = 0; i < s.length(); i++) {
  12. 12 if (resultMap.containsKey(s.charAt(i))) {
  13. 13 j = Math.max(resultMap.get(s.charAt(i)) + 1, j);
  14. 14 }
  15. 15 //”当前位置-上次重复的最大位置+1“
  16. 16 max = Math.max(i - j + 1, max);
  17. 17 resultMap.put(s.charAt(i), i);
  18. 18 }
  19. 19
  20. 20 return max;
  21. 21 }

7. 整数反转

  1. 1 public int reverse(int x) {
  2. 2 int ans = 0;
  3. 3 while (x != 0) {
  4. 4 int pop = x % 10;
  5. 5 if (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && pop > 7))
  6. 6 return 0;
  7. 7 if (ans < Integer.MIN_VALUE / 10 || (ans == Integer.MIN_VALUE / 10 && pop < -8))
  8. 8 return 0;
  9. 9 ans = ans * 10 + pop;
  10. 10 x /= 10;
  11. 11 }
  12. 12 return ans;
  13. 13 }
  14. 14

8. String to Integer (atoi)

  1. public static int myAtoi(String str) {
  2.  
  3. // 1字符串非空判断 ""||" "
  4. if (str.isEmpty() || str.trim().isEmpty()) {
  5. return 0;
  6. }
  7.  
  8. int index = 0;
  9. int sign = 1;
  10. int total = 0;
  11. //1检测第一个非空字符串是什么
  12. while (str.charAt(index) == ' ' && index < str.length()) {
  13. index++;
  14. }
  15.  
  16. //1判断这个数是正数还是负数
  17. if (str.charAt(index) == '+' || str.charAt(index) == '-') {
  18. sign = str.charAt(index) == '+' ? 1 : -1;
  19. index++;
  20. }
  21.  
  22. //1判断是否是数字,是否越界,如果越界就取越界的边界值
  23. while (index < str.length()) {
  24. int digit = str.charAt(index) - '0';
  25. if (digit < 0 || digit > 9) {

11. Container With Most Water

  1. /**
  2. * 解法1:俩边的边为起点,进行计算,如果左边的边比右边的小,左边第二条边和当前右边的边进行计算,如果右边的边小于左边的边,则右边的第二条便进行计算,依此类推
  3. *
  4. * @param height
  5. * @return
  6. */
  7. public static int maxArea(int[] height) {
  8. int i = 0, j = height.length - 1, res = 0;
  9. while (i < j) {
  10. // ‘取最大值’
  11. res = Math.max(res, Math.min(height[i], height[j]) * (j - i));
  12. if (height[i] < height[j]) {
  13. i++;
  14. } else {
  15. j--;
  16. }
  17. }
  18. return res;
  19. }
  20.  
  21. /**
  22. * 解法2 遍历所有的可能结果n(n-1)/2中情况
  23. *
  24. * @param height
  25. * @return
  26. */
  27. public int maxArea1(int[] height) {
  28. int max = 0;
  29. for (int i = 0; i < height.length; i++) {
  30. for (int j = i + 1; j < height.length; j++) {
  31. max = Math.max(max, Math.min(height[i], height[j]) * (j - i));
  32. }
  33. }
  34.  
  35. return max;
  36. }

17. Letter Combinations of a Phone Number

  1. public static List<String> letterCombinations(String digits) {
  2. List<String> ret = new ArrayList<String>();
  3. Map<Character, String> map = new HashMap<Character, String>() {
  4. {
  5. put('2', "abc");
  6. put('3', "def");
  7. put('4', "ghi");
  8. put('5', "jkl");
  9. put('6', "mno");
  10. put('7', "pqrs");
  11. put('8', "tuv");
  12. put('9', "wxyz");
  13. }
  14. };
  15.  
  16. //‘非空校验’
  17. if (digits == null || "".equals(digits)) {
  18. return ret;
  19. }
  20. dfs(digits, 0, "", map, ret);
  21.  
  22. return ret;
  23. }
  24.  
  25. public static void dfs(String digits, int idx, String path, Map<Character, String> map, List<String> ret) {
  26. if (digits.length() == path.length()) {
  27. ret.add(path);
  28. return;
  29. }
  30. //‘循环配合递归’
  31. for (int i = idx; i < digits.length(); i++) {
  32. for (char c : map.get(digits.charAt(i)).toCharArray()) {//这里是第个数字的对应的字母
  33. dfs(digits, i + 1, path + c, map, ret);//这里进行递归,对应的第二个数字的循环,和第一个字母进行拼接
  34. }
  35. }
  36. }

19. Remove Nth Node From End of List

  1. public class ListNode {
  2. int val;
  3. ListNode next;
  4.  
  5. ListNode(int x) {
  6. val = x;
  7. }
  8.  
  9. /**
  10. *‘本题思路:建立俩个链表,一个是dummy,复制原链表,另一个链表(first)为了计算链表长度;然后在用first链表指向dummy,删掉指定位置的元素’
  11. *‘注意,应为是dummy指向head,所以多了一个节点,在指定删除位置时不用减一;另外返回时应该返回dummy.next,第一个节点是我们自己定义的’
  12. * @param head
  13. * @param n
  14. * @return
  15. */
  16. public static ListNode removeNthFromEnd(ListNode head, int n) {
  17. ListNode dummy = new ListNode(0);
  18. dummy.next = head;
  19. ListNode first = head;
  20. int length = 0;
  21. while (first != null) {
  22. length++;
  23. first = first.next;
  24. }
  25. int position = length - n;
  26. first = dummy;
  27. while (position > 0) {
  28. position--;
  29. first = first.next;
  30. }
  31. first.next = first.next.next;
  32. return dummy.next;
  33.  
  34. }
  35.  
  36. public static void main(String[] args) {
  37. ListNode a1 = new ListNode(1);
  38. ListNode a2 = new ListNode(2);
  39. ListNode a3 = new ListNode(3);
  40. ListNode a4 = new ListNode(4);
  41. ListNode a5 = new ListNode(5);
  42. a1.next = a2;
  43. a2.next = a3;
  44. a3.next = a4;
  45. a4.next = a5;
  46. ListNode a6 = removeNthFromEnd(a1, 2);
  47. while (a6 != null) {
  48. System.out.println(a6.val);
  49. a6 = a6.next;
  50. }
  51. }
  52. }

20. Valid Parentheses

  1. /**
  2. * 题意:括号匹配,俩个匹配的括号之间是不允许有为匹配(也就是单个的)括号
  3. * 解题思路:通过入栈的形式,如果未匹配就入栈,匹配就出栈,最后如果栈不为空或者栈顶元素不当前元素不匹配就返回false
  4. *
  5. * @param s
  6. * @return
  7. */
  8. public static boolean isValid(String s) {
  9. Stack<Character> stack = new Stack<Character>();
  10. for (char c : s.toCharArray()) {
  11. if (c == '(') {
  12. stack.push(')');
  13. } else if (c == '[') {
  14. stack.push(']');
  15. } else if (c == '{') {
  16. stack.push('}');
  17. } else if (stack.isEmpty() || stack.pop() != c) {
  18. return false;
  19. }
  20. }
  21. return stack.isEmpty();
  22. }
  23.  
  24. public static void main(String[] args) {
  25. System.out.println(isValid("["));
  26. }

21. Merge Two Sorted Lists

  1. int val;
  2. ListNode next;
  3.  
  4. ListNode(int x) {
  5. val = x;
  6. }
  7.  
  8. /**
  9. * 本题思路:‘将当前节点l1.next和L2的当前节点(第一个节点)进行比较,如果小于等于(注意:等于也是可以的),继续往下走,反之则进行节点替换(l1.next和l2进行替换),当l2为null时(也就是l1.next=null)结束循环’
  10. * @param l1
  11. * @param l2
  12. * @return
  13. */
  14. public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
  15. if (l1 == null) {
  16. return l2;
  17. }
  18. if (l2 == null) {
  19. return l1;
  20. }
  21. //此处是为了保证第一个节点时最小值
  22. ListNode tmp;
  23. if (l1.val > l2.val) {
  24. tmp = l2;
  25. l2 = l1;
  26. l1 = tmp;
  27. }
  28. ListNode newListNode = l1;
  29. while (l2 != null) {
  30. //遍历节点进行组合
  31. while (newListNode.next != null && newListNode.next.val <= l2.val) {
  32. newListNode = newListNode.next;
  33. }
  34. //比较排序
  35. tmp = newListNode.next;
  36. newListNode.next = l2;
  37. l2 = tmp;
  38. }
  39. return l1;
  40.  
  41. }
  42.  
  43. //展示当前链表的值
  44. public static void sysoListNode(ListNode l1) {
  45. while (l1 != null) {
  46. System.out.format("%d->", l1.val);
  47. l1 = l1.next;
  48. }
  49. System.out.println("===================");
  50. }
  51.  
  52. /**
  53. * 大神的解法:原理和上面一样,只是利用递归的原理
  54. * @param l1
  55. * @param l2
  56. * @return
  57. */
  58. public static ListNode mergeTwoLists2(ListNode l1, ListNode l2) {
  59. if (l1 == null)
  60. return l2;
  61. if (l2 == null)
  62. return l1;
  63. if (l1.val < l2.val) {
  64. l1.next = mergeTwoLists(l1.next, l2);
  65. //此处时为了更直观看当前链表的状态
  66. sysoListNode(l1);
  67. sysoListNode(l2);
  68. return l1;
  69. } else {
  70. l2.next = mergeTwoLists(l1, l2.next);
  71. //此处时为了更直观看当前链表的状态
  72. sysoListNode(l1);
  73. sysoListNode(l2);
  74. return l2;
  75. }
  76. }
  77.  
  78. //测试数据
  79. public static void main(String[] args) {
  80. ListNode l1 = new ListNode(1);
  81. ListNode l2 = new ListNode(2);
  82. ListNode l3 = new ListNode(4);
  83. l1.next = l2;
  84. l2.next = l3;
  85.  
  86. ListNode r1 = new ListNode(1);
  87. ListNode r2 = new ListNode(3);
  88. ListNode r3 = new ListNode(4);
  89. r1.next = r2;
  90. r2.next = r3;
  91.  
  92. mergeTwoLists(l1, r1);
  93.  
  94. }

  1. 26 break;
  2. 27 }
  3. 28
  4. 29 if (Integer.MAX_VALUE / 10 > total
  5. 30 || (Integer.MAX_VALUE / 10 == total && Integer.MAX_VALUE % 10 >= digit)) {
  6. 31 total = total * 10 + digit;
  7. 32 index++;
  8. 33 } else {
  9. 34 return sign > 0 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
  10. 35 }
  11. 36 }
  12. 37 return total * sign;
  13. 38
  14. 39 }

20. 有效的括号

  1. 1 class Solution {
  2. 2 public boolean isValid(String s) {
  3. 3 int n = s.length();
  4. 4 for (int i = 0; i < n / 2; i++) {
  5. 5 if (s.contains("{}"))
  6. 6 s = s.replace("{}", "");
  7. 7 if (s.contains("()"))
  8. 8 s = s.replace("()", "");
  9. 9 if (s.contains("[]"))
  10. 10 s = s.replace("[]", "");
  11. 11 }
  12. 12 if ("".equals(s)) {
  13. 13 return true;
  14. 14 }
  15. 15 return false;
  16. 16 }
  17. 17 }

26. Remove Duplicates from Sorted Array

  1. 1 public static int removeDuplicates(int[] nums) {
  2. 2 int count = 1;
  3. 3 for (int i = 1; i < nums.length; i++) {//用当前的数字和上一个被比较的数字进行比较,如果大于他就替换,本题默认一排序
  4. 4 if (nums[i] > nums[count - 1]) {
  5. 5 nums[count++] = nums[i];
  6. 6 }
  7. 7 }
  8. 8 return count;
  9. 9
  10. 10 }

27. Remove Element

  1. 1 public static int removeElement(int[] nums, int val) {
  2. 2 if (nums == null) {
  3. 3 return -1;
  4. 4 } else if (nums.length == 0) {
  5. 5 return 0;
  6. 6 } else {
  7. 7 int count = 0;//统计几个不相同,同时作为新数组的下标
  8. 8 for (int i = 0; i < nums.length; i++) {
  9. 9 if (nums[i] != val) {
  10. 10 nums[count++] = nums[i];//注意count++的执行顺序
  11. 11 }
  12. 12 }
  13. 13 return count;
  14. 14 }
  15. 15
  16. 16 }

41. First Missing Positive

  1. 1 public static int firstMissingPositive(int[] nums) {
  2. 2 if (nums.length == 0) {
  3. 3 return 1;
  4. 4 }
  5. 5
  6. 6 Set<Integer> numsSet = new HashSet<Integer>();
  7. 7 for (int i = 0; i < nums.length; i++) {
  8. 8 if (nums[i] < 1) {
  9. 9 continue;
  10. 10 } else {
  11. 11 numsSet.add(nums[i]);
  12. 12 }
  13. 13 }
  14. 14 List<Integer> numsList = new ArrayList<Integer>();
  15. 15 numsSet.forEach(n -> numsList.add(n));
  16. 16
  17. 17 // 1筛选过后的数组为空
  18. 18 if (numsList.size() == 0) {
  19. 19 return 1;
  20. 20 }
  21. 21
  22. 22 numsList.sort((a, b) -> a.compareTo(b.intValue()));
  23. 23
  24. 24 int index = 0;// 1当前数组下标
  25. 25 for (int i = 1;; i++) {
  26. 26 // 1预防数组越界
  27. 27 if (index < numsList.size() && numsList.get(index) == i) {
  28. 28 index++;
  29. 29 } else {
  30. 30 return i;
  31. 31 }
  32. 32 }
  33. 33
  34. 34 }

46. Permutations

  1. /**
  2. * 本题目标:对于给定数组列出所有的可能排列组合
  3. * 实现方法:利用递归的思路
  4. * 举个例子,当数组为【1,2,3】;先考虑第一个数为1时,后面的可能性,以此类推
  5. * 注意:后面的可能性要以递归的思路去考虑,或者入栈出栈的思路。
  6. * @param nums
  7. * @return
  8. */
  9. public static List<List<Integer>> permute(int[] nums) {
  10. List<List<Integer>> list = new ArrayList<>();
  11. // Arrays.sort(nums); // not necessary
  12. backtrack(list, new ArrayList<>(), nums);
  13. return list;
  14. }
  15.  
  16. private static void backtrack(List<List<Integer>> list, List<Integer> tempList, int[] nums) {
  17. if (tempList.size() == nums.length) {
  18. //注意这里的细节,是新声明一个集合去保存这个值,如果用tempList会导致最后list为空,原因就是堆被清空啦
  19. list.add(new ArrayList<Integer>(tempList));
  20. } else {
  21. for (int i = 0; i < nums.length; i++) {
  22. if (tempList.contains(nums[i])) {
  23. continue;
  24. } else {
  25. tempList.add(nums[i]);
  26. //注意是循环中调用递归
  27. backtrack(list, tempList, nums);
  28. //小算法,清空当前递归中的最后一个值
  29. tempList.remove(tempList.size() - 1);
  30. }
  31. }
  32.  
  33. }
  34. }

48. Rotate Image

  1. /**
  2. * 本体题意:顺时针反转90度
  3. * 解题方法:找出通项公式
  4. * @param matrix
  5. */
  6. public static void rotate(int[][] matrix) {
  7. int n = matrix.length;
  8. int[][] rotate = new int[n][n];
  9. for (int i = 0; i < n; i++) {
  10. for (int j = 0; j < n; j++) {
  11. //通项公式
  12. rotate[i][j] = matrix[n - 1 - j][i];
  13. }
  14. }
  15. for (int i = 0; i < n; i++) {
  16. for (int j = 0; j < n; j++) {
  17. //重新赋值
  18. matrix[i][j] = rotate[i][j];
  19. }
  20. }
  21. }

49. Group Anagrams

  1. /**
  2. * 本题题意:将含有相同字母的字符串归类
  3. *
  4. * 解法:将字符串拆分成字符,然后排序作为key,最后map转化成list
  5. */
  6. public static List<List<String>> groupAnagrams(String[] strs) {
  7. if (strs.length == 0) {
  8. return new ArrayList<List<String>>();
  9. }
  10. Map<String, List<String>> map = new HashMap<String, List<String>>();
  11. for (String s : strs) {
  12. char[] chars = s.toCharArray();
  13. Arrays.sort(chars);
  14. String key = String.valueOf(chars);
  15. if (!map.containsKey(key)) {
  16. map.put(key, new ArrayList<String>());
  17. }
  18. map.get(key).add(s);
  19. }
  20. return new ArrayList<List<String>>(map.values());
  21.  
  22. }

53. Maximum Subarray

  1. /**
  2. * 题意:找出一组 最大的数组和,作为结果的数组长度不限但小于等于给定的数组
  3. * 解决方法:二步;
  4. * 第一步找到当前最大(通过(当前最大的+a[i+1]) + a[i+1]比较,找出最大的)(类似贪心)
  5. * 第二步找到当前最大的和之前最大的进行比较,选出最大的
  6. * 注意:maxSum初始值一定要定义最小,可能为负数,如果初始化成0就不行啦
  7. * @param A
  8. * @return
  9. */
  10. public static int maxSubArray(int[] A) {
  11. if (A == null || A.length == 0) {
  12. throw new IllegalArgumentException();
  13. }
  14. // ‘记录当前数据的最大值’;‘理解成新生成的最大值 和 旧的(已知的最大值比较)’
  15. int maxSum = Integer.MIN_VALUE;
  16. // ‘记录(当前)和(当前加下一位)的最大值’
  17. int maxCurrentSum = 0;
  18. for (int i = 0; i < A.length; i++) {
  19. maxCurrentSum = Math.max(maxCurrentSum + A[i], A[i]);
  20. maxSum = Math.max(maxCurrentSum, maxSum);
  21. }
  22. return maxSum;
  23.  
  24. }
  25.  
  26. /**
  27. * 这个解决思路很好,也很好理解
  28. * 解决思路:‘如果上一次结果为负数,则上一次结果置0,加下一次数’
  29. * 也不需要考虑最小值的问题啦
  30. * @param nums
  31. * @return
  32. */
  33. public static int maxSubArray2(int[] nums) {
  34. int max = nums[0], tmp = max;
  35. for (int i = 1; i < nums.length; i++) {
  36. if (tmp < 0) tmp = 0;//‘精髓’
  37. tmp += nums[i];
  38. max = Math.max(tmp, max);
  39. }
  40. return max;
  41. }
  42.  
  43. public static void main(String[] args) {
  44. int[] a = {-1,1};
  45. System.out.println(maxSubArray2(a));
  46. }

55. Jump Game

  1. /**
  2. * 题意:从a[0]开始跳转当前索引对应数值的步数,看能否跳到最后一步 解题方法:通过
  3. * (i(当前索引)+nums[i](能跳转的最大长度))和当前索引进行比较;如果可达到的位置小于当前位置;则可以判断不可到达
  4. *
  5. * @param nums
  6. * @return
  7. */
  8. public static boolean canJump(int[] nums) {
  9. int reachable = 0;
  10. for (int i = 0; i < nums.length; i++) {
  11. if (i > reachable) {
  12. return false;
  13. }
  14. // i(当前索引)+nums[i](能跳转的最大长度)
  15. reachable = Math.max(reachable, i + nums[i]);
  16. }
  17. return true;
  18. }
  19.  
  20. public static void main(String[] args) {
  21. int[] nums = { 3, 2, 1, 0, 4 };// false
  22. // int[] nums = { 2, 3, 1, 1, 4 };//true
  23. canJump(nums);
  24. }

75. Sort Colors

  1. /**
  2. * 题目:‘将红白蓝归类排序;其实就是012归类排序’
  3. * 解决方法:‘我这里用的冒泡排序,可以尝试一下别的排序方法’
  4. * @param nums
  5. */
  6. public static void sortColors(int[] nums) {
  7. //‘注意下标’
  8. for (int i = 0; i < nums.length - 1; i++) {
  9. //‘注意下标’
  10. for (int j = 0; j < nums.length - 1; j++) {
  11. if (nums[j] > nums[j + 1]) {
  12. int temp = nums[j];
  13. nums[j] = nums[j + 1];
  14. nums[j + 1] = temp;
  15. }
  16. }
  17. }
  18. }
  19.  
  20. public static void main(String[] args) {
  21. int[] nums = { 2, 0, 2, 1, 1, 0 };
  22. sortColors(nums);
  23. for (int i = 0; i < nums.length; i++) {
  24. System.out.println(nums[i]);
  25. }
  26. }

78. Subsets

  1. import java.util.ArrayList;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4.  
  5. /**
  6. * Given a set of distinct integers, nums, return all possible subsets (the
  7. * power set).
  8. *
  9. * Note: The solution set must not contain duplicate subsets.
  10. *
  11. * Example:
  12. *
  13. * Input: nums = [1,2,3] Output: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2],[]]
  14. *
  15. *给予一个不重复的整数集合,返回所有的可能的子集
  16. */
  17. public class Lc78 {
  18.  
  19. public static void main(String[] args) {
  20. int[] nums = new int[3];
  21. for (int i = 0; i < 3; i++) {
  22. nums[i] = i + 1;
  23. }
  24.  
  25. for (List<Integer> lists : subsets2(nums)) {
  26. for (Integer i : lists) {
  27. System.out.print(i);
  28. }
  29. System.out.println();
  30. }
  31. }
  32.  
  33. /**
  34. * 利用深度优先搜索(dfs)
  35. */
  36. private static List<List<Integer>> results = new ArrayList<>();
  37.  
  38. public static List<List<Integer>> subsets2(int[] nums) {
  39. dfs(nums, 0, new LinkedList<>());
  40. return results;
  41. }
  42.  
  43. private static void dfs(int[] nums, int start, LinkedList<Integer> list) {
  44. results.add(new ArrayList<>(list));
  45. for (int i = start; i < nums.length; i++) {
  46. list.addLast(nums[i]);
  47. dfs(nums, i + 1, list);
  48. //遍历之后删除该节点避免重复
  49. list.removeLast();
  50. }
  51. }
  52.  
  53. }

80. Remove Duplicates from Sorted Array II

  1. 1 public static int removeDuplicates(int[] nums) {
  2. 2 int count = 2;
  3. 3 for (int i = 2; i < nums.length; i++) {
  4. 4 if (nums[i] > nums[count - 2]) {
  5. 5 nums[count++] = nums[i];
  6. 6 }
  7. 7 }
  8. 8 return count;
  9. 9 }

94. Binary Tree Inorder Traversal

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Stack;
  4.  
  5. public class TreeNode {
  6. int val;
  7. TreeNode left;
  8. TreeNode right;
  9.  
  10. TreeNode(int x) {
  11. val = x;
  12. }
  13.  
  14. /**
  15. * 题目:‘有序遍历:给你一个二叉树,有序遍历他的节点;有序遍历意味着先便利左子树,之后依次倒叙遍历右子树;
  16. * ’最好集合solution的动图,入栈出栈的形式更好理解
  17. *
  18. * ‘解决方法:利用入栈出栈的形式
  19. *
  20. * @param root
  21. * @return
  22. */
  23. public static List<Integer> inorderTraversal(TreeNode root) {
  24. List<Integer> res = new ArrayList<Integer>();
  25. //声明一个栈来存取节点
  26. Stack<TreeNode> stack = new Stack<TreeNode>();
  27. TreeNode curr = root;
  28. //如果节点没有遍历完或者说栈不为空就继续一下流程
  29. while (curr != null || !stack.isEmpty()) {
  30. //如果当前节点不为空,就继续将当前节点压入栈
  31. while (curr != null) {
  32. stack.push(curr);
  33. curr = curr.left;
  34. }
  35. //如果当前节点为空,意味着左子树遍历完了,那就出栈存值,然后遍历当前节点的右子树
  36. curr = stack.pop();
  37. res.add(curr.val);
  38. curr = curr.right;
  39. }
  40. return res;
  41. }
  42.  
  43. public static void main(String[] args) {
  44. // [1,null,2,3]
  45. TreeNode treeNode = new TreeNode(1);
  46. TreeNode treeNode1 = new TreeNode(2);
  47. TreeNode treeNode2 = new TreeNode(3);
  48. treeNode.right = treeNode1;
  49. treeNode1.left = treeNode2;
  50. inorderTraversal(treeNode);
  51. }
  52.  
  53. }

101. Symmetric Tree

  1. public class TreeNode {
  2. int val;
  3. TreeNode left;
  4. TreeNode right;
  5.  
  6. TreeNode(int x) {
  7. val = x;
  8. }
  9.  
  10. /**
  11. * 题意:’判断给定的二叉树是不是对称的二叉树
  12. * 解决方法:‘递归,理解简单。通过递归判断所有的节点是否对称;
  13. * 思路:’将一个给定的二叉树‘复制一份’,从根节点开始,判断对应的节点(以根节点为对称轴)是否相同;
  14. * @param t1
  15. * @param t2
  16. * @return
  17. */
  18. public static boolean isMirro(TreeNode t1,TreeNode t2) {
  19. if(t1 ==null && t2==null) {
  20. return true;
  21. }
  22. if(t1 == null || t2 == null) {
  23. return false;
  24. }
  25. //判断当前节点以及当前节点的左右树
  26. return (t1.val == t2.val) && isMirro(t1.left, t2.right) && isMirro(t1.right, t2.left);
  27. }
  28.  
  29. public static boolean isSymmetric(TreeNode root) {
  30. return isMirro(root, root);
  31. }
  32.  
  33. public static void main(String[] args) {
  34. // [1,2,2,3,4,4,3]
  35. TreeNode t1 = new TreeNode(1);
  36. TreeNode t2 = new TreeNode(2);
  37. TreeNode t3 = new TreeNode(2);
  38. TreeNode t4 = new TreeNode(3);
  39. TreeNode t5 = new TreeNode(4);
  40. TreeNode t6 = new TreeNode(4);
  41. TreeNode t7 = new TreeNode(3);
  42. t1.left = t2;t1.right = t3;
  43. t2.left = t4;t2.right = t5;
  44. t3.left = t6;t3.right = t7;
  45. System.out.println(isSymmetric(t1));
  46. }
  47.  
  48. }

104. Maximum Depth of Binary Tree

  1. public class TreeNode {
  2. int val;
  3. TreeNode left;
  4. TreeNode right;
  5.  
  6. TreeNode(int x) {
  7. val = x;
  8. }
  9.  
  10. /**
  11. * 题意:遍历二叉树得到最大路径的长度
  12. * 解题:遍历可以用递归或者是栈;这里用的是递归,栈我没用明白,
  13. * @param root
  14. * @return
  15. */
  16. public static int maxDepth(TreeNode root) {
  17. if(root == null) {
  18. return 0;
  19. }
  20. return 1+Math.max(maxDepth(root.left), maxDepth(root.right));
  21. }
  22.  
  23. public static void main(String[] args) {
  24. // [0,2,4,1,null,3,-1,5,1,null,6,null,8]
  25. TreeNode t1 = new TreeNode(0);
  26. TreeNode t2 = new TreeNode(2);
  27. TreeNode t3 = new TreeNode(4);
  28. TreeNode t4 = new TreeNode(1);
  29. TreeNode t5 = new TreeNode(3);
  30. TreeNode t6 = new TreeNode(-1);
  31. TreeNode t7 = new TreeNode(5);
  32. TreeNode t8 = new TreeNode(1);
  33. TreeNode t9 = new TreeNode(6);
  34. TreeNode t10 = new TreeNode(8);
  35. t1.left = t2;
  36. t1.right = t3;
  37. t2.left = t4;
  38. t4.left = t7;
  39. t4.right = t8;
  40. t3.left = t5;
  41. t3.right = t6;
  42. t5.left = t9;
  43. t6.left = t10;
  44. System.out.println(maxDepth(t1));
  45. }
  46.  
  47. }

121. Best Time to Buy and Sell Stock

  1. public class oneHundredone {
  2. /**
  3. * 题目:卖股票 小卖大卖
  4. * 解题方法:动态找到当前最小的,然后一次判断当前的最大利润
  5. * @param prices
  6. * @return
  7. */
  8. public static int maxProfit(int prices[]) {
  9. //初始化,
  10. int minPrice = Integer.MAX_VALUE;
  11. int maxProfit = 0;
  12. for (int i = 0; i < prices.length; i++) {
  13. //找到最小的买入值
  14. minPrice = Math.min(minPrice, prices[i]);
  15. //找到最大的卖出值
  16. maxProfit = Math.max(maxProfit, prices[i] - minPrice);
  17. }
  18. return maxProfit;
  19.  
  20. }
  21.  
  22. public static void main(String[] args) {
  23. int[] stock = { 7, 6, 4, 3, 1 };
  24. System.out.println(maxProfit(stock));
  25. }
  26.  
  27. }

136. Single Number

  1. 1 public int singleNumber(int[] nums) {
  2. 2
  3. 3
  4. 4 Map<Integer, Integer> map = new HashMap<Integer, Integer>();
  5. 5
  6. 6 for (int i = 0; i < nums.length; i++) {
  7. 7 if (map.containsKey(nums[i])) {
  8. 8 map.remove(nums[i]);
  9. 9 } else {
  10. 10 map.put(nums[i], 1);
  11. 11 }
  12. 12
  13. 13 }
  14. 14
  15. 15 Integer result = 0;
  16. 16 for (Integer key : map.keySet()) {
  17. 17 result = key;
  18. 18 break;
  19. 19 }
  20. 20
  21. 21 return result;
  22. 22
  23. 23
  24. 24 }

137. Single Number II

  1. 1 public int singleNumber(int[] nums) {
  2. 2
  3. 3
  4. 4 Map<Integer, Boolean> map = new HashMap<Integer, Boolean>();
  5. 5
  6. 6 for (int i = 0; i < nums.length; i++) {
  7. 7 if (map.containsKey(nums[i])) {
  8. 8 map.put(nums[i], false);
  9. 9 } else {
  10. 10 map.put(nums[i], true);
  11. 11 }
  12. 12
  13. 13 }
  14. 14
  15. 15 List<Integer> result = new ArrayList<Integer>();
  16. 16 map.forEach((k, v) -> {
  17. 17 if (v) {
  18. 18 result.add(k);
  19. 19 }
  20. 20 });
  21. 21 return result.get(0);
  22. 22
  23. 23
  24. 24 }

139. Word Break

  1. 1 import java.util.ArrayList;
  2. 2 import java.util.List;
  3. 3
  4. 4 /**
  5. 5 * 题意:根据给定的字典判断字符串是否可以完全根据字典拆解 思路:利用dp(动态规划:把问题分解成原子级别,求解每个问题的最优解,最后汇聚就是问题的最优解)
  6. 6 *
  7. 7 *
  8. 8 */
  9. 9 public class WordBreak {
  10. 10 /**
  11. 11 * dp1 比较容易理解
  12. 12 *
  13. 13 * 遍历给定字符串的每一个字符,和字典机型比较,如果符合条件(wordDict.contains(sub) && (j == 0 || dp[j -
  14. 14 * 1])),就将该位置设置成true 若遍历所有之后,dp的最后一位是true,代表字符串按照字段拆解完全
  15. 15 *
  16. 16 * @param s
  17. 17 * @param wordDict
  18. 18 * @return
  19. 19 */
  20. 20 public static boolean wordBreak(String s, List<String> wordDict) {
  21. 21 if (s == null || "".equals(s)) {
  22. 22 return false;
  23. 23 }
  24. 24 int n = s.length();
  25. 25 boolean[] dp = new boolean[s.length()];
  26. 26 for (int i = 0; i < s.length(); i++) {
  27. 27 for (int j = 0; j <= i; j++) {
  28. 28 String sub = s.substring(j, i + 1);
  29. 29 if (wordDict.contains(sub) && (j == 0 || dp[j - 1])) {
  30. 30 dp[i] = true;
  31. 31 }
  32. 32 }
  33. 33 }
  34. 34 return dp[n - 1];
  35. 35 }
  36. 36
  37. 37 /**
  38. 38 * dp2
  39. 39 * 和dp1思路一样,只是优化了匹配过程,第二次直接遍历字段进行匹配,优化了3ms
  40. 40 * @param s
  41. 41 * @param wordDict
  42. 42 * @return
  43. 43 */
  44. 44 public static boolean wordBreak2(String s, List<String> wordDict) {
  45. 45 int n = s.length();
  46. 46 boolean[] dp = new boolean[n + 1];
  47. 47 dp[0] = true;
  48. 48 for (int i = 1; i <= s.length(); i++) {
  49. 49 for (String word : wordDict) {
  50. 50 int len = word.length();
  51. 51 if (i >= len && dp[i - len] && s.substring(i - len, i).equals(word)) {
  52. 52 dp[i] = true;
  53. 53 }
  54. 54 }
  55. 55 }
  56. 56 return dp[n];
  57. 57
  58. 58 }
  59. 59
  60. 60 /**
  61. 61 * dp3递归加dp,还没有完全理解,不过思路都很相似
  62. 62 * @param s
  63. 63 * @param wordDict
  64. 64 * @return
  65. 65 */
  66. 66 public static boolean wordBreak3(String s, List<String> wordDict) {
  67. 67 boolean[] memo = new boolean[s.length()];
  68. 68 return wordBreakHelper(s, wordDict, memo, 0);
  69. 69 }
  70. 70
  71. 71 public static boolean wordBreakHelper(String s, List<String> wordDict, boolean[] memo, int i) {
  72. 72 if (i >= s.length()) {
  73. 73 return true;
  74. 74 }
  75. 75 if (memo[i]) {
  76. 76 return false;
  77. 77 }
  78. 78 for (String word : wordDict) {
  79. 79 if (!s.startsWith(word, i)) {
  80. 80 continue;
  81. 81 }
  82. 82 boolean result = wordBreakHelper(s, wordDict, memo, i + word.length());
  83. 83 if (result) {
  84. 84 return true;
  85. 85 }
  86. 86 memo[i] = true;
  87. 87 }
  88. 88 return false;
  89. 89 }
  90. 90
  91. 91 public static void main(String[] args) {
  92. 92 String s = "leetcode";
  93. 93 List<String> dict = new ArrayList<String>();
  94. 94 dict.add("leet");
  95. 95 dict.add("code");
  96. 96 // System.out.println(wordBreak(s, dict));
  97. 97 System.out.println(wordBreak2(s, dict));
  98. 98 }
  99. 99 }

152. Maximum Product Subarray

  1. /**
  2. * Given an integer array nums, find the contiguous subarray within an array
  3. * (containing at least one number) which has the largest product.
  4. *
  5. * 给一整数,求解最大的连续乘积,数组包含至少一个整数
  6. *
  7. */
  8. public class Lc152 {
  9. /**
  10. * 思路:dp
  11. * 最优子结构,之前最大值乘当前值为最大值
  12. * 边界值,初始值为nums[0]
  13. *公式: 最大值 为 当前值 和 之前最大值乘以当前值 中的一个
  14. * @param nums
  15. * @return
  16. */
  17. public static int maxProduct(int[] nums) {
  18. if (nums.length == 1) {
  19. return 0;
  20. }
  21.  
  22. int max = nums[0];
  23. int dpMax = nums[0];
  24. int dpMin = nums[0];
  25. for (int i = 1; i < nums.length; i++) {
  26. dpMax = Math.max(nums[i], Math.max(dpMax * nums[i], dpMin * nums[i]));
  27. dpMin = Math.min(nums[i], Math.min(dpMax * nums[i], dpMin * nums[i]));
  28. max = Math.max(max, dpMax);
  29. }
  30.  
  31. return max;
  32. }
  33.  
  34. public static void main(String[] args) {
  35. int[] nums = { 2, 3, -2, 4 };
  36. System.out.println(maxProduct(nums));
  37. }
  38. }

167. Two Sum II - Input array is sorted

  1. 1 public int[] twoSum(int[] numbers, int target) {
  2. 2
  3. 3 int[] position = new int[2];
  4. 4 for (int i = 0; i < numbers.length; i++) {
  5. 5 for (int j = i + 1; j < numbers.length; j++) {
  6. 6 if (numbers[i] + numbers[j] == target) {
  7. 7 position[0] = ++i;
  8. 8 position[1] = ++j;
  9. 9 break;
  10. 10 }
  11. 11 }
  12. 12 }
  13. 13
  14. 14 return position;
  15. 15
  16. 16 }

169. Majority Element

  1. import java.util.Arrays;
  2.  
  3. public class majorityElement {
  4. /**
  5. * 题目: Given an array of size n, find the majority element. The majority element
  6. * is the element that appears more than ⌊ n/2 ⌋ times.
  7. *
  8. * You may assume that the array is non-empty and the majority element always
  9. * exist in the array.
  10. *
  11. * 解题: 利用测试用例数据
  12. *
  13. * @param nums
  14. * @return
  15. */
  16. public static int majorityElement(int[] nums) {
  17. Arrays.sort(nums);
  18. return nums[nums.length / 2];
  19. }
  20.  
  21. /**
  22. * 摩尔投票 是你就给你加一,不是你就减一,如果你是0就替换
  23. */
  24. public static int majorityElement2(int[] nums) {
  25. int res = nums[0];
  26. int count = 1;
  27. for (int i : nums) {
  28. if (i == res) {
  29. count++;
  30. } else {
  31. count--;
  32. }
  33. if (count == 0) {
  34. res = i;
  35. count++;
  36. }
  37. }
  38. return res;
  39. }
  40.  
  41. public static void main(String[] args) {
  42. int a[] = { 2, 2, 1, 1, 1, 2, 2 };
  43. // System.out.println(majorityElement(a));
  44. System.out.println(majorityElement2(a));
  45. }
  46.  
  47. }

198. House Robber

  1. /**
  2. * You are a professional robber planning to rob houses along a street. Each
  3. * house has a certain amount of money stashed, the only constraint stopping you
  4. * from robbing each of them is that adjacent houses have security system
  5. * connected and it will automatically contact the police if two adjacent houses
  6. * were broken into on the same night.
  7. *
  8. * Given a list of non-negative integers representing the amount of money of
  9. * each house, determine the maximum amount of money you can rob tonight without
  10. * alerting the police.
  11. *
  12. * @author 5109v12458
  13. *
  14. */
  15. public class HouseRobbe {
  16.  
  17. /**
  18. * 每次求得的now都是相隔的俩个数相加
  19. * @param nums
  20. * @return
  21. */
  22. public static int rob(int[] nums) {
  23. int last = 0;
  24. int now = 0;
  25. int temp = 0;
  26. //an = (a(n-1)+n,an)
  27. for (int i : nums) {
  28. temp = now;
  29. now = Math.max(last + i, now);
  30. last = temp;
  31. }
  32. return now;
  33. }
  34.  
  35. public static void main(String[] args) {
  36. int nums[] = { 1, 2, 4, 6 };
  37. System.out.println(rob(nums));
  38. }
  39. }

204. 计数质数

  1. 1 class Solution {
  2. 2 public int countPrimes(int n) {
  3. 3 int[] num = new int[n];
  4. 4
  5. 5 for (int i = 0; i < n; i++) {
  6. 6 num[i] = 1;
  7. 7 }
  8. 8
  9. 9 for (int j = 2; j < n; j++) {
  10. 10 if (num[j] == 1) {
  11. 11 for (int k = 2; k * j < n; k++) {
  12. 12 num[j * k] = 0;
  13. 13 }
  14. 14 }
  15. 15 }
  16. 16 int sum = 0;
  17. 17 for (int i = 2; i < n; i++) {
  18. 18 if (num[i] == 1) {
  19. 19 sum++;
  20. 20 }
  21. 21 }
  22. 22 return sum;
  23. 23 }
  24. 24
  25. 25 }

206. Reverse Linked List

  1. /**
  2. * Reverse a singly linked list.
  3. *
  4. * Example:
  5. *
  6. * Input: 1->2->3->4->5->NULL Output: 5->4->3->2->1->NULL Follow up:
  7. *
  8. * A linked list can be reversed either iteratively or recursively. Could you
  9. * implement both?
  10. *
  11. */
  12. public class ReverseLinkedList {
  13. public static class ListNode {
  14. int val;
  15. ListNode next;
  16.  
  17. ListNode(int x) {
  18. val = x;
  19. }
  20. }
  21.  
  22. /**
  23. * 解法,通过另一条链表实现反转链表
  24. * @param head
  25. * @return
  26. */
  27. public static ListNode reverseList(ListNode head) {
  28. ListNode prev = null;
  29. ListNode curr = head;
  30. while (curr != null) {
  31. ListNode temp = curr.next;
  32. /*
  33. * 目的是将当前节点的下一个几点作为prev的上一个节点,当前节点作为prev的当前节点
  34. * 其他的步骤就是单纯的置换
  35. */
  36. curr.next = prev;
  37. prev = curr;
  38. curr = temp;
  39. }
  40. return prev;
  41. }
  42.  
  43. public static void main(String[] args) {
  44. ListNode node = new ListNode(0);
  45. ListNode node1 = new ListNode(1);
  46. ListNode node2 = new ListNode(2);
  47.  
  48. node.next = node1;
  49. node1.next = node2;
  50.  
  51. reverseList(node);
  52. }
  53. }

226. Invert Binary Tree

  1. Invert a binary tree.
  2.  
  3. Example:
  4.  
  5. Input:
  6.  
  7. 4
  8. / \
  9. 2 7
  10. / \ / \
  11. 1 3 6 9
  12. Output:
  13.  
  14. 4
  15. / \
  16. 7 2
  17. / \ / \
  18. 9 6 3 1
  1. /**
  2. * Definition for a binary tree node. public class TreeNode { int val; TreeNode
  3. * left; TreeNode right; TreeNode(int x) { val = x; } }
  4. */
  5. class Lc226 {
  6. public static class TreeNode {
  7. int val;
  8. TreeNode left;
  9. TreeNode right;
  10.  
  11. TreeNode(int x) {
  12. val = x;
  13. }
  14. }
  15.  
  16. /**
  17. *
  18. * 反转二叉树:先按照左子树反转,在右子树反转,在左右字数反转
  19. *
  20. * @return
  21. */
  22. public TreeNode invertTree(TreeNode root) {
  23. if (root == null) {
  24. return null;
  25. }
  26. TreeNode left = invertTree(root.left);
  27. TreeNode right = invertTree(root.right);
  28. root.left = right;
  29. root.right = left;
  30. return root;
  31. }
  32. }

260. Single Number III

  1. 1 public int[] singleNumber(int[] nums) {
  2. 2
  3. 3 Map<Integer, Boolean> map = new HashMap<Integer, Boolean>();
  4. 4
  5. 5 for (int i = 0; i < nums.length; i++) {
  6. 6 if (map.containsKey(nums[i])) {
  7. 7 map.put(nums[i], false);
  8. 8 } else {
  9. 9 map.put(nums[i], true);
  10. 10 }
  11. 11
  12. 12 }
  13. 13
  14. 14 List<Integer> resultTemp = new ArrayList<Integer>();
  15. 15
  16. 16 map.forEach((k, v) -> {
  17. 17 if (v) {
  18. 18 resultTemp.add(k);
  19. 19 }
  20. 20 });
  21. 21
  22. 22 int[] result = new int[resultTemp.size()];
  23. 23
  24. 24 for (int i = 0; i < resultTemp.size(); i++) {
  25. 25 result[i] = resultTemp.get(i);
  26. 26 }
  27. 27 return result;
  28. 28
  29. 29 }

283. Move Zeroes

  1. 1 public static void moveZeroes(int[] nums) {
  2. 2 for (int i = 0; i < nums.length; i++) {
  3. 3 if (nums[i] != 0) {
  4. 4 continue;
  5. 5 } else {
  6. 6 int count = 0;
  7. 7 do {
  8. 8 swap(nums, i);//如果当前位置为0,则置换到最后一位
  9. 9 count++;
  10. 10 } while (nums[i] == 0 && count < nums.length - i);//如果当前位置是0,并且之前也没有0啦,则终止循环,终止条件有待优化
  11. 11 }
  12. 12 }
  13. 13 for (int i = 0; i < nums.length; i++) {
  14. 14 System.out.print(nums[i]);
  15. 15 }
  16. 16 }
  17. 17
  18. 18 public static void swap(int[] nums, int position) {//普通的置换算法,冒泡排序里的一段
  19. 19 for (int i = position; i < nums.length - 1; i++) {
  20. 20 int temp = nums[i];
  21. 21 nums[i] = nums[i + 1];
  22. 22 nums[i + 1] = temp;
  23. 23 }
  24. 24 }

412. Fizz Buzz

  1. 1 class Solution {
  2. 2 public List<String> fizzBuzz(int n) {
  3. 3 List<String> result = new ArrayList<>();
  4. 4 for (int i = 1; i <= n; i++) {
  5. 5 if (i % 3 == 0 && i % 5 == 0) {
  6. 6 result.add("FizzBuzz");
  7. 7 } else if (i % 3 == 0) {
  8. 8 result.add("Fizz");
  9. 9 } else if (i % 5 == 0) {
  10. 10 result.add("Buzz");
  11. 11 } else {
  12. 12 result.add("" + i);
  13. 13 }
  14. 14
  15. 15 }
  16. 16 return result;
  17. 17 }
  18. 18 }

448. Find All Numbers Disappeared in an Array

  1. 1 public List<Integer> findDisappearedNumbers(int[] nums) {
  2. 2
  3. 3
  4. 4 Map<Integer, Integer> numsMap = new HashMap<Integer, Integer>();
  5. 5 for (int i = 0; i < nums.length; i++) {
  6. 6 numsMap.put(nums[i], i);
  7. 7 }
  8. 8
  9. 9 // 1给定数组应该有的大小
  10. 10 int size = nums.length;
  11. 11
  12. 12 List<Integer> disappearedNumbers = new ArrayList<Integer>();
  13. 13 for (int i = 1; i <= size; i++) {
  14. 14 if (!numsMap.containsKey(i)) {
  15. 15 disappearedNumbers.add(i);
  16. 16 }
  17. 17 }
  18. 18
  19. 19 return disappearedNumbers;
  20. 20
  21. 21 }

442. Find All Duplicates in an Array

  1. 1 public List<Integer> findDuplicates(int[] nums) {
  2. 2
  3. 3 // 1对于给定数组进行排序
  4. 4 Map<Integer, Integer> numsMap = new HashMap<Integer, Integer>();
  5. 5 for (int i = 0; i < nums.length; i++) {
  6. 6 if(numsMap.containsKey(nums[i])) {
  7. 7 numsMap.put(nums[i], 2);
  8. 8 }else {
  9. 9 numsMap.put(nums[i], 1);
  10. 10 }
  11. 11 }
  12. 12
  13. 13 List<Integer> disappearedNumbers = new ArrayList<Integer>();
  14. 14 numsMap.forEach((k,v)->{
  15. 15 if(v==2) {
  16. 16 disappearedNumbers.add(k);
  17. 17 }
  18. 18 });
  19. 19
  20. 20 return disappearedNumbers;
  21. 21
  22. 22
  23. 23 }

461. Hamming Distance

  1. /**
  2. * Hamming Distance
  3. *
  4. * The Hamming distance between two integers is the number of positions at which
  5. * the corresponding bits are different. Given two integers x and y, calculate
  6. * the Hamming distance.
  7. *
  8. * 转换为2进制,有几个位置上的值不同,就叫做Hamming distance
  9. *
  10. */
  11. public class Lc461 {
  12. public static void main(String[] args) {
  13. System.out.println(hammingDistance(1, 4));
  14. }
  15.  
  16. public static int hammingDistance(int x, int y) {
  17. int sum = x ^ y;
  18. int res = 0;
  19. res += sum % 2;
  20. sum /= 2;
  21. return res;
  22. }
  23. }

560. Subarray Sum Equals K

  1. import java.util.HashMap;
  2. import java.util.Map;
  3.  
  4. /**
  5. *找出最大连续子序列的个数
  6. *
  7. */
  8. public class Lc560 {
  9.  
  10. /**
  11. * 如果存在 sum-k=subArrayCount,則存在对应count的连续子序列
  12. *
  13. * @param nums
  14. * @param k
  15. * @return
  16. */
  17. public static int subarraySum(int[] nums, int k) {
  18. int count = 0;
  19. int sum = 0;
  20. Map<Integer, Integer> map = new HashMap<>();// map<sum,count(该sum-k出现的次数)>
  21. map.put(0, 1);
  22. for (int i = 0; i < nums.length; i++) {
  23. sum += nums[i];
  24. if (map.containsKey(sum - k)) {
  25. count += map.get(sum - k);
  26. }
  27. map.put(sum, map.getOrDefault(sum, 0) + 1);
  28. }
  29. return count;
  30. }
  31.  
  32. public static void main(String[] args) {
  33. int nums[] = { 3, 4, 7, 2, -3, 1, 4, 2 };
  34. System.out.println(subarraySum(nums, 7));
  35. }
  36. }

581. Shortest Unsorted Continuous Subarray

  1. import java.util.Arrays;
  2. /*
  3. * 581. Shortest Unsorted Continuous Subarray
  4. * 题意:找出数组中需要排序的长度
  5. * 难度:Easy
  6. * 分类:Array
  7. * 思路:
  8. * Tips:可以考虑八大排序
  9. */
  10. public class Lc581 {
  11. public static int findUnsortedSubarray(int[] nums) {
  12. int copyFromNums[] = new int[nums.length];
  13. for (int i = 0; i < nums.length; i++) {
  14. copyFromNums[i] = nums[i];
  15. }
  16. Arrays.sort(copyFromNums);
  17. int startPosition = 0;
  18. int endPosition = 0;
  19. for (int i = 0; i < nums.length; i++) {
  20. if (copyFromNums[i] != nums[i]) {
  21. startPosition = i;
  22. break;
  23. }
  24. }
  25.  
  26. for (int i = 0; i < nums.length; i++) {
  27. if (copyFromNums[i] != nums[i]) {
  28. endPosition = i;
  29. }
  30. }
  31.  
  32. int count = 0;
  33. if (endPosition != startPosition) {
  34. count = endPosition - startPosition + 1;
  35. }
  36. return count;
  37. }
  38.  
  39. public static void main(String[] args) {
  40. int nums[] = { 2, 6, 4, 8, 10, 9, 15 };
  41. System.out.println(findUnsortedSubarray(nums));
  42. }
  43. }

617. Merge Two Binary Trees

  1. 1 /**
  2. 2 * 题意:将俩个二叉树及进行合并,如果同一位置节点都存在,则合并,否则旧直接放上去
  3. 3 * 思路:相同位置进行合并,有则相加,无责这届放上去,注意用递归
  4. 4 * @param t1
  5. 5 * @param t2
  6. 6 * @return
  7. 7 */
  8. 8 public static TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
  9. 9 if (t1 == null && t2 == null) {
  10. 10 return null;
  11. 11 }
  12. 12 if (t1 == null) {
  13. 13 return t2;
  14. 14 }
  15. 15 if (t2 == null) {
  16. 16 return t1;
  17. 17 }
  18. 18
  19. 19 TreeNode t = new TreeNode(t1.val + t2.val);
  20. 20 t.left = mergeTrees(t1.left, t2.left);
  21. 21 t.right = mergeTrees(t1.right, t2.right);
  22. 22 return t;
  23. 23 }

771. Jewels and Stones

  1. public class Lc771 {
  2.  
  3. public static int numJewelsInStones(String J, String S) {
  4. String[] strJ = convertToAscall(J);
  5. String[] strS = convertToAscall(S);
  6. int count = 0;
  7. for (int i = 0; i < strS.length; i++) {
  8. for (int k = 0; k < strJ.length; k++) {
  9. if (strS[i].equals(strJ[k])) {
  10. count++;
  11. break;
  12. }
  13. }
  14. }
  15. return count;
  16. }
  17.  
  18. private static String[] convertToAscall(String s) {
  19. StringBuffer sb = new StringBuffer();
  20. char[] chars = s.toCharArray();
  21. for (char c : chars) {
  22. sb.append((int) c).append(",");
  23. }
  24. return sb.toString().split(",");
  25. }
  26.  
  27. public static void main(String[] args) {
  28. String S = "aAAbbbddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddb";
  29. String J = "addddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddA";
  30.  
  31. System.out.println(numJewelsInStones(J, S));
  32. }
  33. }

leetcode 刷题记录(java)-持续更新的更多相关文章

  1. leetcode刷题记录--js

    leetcode刷题记录 两数之和 给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标. 你可以假设每种输入只会对应一个答案.但 ...

  2. Leetcode刷题记录(python3)

    Leetcode刷题记录(python3) 顺序刷题 1~5 ---1.两数之和 ---2.两数相加 ---3. 无重复字符的最长子串 ---4.寻找两个有序数组的中位数 ---5.最长回文子串 6- ...

  3. LeetCode刷题记录(python3)

    由于之前对算法题接触不多,因此暂时只做easy和medium难度的题. 看完了<算法(第四版)>后重新开始刷LeetCode了,这次决定按topic来刷题,有一个大致的方向.有些题不止包含 ...

  4. LeetCode 刷题记录(二)

    写在前面:因为要准备面试,开始了在[LeetCode]上刷题的历程.LeetCode上一共有大约150道题目,本文记录我在<http://oj.leetcode.com>上AC的所有题目, ...

  5. LeetCode 刷题记录

    写在前面:因为要准备面试,开始了在[LeetCode]上刷题的历程.LeetCode上一共有大约150道题目,本文记录我在<http://oj.leetcode.com>上AC的所有题目, ...

  6. LeetCode动态规划题总结【持续更新】

    以下题号均为LeetCode题号,便于查看原题. 10. Regular Expression Matching 题意:实现字符串的正则匹配,包含'.' 和 '*'.'.' 匹配任意一个字符,&quo ...

  7. leetcode刷题记录——树

    递归 104.二叉树的最大深度 /** * Definition for a binary tree node. * public class TreeNode { * int val; * Tree ...

  8. 算法进阶之Leetcode刷题记录

    目录 引言 题目 1.两数之和 题目 解题笔记 7.反转整数 题目 解题笔记 9.回文数 题目 解题笔记 13.罗马数字转整数 题目 解题笔记 14.最长公共前缀 题目 解题笔记 20.有效的括号 题 ...

  9. leetcode刷题记录——字符串

    242.有效地字母异位词 由于本题的字符串只包含 26 个小写字符,因此可以使用长度为 26 的整型数组对字符串出现的字符进行统计,并对比字母出现的次数是否一致.不再使用 HashMap. toCha ...

随机推荐

  1. 一文带你了解Java反射机制

    想要获取更多文章可以访问我的博客 - 代码无止境. 上周上班的时候解决一个需求,需要将一批数据导出到Excel.本来公司的中间件组已经封装好了使用POI生成Excel的工具方法,但是无奈产品的需求里面 ...

  2. bootstrap datatable editor 扩展

    需求: a. 表单样式更改. b. 表单大小更改. 思路: a. 通过设置modal css更改样式和大小.缺点,全局性的更改. b. 更改bootstrap-editor,可以通过某种方式将参数传入 ...

  3. ASP.NET Core on K8S深入学习(2)部署过程解析与Dashboard

    上一篇<K8S集群部署>中搭建好了一个最小化的K8S集群,这一篇我们来部署一个ASP.NET Core WebAPI项目来介绍一下整个部署过程的运行机制,然后部署一下Dashboard,完 ...

  4. 【Vue前端】Vue前端注册业务实现!!!【代码】

    用户注册前端逻辑 1. Vue绑定注册界面准备 1.导入Vue.js库和ajax请求的库 <script type="text/javascript" src="{ ...

  5. 【Java笔记】【Java核心技术卷1】chapter3 D2注释

    package chapter3; /** * 文档注释 *@author lp *@version 1 **/ public class D2注释 { //单行注释 /* 长注释 */ }

  6. Spring Boot 整合 JPA 使用多个数据源

    介绍 JPA(Java Persistence API)Java 持久化 API,是 Java 持久化的标准规范,Hibernate 是持久化规范的技术实现,而 Spring Data JPA 是在 ...

  7. 【游记】NOIP2018复赛

    声明 我的游记是一个完整的体系,如果没有阅读过往届文章,阅读可能会受到障碍. ~~~上一篇游记的传送门~~~ 前言 参加完NOIP2018的初赛过后,我有点自信心爆棚,并比之前更重视了一点(也仅仅是一 ...

  8. java并发编程(一)----线程基础知识

    在任何的生产环境中我们都不可逃避并发这个问题,多线程作为并发问题的技术支持让我们不得不去了解.这一块知识就像一个大蛋糕一样等着我们去分享,抱着学习的心态,记录下自己对并发的认识. 1.线程的状态: 线 ...

  9. jQuery发送Ajax请求以及出现的问题

    普通jQuery的Ajax请求代码如下: $.ajax({ type: 'POST', url: "http://xxx/yyy/zzz/sendVerifyCode", data ...

  10. 如何调教你的博客Episode1——修改整体样式

    如图所示,这是你刚刚注册的博客园博客,让我们开始一步步修改它. 1.写入自适应代码 html,body{ height:100%; border:; margin:; padding:; } body ...