为链表篇 增加 Swift 实现

animation-simulation/链表篇/234. 回文链表.md

@@ -145,6 +145,35 @@ class Solution:
         return True
 ```
 
+Swift Code：
+
+```swift
+class Solution {
+    func isPalindrome(_ head: ListNode?) -> Bool {
+        // 这里需要用动态数组，因为我们不知道链表的长度
+        var arr:[Int?] = []
+        var copynode = head
+        // 将链表的值复制到数组中
+        while copynode != nil {
+            arr.append(copynode?.val)
+            copynode = copynode?.next
+        }
+        // 双指针遍历数组
+        var back = 0, pro = arr.count - 1
+        while back < pro {
+            // 判断两个指针的值是否相等
+            if arr[pro] != arr[back] {
+                return false
+            }
+            // 移动指针
+            back += 1
+            pro -= 1
+        }
+        return true
+    }
+}
+```
+
 这个方法可以直接通过，但是这个方法需要辅助数组，那我们还有其他更好的方法吗？
 
 **双指针翻转链表法**
@@ -375,3 +404,57 @@ class Solution:
         return low
 ```
 
+Swift Code：
+
+```swift
+class Solution {
+    func isPalindrome(_ head: ListNode?) -> Bool {
+        if head == nil || head?.next == nil {
+            return true
+        }
+        //找到中间节点，也就是翻转的头节点,这个在昨天的题目中讲到
+        //但是今天和昨天有一些不一样的地方就是，如果有两个中间节点返回第一个，昨天的题目是第二个
+        var midnode = searchmidnode(head)
+        //原地翻转链表，需要两个辅助指针。这个也是面试题目，大家可以做一下
+        //这里我们用的是midnode.next需要注意，因为我们找到的是中点，但是我们翻转的是后半部分
+        var backhalf = reverse(midnode?.next);
+        //遍历两部分链表，判断值是否相等
+        var p1 = head
+        var p2 = backhalf
+        while p2 != nil {
+            if p1?.val != p2?.val {
+                midnode?.next = reverse(backhalf)
+                return false
+            }
+            p1 = p1?.next
+            p2 = p2?.next
+        }
+        //还原链表并返回结果，这一步是需要注意的，我们不可以破坏初始结构，我们只是判断是否为回文，
+        //当然如果没有这一步也是可以AC，但是面试的时候题目要求可能会有这一条。
+        midnode?.next = reverse(backhalf)
+        return true
+    }
+    //找到中点
+    func searchmidnode(_ head: ListNode?) -> ListNode? {
+        var fast = head, slow = head
+        while fast?.next != nil && fast?.next?.next != nil {
+            fast = fast?.next?.next
+            slow = slow?.next
+        }
+        return slow
+    }
+    //翻转链表
+    func reverse(_ slow: ListNode?) -> ListNode? {
+        var slow = slow
+        var low: ListNode?
+        var temp: ListNode?
+        while slow != nil {
+            temp = slow?.next
+            slow?.next = low
+            low = slow
+            slow = temp
+        }
+        return low
+    }
+}
+```