Algorithm Of Swift -- 3.链表反转

题目描述：

        反转一个单链表。

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

解法1：
public class ListNode<T> {
    public var val: T
    public var next: ListNode?
    public init(_ val: T) {
        self.val = val
        self.next = nil
    }
}

func reverseList(_ head: ListNode<Any>?) -> ListNode<Any>? {
    var prev: ListNode<Any>? = nil
    var curr = head
    
    while curr != nil {
        let nextT = curr?.next
        curr?.next = prev //curr?.next = nil
        prev = curr!
        curr = nextT
    }
    
    return prev
}

在遍历列表时，将当前节点的 next 指针改为指向前一个元素。由于节点没有引用其上一个节点，因此必须事先存储其前一个元素。在更改引用之前，还需要另一个指针来存储下一个节点。最后返回新的头引用！

验证解法1：
let a:ListNode<Any>? = ListNode(1)
let b:ListNode<Any>? = ListNode(2)
let c:ListNode<Any>? = ListNode(3)
let d:ListNode<Any>? = ListNode(4)
let e:ListNode<Any>? = ListNode(5)
a?.next = b
b?.next = c
c?.next = d
d?.next = e
e?.next = nil
/*
 (lldb) p a
 (Test.ListNode<Any>?) $R0 = 0x000000010585b7f0 {
   val = 1
   next = 0x000000010585b830 {
     val = 2
     next = 0x000000010585b870 {
       val = 3
       next = 0x000000010585b8b0 {
         val = 4
         next = 0x000000010585b8f0 {
           val = 5
           next = nil
         }
       }
     }
   }
 }
 */
let x = reverseList(a)
/*
 (lldb) p x
 (Test.ListNode<Any>?) $R0 = 0x000000010113c690 {
   val = 5
   next = 0x000000010113c650 {
     val = 4
     next = 0x000000010113c3d0 {
       val = 3
       next = 0x000000010113c390 {
         val = 2
         next = 0x000000010113c350 {
           val = 1
           next = nil
         }
       }
     }
   }
 }
 */

/**
 复杂度分析

 时间复杂度：O(n)，假设n是列表的长度，时间复杂度是O(n)。
 空间复杂度：O(1)。
 */