Swift 3 和自定义链表集合类型的 Index

自定义链表是一种常见的数据结构，用于存储和管理数据集合。在 Swift 3 中，我们可以使用自定义链表集合类型的 Index 来操作和访问链表中的元素。本文将介绍如何使用 Swift 3 和自定义链表集合类型的 Index 来创建和操作链表，并提供案例代码作为示例。

swift
class ListNode {
    var value: T
    var next: ListNode?
    
    init(value: T, next: ListNode? = nil) {
        self.value = value
        self.next = next
    }
}

swift
struct LinkedListIndex: Comparable {
    fileprivate let node: ListNode?
    
    fileprivate init(node: ListNode?) {
        self.node = node
    }
    
    static func ==(lhs: LinkedListIndex, rhs: LinkedListIndex) -> Bool {
        switch (lhs.node, rhs.node) {
        case (nil, nil):
            return true
        case (let left?, let right?):
            return left === right
        default:
            return false
        }
    }
    
    static func <(lhs: LinkedListIndex, rhs: LinkedListIndex) -> Bool {
        guard lhs != rhs else {
            return false
        }
        
        var currentNode = lhs.node
        while let node = currentNode {
            if node === rhs.node {
                return true
            }
            currentNode = node.next
        }
        
        return false
    }
}

swift
class LinkedList {
    private var head: ListNode?
    private var tail: ListNode?
    
    var isEmpty: Bool {
        return head == nil
    }
    
    var count: Int {
        var currentNode = head
        var count = 0
        
        while let node = currentNode {
            count += 1
            currentNode = node.next
        }
        
        return count
    }
    
    var startIndex: LinkedListIndex {
        return LinkedListIndex(node: head)
    }
    
    var endIndex: LinkedListIndex {
        return LinkedListIndex(node: nil)
    }
    
    func append(_ value: T) {
        let newNode = ListNode(value: value)
        
        if isEmpty {
            head = newNode
            tail = newNode
        } else {
            tail?.next = newNode
            tail = newNode
        }
    }
    
    func insert(_ value: T, at index: LinkedListIndex) {
        let newNode = ListNode(value: value)
        
        if index == startIndex {
            newNode.next = head
            head = newNode
        } else {
            var currentNode = head
            
            while let node = currentNode {
                if node.next === index.node {
                    newNode.next = node.next
                    node.next = newNode
                    break
                }
                currentNode = node.next
            }
        }
    }
    
    func remove(at index: LinkedListIndex) {
        if index == startIndex {
            head = head?.next
        } else {
            var currentNode = head
            
            while let node = currentNode {
                if node.next === index.node {
                    node.next = node.next?.next
                    break
                }
                currentNode = node.next
            }
        }
    }
    
    subscript(index: LinkedListIndex) -> T {
        get {
            return index.node!.value
        }
        set {
            index.node!.value = newValue
        }
    }
}
// 创建一个整数链表
let list = LinkedList()
// 添加元素
list.append(1)
list.append(2)
list.append(3)
// 在指定位置插入元素
let index = list.startIndex
list.insert(4, at: index)
// 移除指定位置的元素
list.remove(at: index)
// 访问指定位置的元素
let value = list[index]
print(list.count) // 输出：3
print(value) // 输出：2