双向链表在Swift中的简单实现

结点数据结构

class ListNode<T> {
    var value: T
    weak var previous: ListNode?
    var next: ListNode?
    init(value: T) {
        self.value = value
        self.previous = nil
        self.next = nil
    }
}
复制代码

双向链表的数据结构

class LinkList<T> {
    typealias Node = ListNode<T>
    
    var head: Node?
    var first: Node? {
        return head
    }
    var last: Node? {
        guard var node = head else { return nil }
        while let next = node.next {
            node = next
        }
        return node
    }
    
    var isEmpty: Bool {
        return head == nil
    }
    var count: Int {
        guard var node = head else { return 0 }
        var cut = 0
        while let next = node.next {
            node = next
            cut += 1
        }
        return cut
    }
}
复制代码

链表对结点操作的一些方法
查找结点

    func getNode(at index: Int) -> Node? {
        if index == 0 { return head }
        if index > count { return nil }
        var node = head!.next
        for _ in 1..<index {
            node = node?.next
            if node == nil {
                // return nil
                break
            }
        }
        return node
    }
复制代码

增加结点

    func append(_ value: T) {
        let newNode = Node(value: value)
        if let last = last {
            last.next = newNode
            newNode.previous = last
        } else {
            //空链表
            head = newNode
        }
    }
    
    func insertHead(_ value: T) {
        let newNode = Node(value: value)
        if var head = head {
            newNode.next = head
            head.previous = newNode
            head = newNode
        } else {
            head = newNode
        }
    }
    
    func insert(_ value: T ,atIndex index: Int) {
        if index < 0 {
            return
        }
        let newNode = Node(value: value)
        if count == 0 {
            head = newNode
        } else {
            if index == 0 {
                newNode.next = head
                head?.previous = newNode
                head = newNode
            } else {
                if index > count {
                    return
                }
                
                let nodeP = getNode(at: index - 1)
                let nodeN = nodeP?.next
                
                nodeP?.next = newNode
                newNode.previous = nodeP
                
                nodeN?.previous = newNode
                newNode.next = nodeN
                
            }
        }
    }
复制代码

删除结点

    func removeAll() {
        head = nil
    }
    
    func removeLast() -> T? {
        if isEmpty { return nil }
         return removeNode(atIndex: count)
    }
    
    func removeNode(node: Node) -> T? {
        guard head != nil else {
            return nil
        }
        
        let prev = node.previous
        let next = node.next
        
        //当某结点 prev 为空时，即为 head 结点
        if let prev = prev {
            prev.next = next
        } else {
            head = next
        }
        next?.previous = prev // 此时 prev 仍旧为optional值，
        
        //清空node信息
        node.previous = nil
        node.next = nil
        return node.value
    }
    
    func removeNode(atIndex index: Int) -> T? {
        if head == nil {
            return nil
        }
        
        let node = getNode(at: index)
        let prev = node?.previous
        let next = node?.next
        //当某结点 prev 为空时，即为 head 结点
        if let prev = prev {
            prev.next = next
        } else {
            head = next
        }
        next?.previous = prev
        
        //清空node信息
        node?.previous = nil
        node?.next = nil
        return node?.value
    }
复制代码

• 学习了 J_Knight_ 文章之后，敲一敲代码加深印象。