[Swift]LeetCode143. 重排链表 | Reorder List

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9968081.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…

You may not modify the values in the list's nodes, only nodes itself may be changed.

Example 1:

Given 1->2->3->4, reorder it to 1->4->2->3.

Example 2:

Given 1->2->3->4->5, reorder it to 1->5->2->4->3.

---

给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1:

给定链表 1->2->3->4, 重新排列为 1->4->2->3.

示例 2:

给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

---

72ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reorderList(_ head: ListNode?) {
        var arr = [ListNode]()
        var cur = head
        while cur != nil {
            arr.append(cur!)
            cur = cur!.next
        }
        var i = 0
        var j = arr.count - 1
        
        cur = nil
        while i <= j {
            if i == j {
                cur?.next = arr[j]
                cur = arr[j]
                break
            }
            
            cur?.next = arr[i]
            arr[i].next = arr[j]
            cur = arr[j]
            
            i += 1
            j -= 1
        }
        cur?.next = nil
    }
}

---

80ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reorderList(_ head: ListNode?) -> ListNode? {
        guard let head = head else { return nil }
        var slow: ListNode? = head
        var fast: ListNode? = head
        while fast?.next?.next != nil {
            fast = fast?.next?.next
            slow = slow?.next
        }
        let next = reverseList(slow?.next)
        slow?.next = nil
        slow = head
        fast = next
        var curr: ListNode? = nil
        while slow != nil {
            curr?.next = slow
            curr = fast
            let tmp = slow?.next
            slow?.next = fast
            slow = tmp
            fast = fast?.next
        }
        return head
    }
    
    func reverseList(_ head: ListNode?) -> ListNode? {
        guard let head = head else { return nil }
        var curr: ListNode? = head
        var prev: ListNode? = nil 
        while curr != nil {
            let tmp = curr?.next
            curr?.next = prev
            prev = curr
            curr = tmp
        }
        return prev
    }
}

---

84ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reorderList(_ head: ListNode?) {
        if head?.next?.next == nil { return }
        
        var slow: ListNode? = head
        var quick: ListNode? = head
        
        while (true) {
            if quick?.next?.next == nil { break }
            slow = slow?.next
            quick = quick?.next?.next
        }
        
        // 1 // 1, 2
        // if slow?.val == quick?.val { return }

        // 1,2,3
        var second: ListNode = slow!.next!
        slow!.next = nil
        var first: ListNode = head!
        
        
        revNode(&second)
        
        // debug(first)
        // debug(second)
        let resHead = mergNode(first, second)
        // debug(resHead)
        
        head?.next = resHead.next
    }
    
    func revNode(_ head: inout ListNode) {
        var prev: ListNode?
        var cur: ListNode? = head
        
        while (cur != nil) {
            let temp: ListNode? = cur?.next
            cur?.next = prev
            prev = cur
            cur = temp
        }
        
        head = prev!
    }
    
    func mergNode(_ n1: ListNode, _ n2: ListNode) -> ListNode {
        var cur1: ListNode? = n1
        var cur2: ListNode? = n2
        
        let head: ListNode = ListNode(0)
        var cur: ListNode? = head
        
        var m1 = true
        while (true) {
            if m1 {
                cur?.next = cur1
                cur = cur?.next
                cur1 = cur1?.next
            } else {
                cur?.next = cur2
                cur = cur?.next
                cur2 = cur2?.next
            }
            m1 = !m1
            if cur1 == nil && cur2 == nil { break }
        }
        
        return head.next!
    }
    
    func debug(_ node: ListNode?) {
        var temp: ListNode? = node
        var res = ""
        while temp != nil {
            res += String(temp!.val) + " "
            temp = temp!.next
        }
        print(res)
    }
}

---

92ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reorderList(_ head: ListNode?) {
        if head == nil || head?.next == nil {
            return
        }
        
        var p1: ListNode? = head
        var p2: ListNode? = head
        while p2?.next != nil && p2?.next?.next != nil {
            p1 = p1?.next
            p2 = p2?.next?.next
        }
        
        //reverse the 2nd half
        let preMiddle: ListNode? = p1
        let preCur: ListNode? = p1?.next
        while preCur?.next != nil {
            let cur = preCur?.next
            preCur?.next = cur?.next
            cur?.next = preMiddle?.next
            preMiddle?.next = cur
        }
        
        // reconstruct the link 
        p1 = head
        p2 = preMiddle?.next
        while p1 !== preMiddle {
            preMiddle?.next = p2?.next
            p2?.next = p1?.next
            p1?.next = p2
            p1 = p2?.next
            p2 = preMiddle?.next
        }
    }
}

---

104ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reorderList(_ head: ListNode?) {
        guard let head = head else {
            return
        }
        
        var next: ListNode? = head
        var reverseNodes: [ListNode] = []
        while next != nil {
            reverseNodes.append(next!)
            next = next?.next
        }

        next = head
        var index = reverseNodes.count - 1
        while index >= reverseNodes.count / 2 {
            let temp = next?.next
            next?.next = reverseNodes[index]
            reverseNodes[index].next = temp
            next = temp

            index -= 1
        }

        reverseNodes[index + 1].next = nil
    }
}

---

108ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func reorderList(_ head: ListNode?) {
        guard let head = head else {
            return
        }
  
        var prev: ListNode? = head
        var post: ListNode? = head
  
        _split(&prev, &post)
        prev = head
  
        post = _reverse(&post)
  
        _merge(&prev, &post)
    }
    
     private func _split(_ prev: inout ListNode?, _ post: inout ListNode?) {
        while post != nil && post!.next != nil {
            prev = prev!.next
            post = post!.next!.next
        }
  
        post = prev!.next
        prev!.next = nil
    }

    private func _reverse(_ head:inout ListNode?) -> ListNode? {
        var prev = head
        var temp: ListNode?
  
        while prev != nil {
            let post = prev!.next
    
            prev!.next = temp
    
            temp = prev
            prev = post
        }
  
        return temp
    }

    private func _merge(_ prev:inout ListNode?, _ post:inout ListNode?) {
        while prev != nil && post != nil{
            let preNext = prev!.next
            let posNext = post!.next
    
            prev!.next = post
            post!.next = preNext
    
            prev = preNext
            post = posNext
        }
    }
}