[Swift]LeetCode19. 删除链表的倒数第N个节点 | Remove Nth Node From End of List

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

Given a linked list, remove the n-th node from the end of list and return its head.

Example:

Given linked list: 1->2->3->4->5, and n = 2.

After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:

Given n will always be valid.

Follow up:

Could you do this in one pass?

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

说明：

给定的 n 保证是有效的。

进阶：

你能尝试使用一趟扫描实现吗？

---

 12ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        var endPointer : ListNode? = head
        var nFromEndPointer : ListNode? = nil
        var counter = n
        
        while endPointer != nil {            
            if counter == 0 {
                if nFromEndPointer == nil {
                    nFromEndPointer = head
                } else {
                    nFromEndPointer = nFromEndPointer?.next
                }
            }
            
            endPointer = endPointer?.next
            
            if counter > 0 {
                counter -= 1
            }
        }
        
        if nFromEndPointer == nil {
            if counter == 0 {
                return head?.next
            }
            return nil
        } else {
            nFromEndPointer?.next = nFromEndPointer?.next?.next
        }
        
        return head
    }
}

---

16ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
               let dummy = ListNode(0)
        var slow: ListNode? = dummy
        var fast: ListNode? = dummy
        
        slow?.next = head
        for _ in 1...(n + 1) {
            fast = fast?.next
        }
        while fast != nil {
            slow = slow?.next
            fast = fast?.next
        }
        slow?.next = slow?.next?.next
        
        return dummy.next
    }
}

---

20ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        guard let head = head else {
            
            return nil
        }
              
        
        if n == 1 && head.next == nil {
            
            return nil
        }
        
        var cur: ListNode? = head
        var last: ListNode? = head
        
        for i in 1..<n {

            last = last?.next
        }
        
        var prev: ListNode?
        while last?.next != nil  {
            prev = cur
            cur = cur?.next
            last = last?.next
        }
        
        prev?.next = prev?.next?.next
        
        return  prev == nil ? head.next : head
    }
}

---

20ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        var result:ListNode? = head;
        var tempNode:ListNode? = result;
        var tempNode2:ListNode? = result;
        if head! == nil {
            return head;
        }
        
        var i = 0;
        while i < n && tempNode!.next != nil {
            tempNode = tempNode!.next;
            i += 1;
        }
        while (tempNode!.next != nil) {  
            i += 1;
            tempNode = tempNode!.next;
            tempNode2 = tempNode2!.next;
        }
        if (i + 1 == n) {
            return result!.next;
        }else {
           tempNode2!.next = tempNode2!.next!.next; 
            return result;
        }
    }
}

---

24ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        var first: ListNode? = head
        var n:Int = n
        while(n-- != 0)
        {
            first=first!.next
        }
        if first == nil
        {
            return head!.next
        }
        var sec: ListNode? = head
        while(first!.next != nil)
        {
             sec = sec!.next
            first = first!.next
        }
        sec!.next = sec!.next!.next
        return head
    }
}

/*扩展Int类，实现自增++、自减--运算符*/
extension Int{
    //后缀--:先执行表达式后再自减
    static postfix func --(num:inout Int) -> Int {
        //输入输出参数num
        let temp = num
        //num减1
        num -= 1
         //返回减1前的数值
        return temp
    }
}

---

 24ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        guard let _ = head else {
            return nil
        }
 
        var preNode = head
        var curNode = head
        var count: Int = 0
        while count < n {
            curNode = curNode?.next
            count += 1
        }
        if curNode == nil {
            return preNode?.next
        }
        
        while let _ = curNode?.next {
            preNode = preNode?.next
            curNode = curNode?.next
        }
        
        preNode?.next = preNode?.next?.next
        return head
    }
}

---

28ms

/**
 * 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 removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        var resultArray = [ListNode]()
        var tmpNode = head
        var resultNode = head
        repeat {
            resultArray.append(tmpNode!)
            tmpNode = tmpNode?.next
        }while tmpNode != nil
        
        let arrayCount = resultArray.count
        if arrayCount == n {
            resultNode = head?.next
            return resultNode
        }
        resultArray[arrayCount - n - 1].next = resultArray[arrayCount - n].next
        return resultNode
    }
}