solution：5~29

JavaScalaDeveloper · JavaScalaDeveloper · commit 2f16ee929c10 · 2023-05-24T00:06:56.000+08:00
diff --git a/change/tools/listnode/ListNodeUtils.java b/change/tools/listnode/ListNodeUtils.java
@@ -1,8 +1,10 @@
 package change.tools.listnode;
 
 
-import change.datastructure.*;
-import java.util.*;
+import change.datastructure.ListNode;
+
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * 链表工具类
@@ -71,4 +73,16 @@ public static List<Integer> getCircularList(ListNode head) {
         return list;
     }
 
+    private static ListNode reverse(ListNode listNode) {
+        ListNode pre = null;
+        ListNode dump = listNode;
+        while (dump != null) {
+            ListNode next = dump.next;
+//            每一轮翻转以后，把当前节点及前给pre，把后面的节点给dump
+            dump.next = pre;
+            pre = dump;
+            dump = next;
+        }
+        return pre;
+    }
 }
diff --git a/solution/0000-0099/0005.Longest Palindromic Substring/Solution.java b/solution/0000-0099/0005.Longest Palindromic Substring/Solution.java
@@ -1,8 +1,37 @@
 package com.solution._0005;
-import change.datastructure.*;
-import java.util.*;
+
 public class Solution {
-    public String longestPalindrome(String s) {
+    public static void main(String[] args) {
+        String s = "babad";
+        String res = longestPalindrome(s);
+//        System.out.printf(res);
+        String res2 = longestPalindrome2(s);
+        System.out.printf(res2);
+    }
+
+    public static String longestPalindrome2(String s) {
+        int len = s.length();
+        if (len == 1) return s;
+        int left = 0, right = 1;
+        int max = 0;
+        for (int i = 1; i < len - 1; i++) {
+            int l = i - 1, r = i + 1;
+            while (s.charAt(l) == s.charAt(r) && l > 0 && r < len - 1) {
+                l--;
+                r++;
+            }
+            if (r - l > max) {
+                max = r - l;
+                left = l;
+                right = r;
+            }
+        }
+
+        return s.substring(left, right - 1);
+
+    }
+
+    public static String longestPalindrome(String s) {
         int n = s.length();
         boolean[][] dp = new boolean[n][n];
         int mx = 1, start = 0;
diff --git a/solution/0000-0099/0006.Zigzag Conversion/Solution.java b/solution/0000-0099/0006.Zigzag Conversion/Solution.java
@@ -1,7 +1,63 @@
 package com.solution._0006;
 import change.datastructure.*;
+import change.tools.listnode.ArrayUtils;
+
 import java.util.*;
 public class Solution {
+    public static void main(String[] args) {
+        String s = "ABCDEFGHIJKLMNOPQRSTU";
+        Solution solution = new Solution();
+        String result = solution.convert(s, 4);
+        System.out.println(result);
+        String result2 = convert3(s, 4);
+        System.out.println(result2);
+    }
+    /*
+    这个算法的时间复杂度是 O(n)，其中 n 是字符串 s 的长度。该算法使用一个StringBuilder数组来保存每一行的字符，然后通过遍历输入字符串来
+    填充字符，同时跟踪当前行和移动方向。
+     */
+    public static String convert3(String s, int numRows) {
+        if (numRows == 1) {
+            return s;
+        }
+        StringBuilder[] rows = new StringBuilder[numRows];
+        int curRow = 0;
+        boolean goingDown = false;
+        for (char c : s.toCharArray()) {
+            if (rows[curRow] == null) {
+                rows[curRow] = new StringBuilder();
+            }
+            rows[curRow].append(c);
+            if (curRow == 0 || curRow == numRows - 1) {
+//                决定往下或者往上
+                goingDown = !goingDown;
+            }
+//            进入往下或者往上一行
+            curRow += goingDown ? 1 : -1;
+        }
+        StringBuilder result = new StringBuilder();
+        for (StringBuilder row : rows) {
+            result.append(row != null ? row.toString() : "");
+        }
+        return result.toString();
+    }
+
+    public String convert2(String s, int numRows) {
+        if (numRows == 1) {
+            return s;
+        }
+        StringBuilder[] g = new StringBuilder[numRows];
+        Arrays.setAll(g, k -> new StringBuilder());
+        int i = 0, k = -1;
+        for (char c : s.toCharArray()) {
+            g[i].append(c);
+            if (i == 0 || i == numRows - 1) {
+                k = -k;
+            }
+            i += k;
+        }
+        return String.join("", g);
+    }
     public String convert(String s, int numRows) {
         if (numRows == 1) {
             return s;
diff --git a/solution/0000-0099/0007.Reverse Integer/Solution.java b/solution/0000-0099/0007.Reverse Integer/Solution.java
@@ -1,7 +1,23 @@
 package com.solution._0007;
-import change.datastructure.*;
-import java.util.*;
+
 public class Solution {
+    public static void main(String[] args) {
+        int res = reverse2(123);
+        System.out.println(res);
+    }
+
+    public static int reverse2(int x) {
+        int res = 0;
+        while (x != 0) {
+            //res=0,x=123
+            //res=3,x=12
+            //res=32,x=1
+            res = res * 10 + x % 10;
+            x /= 10;
+        }
+        return res;
+    }
+
     public int reverse(int x) {
         int ans = 0;
         for (; x != 0; x /= 10) {
diff --git a/solution/0000-0099/0010.Regular Expression Matching/README.md b/solution/0000-0099/0010.Regular Expression Matching/README.md
@@ -125,8 +125,7 @@ class Solution {
                     if (i > 0 && (p.charAt(j - 2) == '.' || p.charAt(j - 2) == s.charAt(i - 1))) {
                         f[i][j] |= f[i - 1][j];
                     }
-                } else if (i > 0
-                    && (p.charAt(j - 1) == '.' || p.charAt(j - 1) == s.charAt(i - 1))) {
+                } else if (i > 0 && (p.charAt(j - 1) == '.' || p.charAt(j - 1) == s.charAt(i - 1))) {
                     f[i][j] = f[i - 1][j - 1];
                 }
             }
diff --git a/solution/0000-0099/0010.Regular Expression Matching/Solution.java b/solution/0000-0099/0010.Regular Expression Matching/Solution.java
@@ -1,8 +1,15 @@
 package com.solution._0010;
-import change.datastructure.*;
-import java.util.*;
+
 public class Solution {
-    public boolean isMatch(String s, String p) {
+    public static void main(String[] args) {
+        String s = "aaa", p = "a*";
+        boolean res = isMatch(s, p);
+        System.out.println(res);
+        boolean res2 = isMatch2(s, p);
+        System.out.println(res2);
+    }
+
+    public static boolean isMatch(String s, String p) {
         int m = s.length(), n = p.length();
         boolean[][] f = new boolean[m + 1][n + 1];
         f[0][0] = true;
@@ -13,12 +20,28 @@ public boolean isMatch(String s, String p) {
                     if (i > 0 && (p.charAt(j - 2) == '.' || p.charAt(j - 2) == s.charAt(i - 1))) {
                         f[i][j] |= f[i - 1][j];
                     }
-                } else if (i > 0
-                    && (p.charAt(j - 1) == '.' || p.charAt(j - 1) == s.charAt(i - 1))) {
+                } else if (i > 0 && (p.charAt(j - 1) == '.' || p.charAt(j - 1) == s.charAt(i - 1))) {
                     f[i][j] = f[i - 1][j - 1];
                 }
+//                System.out.println("i=" + i + ",j=" + j + ",f[i][j]=" + f[i][j]);
             }
         }
         return f[m][n];
     }
+
+    /*
+    递归
+     */
+    public static boolean isMatch2(String s, String p) {
+        if (p.isEmpty()) {
+            return s.isEmpty();
+        }
+        boolean firstMatch = !s.isEmpty() && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.');
+        if (p.length() >= 2 && p.charAt(1) == '*') {
+            return isMatch2(s, p.substring(2)) || (firstMatch && isMatch2(s.substring(1), p));
+        } else {
+            return firstMatch && isMatch2(s.substring(1), p.substring(1));
+        }
+    }
+
 }
diff --git a/solution/0000-0099/0011.Container With Most Water/Solution.java b/solution/0000-0099/0011.Container With Most Water/Solution.java
@@ -2,6 +2,19 @@
 import change.datastructure.*;
 import java.util.*;
 public class Solution {
+    public static void main(String[] args) {
+
+    }
+    public static int maxArea2(int[] height) {
+        int l=0,r=height.length-1;
+        int max=0;
+        while (l < r) {
+            max = Math.max(Math.min(height[l], height[r]) * (r - l), max);
+            l++;
+            r--;
+        }
+        return max;
+    }
     public int maxArea(int[] height) {
         int i = 0, j = height.length - 1;
         int ans = 0;
diff --git a/solution/0000-0099/0015.3Sum/Solution.java b/solution/0000-0099/0015.3Sum/Solution.java
@@ -5,13 +5,17 @@
 import java.util.List;
 
 public class Solution {
+    public static void main(String[] args) {
+        List<List<Integer>> res = threeSum(new int[]{-1, 0, 1, 2, -1, -4});
+        System.out.println(res);
+    }
     /*
     将数组排序，这样相同的数字就会挨在一起，方便进行去重；
     从左到右枚举数组中的每个数字作为第一个数 a；
     在 a 右边的区域内使用双指针 left 和 right，找出所有满足 a + nums[left] + nums[right] == 0 的三元组，并将其加入结果集；
     注意去重。
      */
-    public List<List<Integer>> threeSum(int[] nums) {
+    public static List<List<Integer>> threeSum(int[] nums) {
         List<List<Integer>> result = new ArrayList<>();
         int n = nums.length;
         Arrays.sort(nums); // 排序
diff --git a/solution/0000-0099/0017.Letter Combinations of a Phone Number/Solution.java b/solution/0000-0099/0017.Letter Combinations of a Phone Number/Solution.java
@@ -1,14 +1,52 @@
 package com.solution._0017;
-import change.datastructure.*;
-import java.util.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
 public class Solution {
-    public List<String> letterCombinations(String digits) {
+    public static void main(String[] args) {
+        List<String> res = letterCombinations("2345");
+        System.out.println(res);
+        List<String> res2 = letterCombinations2("2345");
+        System.out.println(res2);
+    }
+
+    /*
+    递归调用 dfs 函数来遍历所有可能的情况。对于每一层递归，我们都会将当前数字对应的所有字母添加到当前组合中，然后继续搜索下一层。
+    当到达最后一个数字时，我们将当前组合添加到结果列表中并返回上一层递归。
+    该算法的时间复杂度是 O(3^n * 4^m)，其中 n 和 m 分别是数字 7 和 9 的数目。因为每个数字对应的字母数都不超过 4 个，且输入字符
+    串中只包含数字 2 到 9，因此在最坏情况下，我们需要遍历的所有情况数是 3^n * 4^m 种，其中 n 和 m 分别是数字 7 和 9 的数目。
+     */
+    private static final String[] mapping = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+    private static final List<String> result = new ArrayList<>();
+
+    public static List<String> letterCombinations2(String digits) {
+        if (digits == null || digits.length() == 0) {
+            return new ArrayList<>();
+        }
+        dfs(digits, "");
+        return result;
+    }
+
+    private static void dfs(String digits, String combination) {
+        System.out.println("digits=" + digits + ",combination=" + combination + ",");
+        if (digits.length() == 0) {
+            result.add(combination);
+            return;
+        }
+        String letters = mapping[digits.charAt(0) - '0'];
+        for (int i = 0; i < letters.length(); i++) {
+            dfs(digits.substring(1), combination + letters.charAt(i));
+        }
+    }
+
+    public static List<String> letterCombinations(String digits) {
         List<String> ans = new ArrayList<>();
         if (digits.length() == 0) {
             return ans;
         }
         ans.add("");
-        String[] d = new String[] {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        String[] d = new String[]{"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
         for (char i : digits.toCharArray()) {
             String s = d[i - '2'];
             List<String> t = new ArrayList<>();
diff --git a/solution/0000-0099/0022.Generate Parentheses/Solution.java b/solution/0000-0099/0022.Generate Parentheses/Solution.java
@@ -5,6 +5,11 @@ public class Solution {
     private List<String> ans = new ArrayList<>();
     private int n;
 
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        List<String> res = solution.generateParenthesis(4);
+        System.out.println(res);
+    }
     public List<String> generateParenthesis(int n) {
         this.n = n;
         dfs(0, 0, "");
diff --git a/solution/0000-0099/0024.Swap Nodes in Pairs/Solution.java b/solution/0000-0099/0024.Swap Nodes in Pairs/Solution.java
@@ -10,18 +10,26 @@
  */
 package com.solution._0024;
 import change.datastructure.*;
+import change.tools.listnode.ListNodeUtils;
+
 import java.util.*;
 public class Solution {
-    public ListNode swapPairs(ListNode head) {
+    public static void main(String[] args) {
+        ListNode listNode = new ListNode(1, new ListNode(2, new ListNode(3, new ListNode(4))));
+        ListNode result = swapPairs(listNode);
+        System.out.println(ListNodeUtils.getValues(result));
+    }
+
+    public static ListNode swapPairs(ListNode head) {
         ListNode dummy = new ListNode(0, head);
         ListNode pre = dummy, cur = head;
         while (cur != null && cur.next != null) {
-            ListNode t = cur.next;
-            cur.next = t.next;
-            t.next = cur;
-            pre.next = t;
-            pre = cur;
-            cur = cur.next;
+            ListNode t = cur.next;//t=2,3,4
+            cur.next = t.next;//cur=1,3,4
+            t.next = cur;//t=2,1,3,4
+            pre.next = t;//pre=0,2,1,3,4
+            pre = cur;//pre=1,3,4
+            cur = cur.next;//cur=3,4
         }
         return dummy.next;
     }
diff --git a/solution/0000-0099/0026.Remove Duplicates from Sorted Array/Solution.java b/solution/0000-0099/0026.Remove Duplicates from Sorted Array/Solution.java
@@ -1,11 +1,16 @@
 package com.solution._0026;
-import change.datastructure.*;
-import java.util.*;
+
 public class Solution {
-    public int removeDuplicates(int[] nums) {
+    public static void main(String[] args) {
+        int res = removeDuplicates(new int[]{0, 0, 1, 1, 1, 2, 2, 3, 3, 4});
+        System.out.println(res);
+    }
+
+    public static int removeDuplicates(int[] nums) {
         int k = 0;
         for (int x : nums) {
             if (k == 0 || x != nums[k - 1]) {
+                System.out.println("k=" + k + ",num[k]=" + nums[k] + ",x=" + x);
                 nums[k++] = x;
             }
         }
diff --git a/solution/0000-0099/0027.Remove Element/Solution.java b/solution/0000-0099/0027.Remove Element/Solution.java
diff --git a/solution/0000-0099/0028.Find the Index of the First Occurrence in a String/Solution.java b/solution/0000-0099/0028.Find the Index of the First Occurrence in a String/Solution.java
diff --git a/solution/0000-0099/0029.Divide Two Integers/Solution.java b/solution/0000-0099/0029.Divide Two Integers/Solution.java

Original file line number	Diff line number	Diff line change
`@@ -125,8 +125,7 @@ class Solution {`
`125`	`125`	`if (i > 0 && (p.charAt(j - 2) == '.' \|\| p.charAt(j - 2) == s.charAt(i - 1))) {`
`126`	`126`	`f[i][j] \|= f[i - 1][j];`
`127`	`127`	`}`
`128`		`- } else if (i > 0`
`129`		`- && (p.charAt(j - 1) == '.' \|\| p.charAt(j - 1) == s.charAt(i - 1))) {`
	`128`	`+ } else if (i > 0 && (p.charAt(j - 1) == '.' \|\| p.charAt(j - 1) == s.charAt(i - 1))) {`
`130`	`129`	`f[i][j] = f[i - 1][j - 1];`
`131`	`130`	`}`
`132`	`131`	`}`