update

chenweijie · chenweijie · commit 2fc6fdc43dc6 · 2020-09-29T17:53:51.000+08:00
diff --git a/src/main/java/com/chen/algorithm/study/test19/Solution3.java b/src/main/java/com/chen/algorithm/study/test19/Solution3.java
@@ -0,0 +1,46 @@
+package com.chen.algorithm.study.test19;
+
+/**
+ * 正确，写的不规整
+ *
+ * @author :  chen weijie
+ * @Date: 2019-11-10 00:25
+ */
+public class Solution3 {
+
+
+    class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int x) {
+            val = x;
+        }
+    }
+
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+
+        if (head == null){
+            return head;
+        }
+
+        ListNode pre = new ListNode(-1);
+        pre.next = head;
+
+        ListNode fast = pre;
+        ListNode slow = pre;
+
+        for (int i = 0; i < n-1; i++) {
+            fast = fast.next;
+        }
+
+        while (fast.next != null) {
+            fast = fast.next;
+            slow = slow.next;
+        }
+        slow.next = slow.next.next;
+        return pre.next;
+    }
+
+
+}
diff --git a/src/main/java/com/chen/algorithm/study/test206/ListNode.java b/src/main/java/com/chen/algorithm/study/test206/ListNode.java
diff --git a/src/main/java/com/chen/algorithm/study/test206/SolutionTest.java b/src/main/java/com/chen/algorithm/study/test206/SolutionTest.java
@@ -1,15 +1,13 @@
 package com.chen.algorithm.study.test206;
 
-import org.junit.Test;
-
 /**
  * @author :  chen weijie
  * @Date: 2019-09-08 01:38
  */
 public class SolutionTest {
 
 
-    public ListNode reverseList(ListNode head) {
+    public static ListNode reverseList(ListNode head) {
 
         if (head == null || head.next == null) {
             return head;
@@ -25,9 +23,8 @@ public ListNode reverseList(ListNode head) {
         return pre;
     }
 
-    @Test
-    public void testCase() {
 
+    public static void main(String[] args) {
         ListNode l1_1 = new ListNode(4);
         ListNode l1_2 = new ListNode(6);
         ListNode l1_3 = new ListNode(10);
@@ -42,3 +39,13 @@ public void testCase() {
     }
 
 }
+
+class ListNode {
+
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+    }
+}
diff --git a/src/main/java/com/chen/algorithm/study/test25/Solution1.java b/src/main/java/com/chen/algorithm/study/test25/Solution1.java
@@ -29,7 +29,6 @@ public ListNode reverseKGroup(ListNode head, int k) {
         ListNode tail = dummy;
 
         while (true) {
-
             int count = 0;
             while (tail != null && count != k) {
                 tail = tail.next;
diff --git a/src/main/java/com/chen/algorithm/study/test25/Solution3.java b/src/main/java/com/chen/algorithm/study/test25/Solution3.java
@@ -27,7 +27,7 @@ public ListNode reverseKGroup(ListNode head, int k) {
         while (true) {
 
             int count = 0;
-            while (tail != null || count != k) {
+            while (tail != null && count != k) {
                 count++;
                 tail = tail.next;
             }
diff --git a/src/main/java/com/chen/algorithm/study/test25/Solution4.java b/src/main/java/com/chen/algorithm/study/test25/Solution4.java
@@ -0,0 +1,60 @@
+package com.chen.algorithm.study.test25;
+
+/**
+ * https://leetcode-cn.com/problems/reverse-nodes-in-k-group/solution/tu-jie-kge-yi-zu-fan-zhuan-lian-biao-by-user7208t/
+ *
+ * @author :  chen weijie
+ * @Date: 2020-09-20 01:29
+ */
+public class Solution4 {
+
+    class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int x) {
+            val = x;
+        }
+    }
+
+    public ListNode reverseKGroup(ListNode head, int k) {
+
+        if (head == null) {
+            return head;
+        }
+
+        ListNode dummy = new ListNode(-1);
+        dummy.next = head;
+        ListNode pre = dummy;
+        ListNode tail = dummy;
+
+
+        while (true) {
+            int count = 0;
+            while (tail != null && count != k) {
+                tail = tail.next;
+                count++;
+            }
+
+            if (tail == null) {
+                break;
+            }
+
+            ListNode head1 = pre.next;
+
+            while (pre.next != tail) {
+                ListNode curr = pre.next;
+                pre.next = curr.next;
+                curr.next = tail.next;
+                tail.next = curr;
+            }
+
+            tail = head1;
+            pre = head1;
+        }
+
+        return dummy.next;
+    }
+
+
+}
diff --git a/src/main/java/com/chen/algorithm/study/test3/Solution4.java b/src/main/java/com/chen/algorithm/study/test3/Solution4.java
@@ -0,0 +1,45 @@
+package com.chen.algorithm.study.test3;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 写的不简洁
+ *
+ * @author :  chen weijie
+ * @Date: 2019-09-03 00:00
+ */
+public class Solution4 {
+
+    public int lengthOfLongestSubstring(String s) {
+
+        if (s == null || "".equals(s)) {
+            return 0;
+        }
+        Map<Character, Integer> map = new HashMap<>();
+
+        int max = 0;
+        int left = 0;
+
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (map.containsKey(c)) {
+                left = Math.max(left, map.get(c));
+            }
+            max = Math.max(max, i - left);
+            map.put(c, i);
+        }
+        return max;
+    }
+
+
+    @Test
+    public void testCase() {
+        System.out.println(lengthOfLongestSubstring("cdfcg"));
+    }
+
+
+}
diff --git a/src/main/java/com/chen/algorithm/study/test300/Solution3.java b/src/main/java/com/chen/algorithm/study/test300/Solution3.java
@@ -0,0 +1,48 @@
+package com.chen.algorithm.study.test300;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+
+/**
+ * https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-2/
+ *
+ * @author :  chen weijie
+ * @Date: 2019-12-22 16:28
+ */
+public class Solution3 {
+
+    public int lengthOfList(int[] nums) {
+
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+        int len = nums.length;
+
+        int[] dp = new int[len];
+        int max = 1;
+        Arrays.fill(dp, 1);
+        for (int i = 1; i < len; i++) {
+            for (int j = 0; j < i; j++) {
+                if (nums[i] > nums[j]) {
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
+                }
+            }
+            max = Math.max(dp[i], max);
+        }
+
+        return max;
+    }
+
+
+    @Test
+    public void testCase() {
+        int[] n = {4, 1, -4, 7, -2, 9, 0};
+
+        System.out.println(lengthOfList(n));
+
+
+    }
+
+
+}

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public ListNode reverseKGroup(ListNode head, int k) {`
`27`	`27`	`while (true) {`
`28`	`28`
`29`	`29`	`int count = 0;`
`30`		`- while (tail != null \|\| count != k) {`
	`30`	`+ while (tail != null && count != k) {`
`31`	`31`	`count++;`
`32`	`32`	`tail = tail.next;`
`33`	`33`	`}`