From c9900267505297634675172ad670e86a2269cace Mon Sep 17 00:00:00 2001
From: JaneyLin <105125897+janeyziqinglin@users.noreply.github.com>
Date: Thu, 9 Jun 2022 21:11:08 -0500
Subject: [PATCH] =?UTF-8?q?Update=200234.=E5=9B=9E=E6=96=87=E9=93=BE?=
 =?UTF-8?q?=E8=A1=A8.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

For both solution of python3, there are shorter and more efficient ways to write it.
For the #数组模拟, it can be solved more easily by convert the linked list to  a list
#反转后半部分链表, the original version define to function, isPalindrome, and reverseList. That's too complicated... No need.
---
 problems/0234.回文链表.md | 80 ++++++++++++++---------------------
 1 file changed, 31 insertions(+), 49 deletions(-)

diff --git a/problems/0234.回文链表.md b/problems/0234.回文链表.md
index db910d4e..bbfe4e91 100644
--- a/problems/0234.回文链表.md
+++ b/problems/0234.回文链表.md
@@ -218,59 +218,41 @@ class Solution {
 ```python
 #数组模拟
 class Solution:
-    def isPalindrome(self, head: ListNode) -> bool:
-        length = 0
-        tmp = head
-        while tmp: #求链表长度
-            length += 1
-            tmp = tmp.next
-        
-        result = [0] * length
-        tmp = head
-        index = 0
-        while tmp: #链表元素加入数组
-            result[index] = tmp.val
-            index += 1
-            tmp = tmp.next
-        
-        i, j = 0, length - 1
-        while i < j: # 判断回文
-            if result[i] != result[j]:
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
+        list=[]
+        while head: 
+            list.append(head.val)
+            head=head.next
+        l,r=0, len(list)-1
+        while l<=r: 
+            if list[l]!=list[r]:
                 return False
-            i += 1
-            j -= 1
-        return True
-        
+            l+=1
+            r-=1
+        return True   
+      
 #反转后半部分链表
 class Solution:
-    def isPalindrome(self, head: ListNode) -> bool:
-        if head == None or head.next == None:
-            return True
-        slow, fast = head, head
-        while fast and fast.next:
-            pre = slow
-            slow = slow.next
-            fast = fast.next.next
-        
-        pre.next = None # 分割链表
-        cur1 = head # 前半部分
-        cur2 = self.reverseList(slow) # 反转后半部分，总链表长度如果是奇数，cur2比cur1多一个节点
-        while cur1:
-            if cur1.val != cur2.val:
-                return False
-            cur1 = cur1.next
-            cur2 = cur2.next
-        return True
+    def isPalindrome(self, head: Optional[ListNode]) -> bool:
+        fast = slow = head
 
-    def reverseList(self, head: ListNode) -> ListNode:
-        cur = head   
-        pre = None
-        while(cur!=None):
-            temp = cur.next # 保存一下cur的下一个节点
-            cur.next = pre # 反转
-            pre = cur
-            cur = temp
-        return pre
+        # find mid point which including (first) mid point into the first half linked list
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+        node = None
+
+        # reverse second half linked list
+        while slow:
+            slow.next, slow, node = node, slow.next, slow
+
+        # compare reversed and original half; must maintain reversed linked list is shorter than 1st half
+        while node:
+            if node.val != head.val:
+                return False
+            node = node.next
+            head = head.next
+        return True
 ```
 
 ## Go