update code

src/main/java/git/snippet/list/Code_ReverseDoubleList.java

 package git.snippet.list;
 
-import java.util.ArrayList;
-import java.util.List;
-
 // 反转双向链表
 // 笔记：https://www.cnblogs.com/greyzeng/p/16629407.html
 public class Code_ReverseDoubleList {
@@ -23,99 +20,6 @@ public class Code_ReverseDoubleList {
         return pre;
     }
 
-    public static DoubleNode testReverseDoubleList(DoubleNode head) {
-        if (head == null) {
-            return null;
-        }
-        ArrayList<DoubleNode> list = new ArrayList<>();
-        while (head != null) {
-            list.add(head);
-            head = head.next;
-        }
-        list.get(0).next = null;
-        DoubleNode pre = list.get(0);
-        int N = list.size();
-        for (int i = 1; i < N; i++) {
-            DoubleNode cur = list.get(i);
-            cur.last = null;
-            cur.next = pre;
-            pre.last = cur;
-            pre = cur;
-        }
-        return list.get(N - 1);
-    }
-
-    // for test
-    public static DoubleNode generateRandomDoubleList(int len, int value) {
-        int size = (int) (Math.random() * (len + 1));
-        if (size == 0) {
-            return null;
-        }
-        size--;
-        DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
-        DoubleNode pre = head;
-        while (size != 0) {
-            DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
-            pre.next = cur;
-            cur.last = pre;
-            pre = cur;
-            size--;
-        }
-        return head;
-    }
-
-    // for test
-    public static List<Integer> getDoubleListOriginOrder(DoubleNode head) {
-        List<Integer> ans = new ArrayList<>();
-        while (head != null) {
-            ans.add(head.value);
-            head = head.next;
-        }
-        return ans;
-    }
-
-    // for test
-    public static boolean checkDoubleListReverse(List<Integer> origin, DoubleNode head) {
-        DoubleNode end = null;
-        for (int i = origin.size() - 1; i >= 0; i--) {
-            if (!origin.get(i).equals(head.value)) {
-                return false;
-            }
-            end = head;
-            head = head.next;
-        }
-        for (int i = 0; i < origin.size(); i++) {
-            if (!origin.get(i).equals(end.value)) {
-                return false;
-            }
-            end = end.last;
-        }
-        return true;
-    }
-
-    // for test
-    public static void main(String[] args) {
-        int len = 50;
-        int value = 100;
-        int testTime = 100000;
-        System.out.println("测试开始!");
-        for (int i = 0; i < testTime; i++) {
-            DoubleNode node3 = generateRandomDoubleList(len, value);
-            List<Integer> list3 = getDoubleListOriginOrder(node3);
-            node3 = reverseDoubleList(node3);
-            if (!checkDoubleListReverse(list3, node3)) {
-                System.out.println("出错了!");
-            }
-
-            DoubleNode node4 = generateRandomDoubleList(len, value);
-            List<Integer> list4 = getDoubleListOriginOrder(node4);
-            node4 = reverseDoubleList(node4);
-            if (!checkDoubleListReverse(list4, node4)) {
-                System.out.println("出错了!");
-            }
-        }
-        System.out.println("测试结束!");
-    }
 
     public static class DoubleNode {
         public int value;

src/main/java/git/snippet/list/LeetCode_0206_ReverseLinkedList.java

@@ -7,31 +7,31 @@ package git.snippet.list;
 // both?
 public class LeetCode_0206_ReverseLinkedList {
     // 非递归版本
-    public ListNode reverseList2(ListNode h) {
-        if (h == null || h.next == null) {
-            return h;
-        }
+    public ListNode reverseList2(ListNode head) {
         ListNode pre = null;
-        ListNode cur = h;
+        ListNode cur = head;
         while (cur != null) {
-            ListNode t = cur.next;
+            ListNode tmp = cur.next;
             cur.next = pre;
             pre = cur;
-            cur = t;
+            cur = tmp;
         }
         return pre;
     }
 
     // 递归版本
-    // 反转head为头的链表，并把反转后的头节点返回
     public ListNode reverseList(ListNode head) {
+        return reverse(head);
+    }
+
+    public ListNode reverse(ListNode head) {
         if (head == null || head.next == null) {
             return head;
         }
-        ListNode newHead = reverseList(head.next);
+        ListNode preHead = reverse(head.next);
         head.next.next = head;
         head.next = null;
-        return newHead;
+        return preHead;
     }
 
     public class ListNode {

src/test/java/git/snippet/list/Code_ReverseDoubleListTest.java

+package git.snippet.list;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static git.snippet.list.Code_ReverseDoubleList.DoubleNode;
+import static git.snippet.list.Code_ReverseDoubleList.reverseDoubleList;
+
+@DisplayName("反转双向链表")
+class Code_ReverseDoubleListTest {
+
+    DoubleNode testReverseDoubleList(DoubleNode head) {
+        if (head == null) {
+            return null;
+        }
+        ArrayList<DoubleNode> list = new ArrayList<>();
+        while (head != null) {
+            list.add(head);
+            head = head.next;
+        }
+        list.get(0).next = null;
+        DoubleNode pre = list.get(0);
+        int N = list.size();
+        for (int i = 1; i < N; i++) {
+            DoubleNode cur = list.get(i);
+            cur.last = null;
+            cur.next = pre;
+            pre.last = cur;
+            pre = cur;
+        }
+        return list.get(N - 1);
+    }
+
+    // for test
+    public DoubleNode generateRandomDoubleList(int len, int value) {
+        int size = (int) (Math.random() * (len + 1));
+        if (size == 0) {
+            return null;
+        }
+        size--;
+        DoubleNode head = new DoubleNode((int) (Math.random() * (value + 1)));
+        DoubleNode pre = head;
+        while (size != 0) {
+            DoubleNode cur = new DoubleNode((int) (Math.random() * (value + 1)));
+            pre.next = cur;
+            cur.last = pre;
+            pre = cur;
+            size--;
+        }
+        return head;
+    }
+
+    // for test
+    public List<Integer> getDoubleListOriginOrder(DoubleNode head) {
+        List<Integer> ans = new ArrayList<>();
+        while (head != null) {
+            ans.add(head.value);
+            head = head.next;
+        }
+        return ans;
+    }
+
+    // for test
+    public boolean checkDoubleListReverse(List<Integer> origin, DoubleNode head) {
+        DoubleNode end = null;
+        for (int i = origin.size() - 1; i >= 0; i--) {
+            if (!origin.get(i).equals(head.value)) {
+                return false;
+            }
+            end = head;
+            head = head.next;
+        }
+        for (int i = 0; i < origin.size(); i++) {
+            if (!origin.get(i).equals(end.value)) {
+                return false;
+            }
+            end = end.last;
+        }
+        return true;
+    }
+
+    // for test
+    @Test
+    void testDoubleList() {
+        int len = 50;
+        int value = 100;
+        int testTime = 100000;
+        System.out.println("测试开始!");
+        for (int i = 0; i < testTime; i++) {
+            DoubleNode node3 = generateRandomDoubleList(len, value);
+            List<Integer> list3 = getDoubleListOriginOrder(node3);
+            node3 = reverseDoubleList(node3);
+            if (!checkDoubleListReverse(list3, node3)) {
+                System.out.println("出错了!");
+            }
+
+            DoubleNode node4 = generateRandomDoubleList(len, value);
+            List<Integer> list4 = getDoubleListOriginOrder(node4);
+            node4 = reverseDoubleList(node4);
+            if (!checkDoubleListReverse(list4, node4)) {
+                System.out.println("出错了!");
+            }
+        }
+        System.out.println("测试结束!");
+    }
+}
\ No newline at end of file