[Swift]LeetCode328. 奇偶链表 | Odd Even Linked List

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given a singly linked list, group all odd nodes together followed by the even nodes. Please note here we are talking about the node number and not the value in the nodes.

You should try to do it in place. The program should run in O(1) space complexity and O(nodes) time complexity.

Example 1:

1->2->3->4->5->NULL
1->3->5->2->4->NULL

Example 2:

->1->3->5->6->4->7->NULL
2->3->6->7->1->5->4->NULL

Note:

• The relative order inside both the even and odd groups should remain as it was in the input.
• The first node is considered odd, the second node even and so on ...

---

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例 2:

输入: 2->1->3->5->6->4->7->NULL 
输出: 2->3->6->7->1->5->4->NULL

说明:

• 应当保持奇数节点和偶数节点的相对顺序。
• 链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。

---

36ms

class Solution {
    func oddEvenList(_ head: ListNode?) -> ListNode? {
        let dummy = ListNode(0)
        var node = head
        var next = head?.next
        var oddEnd: ListNode?
        let evenHead = head?.next
        dummy.next = node
        var isOdd = true
        while node != nil {
            node?.next = node?.next?.next
            if isOdd {
                oddEnd = node
            }
            node = next
            next = next?.next
            isOdd = !isOdd
        }
        oddEnd?.next = evenHead
        return dummy.next
    }
}

---

40ms

/**
 * 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 oddEvenList(_ head: ListNode?) -> ListNode? {
        var odd: ListNode? = head
        var even: ListNode? = head?.next
        var evenFirst: ListNode? = even
        
        while true {
            if odd == nil || even == nil || even?.next == nil {
                odd?.next = evenFirst
                break
            }
            
            // Connecting odd
            odd?.next = even?.next
            odd = even?.next
            
            if odd?.next == nil {
                even?.next = nil
                odd?.next = evenFirst
                break
            }
            
            // Connection even
            even?.next = odd?.next
            even = even?.next
            
        }
        
        return head
    }
}

---

44ms

/**
 * 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 oddEvenList(_ head: ListNode?) -> ListNode? {
        var oddNode = head?.next?.next
        var evenNode = head?.next
        let evenHeadNode = head?.next
        var node = head
        while oddNode != nil {
            evenNode?.next = oddNode?.next
            node?.next = oddNode
            oddNode?.next = evenHeadNode
            node = oddNode
            evenNode = evenNode?.next
            oddNode = evenNode?.next
        }
        
        return head
    }
}

---

56ms

class Solution {
    func oddEvenList(_ head: ListNode?) -> ListNode? {
        let dummy = ListNode(0)
        let dummyOdd = ListNode(0)
        dummy.next = head
        var cur = head
        var curOdd = head?.next
        var index = 1
        dummyOdd.next = curOdd
        while cur?.next != nil  && curOdd?.next != nil{
            if index % 2 == 1 {
                cur?.next = curOdd?.next
                cur = cur?.next
            }else {
                curOdd?.next = cur?.next
                curOdd = curOdd?.next
            }
            index += 1
        }
        cur?.next = dummyOdd.next
        curOdd?.next = nil
        return dummy.next
    }
}

---

64ms

/**
 * 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 oddEvenList(_ head: ListNode?) -> ListNode? {
        var i = head
        var j = head?.next
        let jH = j
        
        while i?.next?.next != nil || j?.next?.next != nil {
            if i?.next?.next != nil {
                i?.next = i?.next?.next
                i = i?.next
            }
            if j?.next?.next != nil {
                j?.next = j?.next?.next
                j = j?.next
            }
        }
        j?.next = nil // 清空偶数节点的next
        i?.next = jH
        return head
    }
}

---

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 oddEvenList(_ head: ListNode?) -> ListNode? {
        var first = head
        var second = head?.next
        let doulbeNode = second
        var lastCNode = head
        while first != nil || second != nil {
            first?.next = second?.next
            lastCNode = first
            first = first?.next
            second?.next = first?.next
            second = second?.next
        }
        lastCNode?.next = doulbeNode
        return head
    }
}