feat: add python and java solutions to leetcode problem: No.0234

yanglbme · yanglbme · commit bf2c587c2bef · 2020-12-15T09:43:40.000+08:00
diff --git a/README.md b/README.md
@@ -59,6 +59,7 @@
 1. [删除链表的节点](/lcof/面试题18.%20删除链表的节点/README.md)
 1. [链表中倒数第 k 个节点](/lcci/02.02.Kth%20Node%20From%20End%20of%20List/README.md)
 1. [反转链表](/solution/0200-0299/0206.Reverse%20Linked%20List/README.md)
+1. [回文链表](/solution/0200-0299/0234.Palindrome%20Linked%20List/README.md)
 1. [环形链表](/solution/0100-0199/0141.Linked%20List%20Cycle/README.md)
 1. [环形链表 II](/solution/0100-0199/0142.Linked%20List%20Cycle%20II/README.md)
 
diff --git a/README_EN.md b/README_EN.md
@@ -57,6 +57,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 1. [Delete Node in a Linked List](/solution/0200-0299/0237.Delete%20Node%20in%20a%20Linked%20List/README_EN.md)
 1. [Kth Node From End of List](/lcci/02.02.Kth%20Node%20From%20End%20of%20List/README_EN.md)
 1. [Reverse Linked List](/solution/0200-0299/0206.Reverse%20Linked%20List/README_EN.md)
+1. [Palindrome Linked List](/solution/0200-0299/0234.Palindrome%20Linked%20List/README_EN.md)
 1. [Linked List Cycle](/solution/0100-0199/0141.Linked%20List%20Cycle/README_EN.md)
 1. [Linked List Cycle II](/solution/0100-0199/0142.Linked%20List%20Cycle%20II/README_EN.md)
 
diff --git a/lcci/02.06.Palindrome Linked List/README.md b/lcci/02.06.Palindrome Linked List/README.md
@@ -30,7 +30,7 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-先利用快慢指针找到链表中点，之后将后半部分链表利用头插法逆序，再比对前后两段链表得出结果。
+先用快慢指针找到链表的中点，接着反转右半部分的链表。然后同时遍历前后两段链表，若前后两段链表节点对应的值不等，说明不是回文链表，否则说明是回文链表。
 
 <!-- tabs:start -->
 
@@ -44,28 +44,22 @@
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None
-
 class Solution:
     def isPalindrome(self, head: ListNode) -> bool:
         if head is None or head.next is None:
             return True
         slow, fast = head, head.next
         while fast and fast.next:
-            fast = fast.next.next
-            slow = slow.next
-        cur = slow.next
-        slow.next = None
+            slow, fast = slow.next, fast.next.next
+        pre, cur = None, slow.next
         while cur:
             t = cur.next
-            cur.next = slow.next
-            slow.next = cur
-            cur = t
-        t = slow.next
-        while t:
-            if head.val != t.val:
+            cur.next = pre
+            pre, cur = cur, t
+        while pre:
+            if pre.val != head.val:
                 return False
-            t = t.next
-            head = head.next
+            pre, head = pre.next, head.next
         return True
 ```
 
@@ -87,26 +81,27 @@ class Solution {
         if (head == null || head.next == null) {
             return true;
         }
-        ListNode slow = head, fast = head.next;
+        ListNode slow = head;
+        ListNode fast = head.next;
         while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
         }
         ListNode cur = slow.next;
         slow.next = null;
+        ListNode pre = null;
         while (cur != null) {
             ListNode t = cur.next;
-            cur.next = slow.next;
-            slow.next = cur;
+            cur.next = pre;
+            pre = cur;
             cur = t;
         }
-        ListNode t = slow.next;
-        while (t != null) {
-            if (head.val != t.val) {
+        while (pre != null) {
+            if (pre.val != head.val) {
                 return false;
             }
+            pre = pre.next;
             head = head.next;
-            t = t.next;
         }
         return true;
     }
diff --git a/lcci/02.06.Palindrome Linked List/README_EN.md b/lcci/02.06.Palindrome Linked List/README_EN.md
@@ -46,28 +46,22 @@ Could you do it in O(n) time and O(1) space?</p>
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None
-
 class Solution:
     def isPalindrome(self, head: ListNode) -> bool:
         if head is None or head.next is None:
             return True
         slow, fast = head, head.next
         while fast and fast.next:
-            fast = fast.next.next
-            slow = slow.next
-        cur = slow.next
-        slow.next = None
+            slow, fast = slow.next, fast.next.next
+        pre, cur = None, slow.next
         while cur:
             t = cur.next
-            cur.next = slow.next
-            slow.next = cur
-            cur = t
-        t = slow.next
-        while t:
-            if head.val != t.val:
+            cur.next = pre
+            pre, cur = cur, t
+        while pre:
+            if pre.val != head.val:
                 return False
-            t = t.next
-            head = head.next
+            pre, head = pre.next, head.next
         return True
 ```
 
@@ -87,26 +81,27 @@ class Solution {
         if (head == null || head.next == null) {
             return true;
         }
-        ListNode slow = head, fast = head.next;
+        ListNode slow = head;
+        ListNode fast = head.next;
         while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
         }
         ListNode cur = slow.next;
         slow.next = null;
+        ListNode pre = null;
         while (cur != null) {
             ListNode t = cur.next;
-            cur.next = slow.next;
-            slow.next = cur;
+            cur.next = pre;
+            pre = cur;
             cur = t;
         }
-        ListNode t = slow.next;
-        while (t != null) {
-            if (head.val != t.val) {
+        while (pre != null) {
+            if (pre.val != head.val) {
                 return false;
             }
+            pre = pre.next;
             head = head.next;
-            t = t.next;
         }
         return true;
     }
diff --git a/lcci/02.06.Palindrome Linked List/Solution.java b/lcci/02.06.Palindrome Linked List/Solution.java
@@ -11,26 +11,27 @@ public boolean isPalindrome(ListNode head) {
         if (head == null || head.next == null) {
             return true;
         }
-        ListNode slow = head, fast = head.next;
+        ListNode slow = head;
+        ListNode fast = head.next;
         while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
         }
         ListNode cur = slow.next;
         slow.next = null;
+        ListNode pre = null;
         while (cur != null) {
             ListNode t = cur.next;
-            cur.next = slow.next;
-            slow.next = cur;
+            cur.next = pre;
+            pre = cur;
             cur = t;
         }
-        ListNode t = slow.next;
-        while (t != null) {
-            if (head.val != t.val) {
+        while (pre != null) {
+            if (pre.val != head.val) {
                 return false;
             }
+            pre = pre.next;
             head = head.next;
-            t = t.next;
         }
         return true;
     }
diff --git a/lcci/02.06.Palindrome Linked List/Solution.py b/lcci/02.06.Palindrome Linked List/Solution.py
@@ -3,26 +3,20 @@
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None
-
 class Solution:
     def isPalindrome(self, head: ListNode) -> bool:
         if head is None or head.next is None:
             return True
         slow, fast = head, head.next
         while fast and fast.next:
-            fast = fast.next.next
-            slow = slow.next
-        cur = slow.next
-        slow.next = None
+            slow, fast = slow.next, fast.next.next
+        pre, cur = None, slow.next
         while cur:
             t = cur.next
-            cur.next = slow.next
-            slow.next = cur
-            cur = t
-        t = slow.next
-        while t:
-            if head.val != t.val:
+            cur.next = pre
+            pre, cur = cur, t
+        while pre:
+            if pre.val != head.val:
                 return False
-            t = t.next
-            head = head.next
+            pre, head = pre.next, head.next
         return True
diff --git a/solution/0200-0299/0234.Palindrome Linked List/README.md b/solution/0200-0299/0234.Palindrome Linked List/README.md
@@ -25,6 +25,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+先用快慢指针找到链表的中点，接着反转右半部分的链表。然后同时遍历前后两段链表，若前后两段链表节点对应的值不等，说明不是回文链表，否则说明是回文链表。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -37,38 +39,23 @@
 #     def __init__(self, x):
 #         self.val = x
 #         self.next = None
-
 class Solution:
     def isPalindrome(self, head: ListNode) -> bool:
-        if not head:
+        if head is None or head.next is None:
             return True
-        mid = self.find_mid_node(head)
-        second_half_list = self.reverse_list(mid.next)
-        result = True
-        p, q = head, second_half_list
-        while result and q:
-            if p.val != q.val:
-                result = False
-            else:
-                p, q = p.next, q.next
-        mid.next = self.reverse_list(second_half_list)
-        return result
-
-    def reverse_list(self, head):
-        pre, p = None, head
-        while p:
-            q = p.next
-            p.next = pre
-            pre = p
-            p = q
-        return pre
-
-    def find_mid_node(self, head):
-        slow = fast = head
-        while fast.next and fast.next.next:
+        slow, fast = head, head.next
+        while fast and fast.next:
             slow, fast = slow.next, fast.next.next
-        return slow
-
+        pre, cur = None, slow.next
+        while cur:
+            t = cur.next
+            cur.next = pre
+            pre, cur = cur, t
+        while pre:
+            if pre.val != head.val:
+                return False
+            pre, head = pre.next, head.next
+        return True
 ```
 
 ### **Java**
@@ -86,43 +73,32 @@ class Solution:
  */
 class Solution {
     public boolean isPalindrome(ListNode head) {
-        if (head == null) {
+        if (head == null || head.next == null) {
             return true;
         }
-        ListNode mid = findMidNode(head);
-        ListNode secondHalfList = reverseList(mid.next);
-        boolean result = true;
-        ListNode p = head, q = secondHalfList;
-        while (result && q != null) {
-            if (p.val != q.val) {
-                result = false;
-            } else {
-                p = p.next;
-                q = q.next;
-            }
-        }
-        mid.next = reverseList(secondHalfList);
-        return result;
-    }
-
-    private ListNode reverseList(ListNode head) {
-        ListNode pre = null, p = head;
-        while (p != null) {
-            ListNode q = p.next;
-            p.next = pre;
-            pre = p;
-            p = q;
-        }
-        return pre;
-    }
-
-    private ListNode findMidNode(ListNode head) {
-        ListNode slow = head, fast = head;
-        while (fast.next != null && fast.next.next != null) {
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while (fast != null && fast.next != null) {
             slow = slow.next;
             fast = fast.next.next;
         }
-        return slow;
+        ListNode cur = slow.next;
+        slow.next = null;
+        ListNode pre = null;
+        while (cur != null) {
+            ListNode t = cur.next;
+            cur.next = pre;
+            pre = cur;
+            cur = t;
+        }
+        while (pre != null) {
+            if (pre.val != head.val) {
+                return false;
+            }
+            pre = pre.next;
+            head = head.next;
+        }
+        return true;
     }
 }
 ```
diff --git a/solution/0200-0299/0234.Palindrome Linked List/README_EN.md b/solution/0200-0299/0234.Palindrome Linked List/README_EN.md
diff --git a/solution/0200-0299/0234.Palindrome Linked List/Solution.java b/solution/0200-0299/0234.Palindrome Linked List/Solution.java
diff --git a/solution/0200-0299/0234.Palindrome Linked List/Solution.py b/solution/0200-0299/0234.Palindrome Linked List/Solution.py
