SwiftでLinkedList

class LLNode<T> {
    var key: T? = nil
    var next: LLNode? = nil
    var prev: LLNode? = nil
    init() {
    }
    init(PREV prev:LLNode!, KEY key:T!, NEXT next:LLNode!) {
        self.prev = prev
        self.key = key
        self.next = next
    }
}

class LinkedList<T: Equatable> {
    private var head: LLNode<T> = LLNode<T>()
    private var tail: LLNode<T> = LLNode<T>()

    func appendKey(key: T) {
        var l = tail
        var newNode = LLNode<T>(PREV:l, KEY:key, NEXT:nil)
        tail = newNode
        if (l.key == nil) {
            head = newNode
        } else {
            l.next = newNode
        }
    }
    func removeKey(key: T) {
        var node: LLNode? = head
        while (node?.key != nil) {
            if (node?.key! == key) {
                unlink(node!)
                break
            }
            node = node?.next
        }
    }
    func unlink(element: LLNode<T>) {
        let __prev = element.prev
        let __next = element.next
        if (__prev?.key == nil) {
            if let n = __next {
                head = n
            }
        } else {
            __prev?.next = __next
            element.prev = nil
        }
        if (__next?.key == nil) {
            tail = __prev!
        } else {
            __next?.prev = __prev
            element.next = nil
        }
        element.key = nil
    }

    func print() {
        var current: LLNode? = head
        var str: String = String()
        while (current != nil) {
            if let key = current?.key {
                println(key)
            }
            current = current?.next
        }
    }
}

var list = LinkedList<String>()
list.appendKey("a")
list.appendKey("b")
list.appendKey("c")
list.print()
list.removeKey("a")
list.print()
list.removeKey("c")
list.print()

参考

下記の記事を読んでて、「バグってね？」「やりかたおかしくね？」と思って自分でも書いてみました。
http://waynewbishop.com/swift/linked-lists/

オプショナルの使い方が正しいのかどうかいまいちピンと来ない場面がある。