探索数据结构和算法的奥秘，用Swift代码展现计算之美

2024-01-12 02:53:10

数据结构

数据结构是组织和存储数据的方式。在Swift中，我们可以使用各种内置的数据结构，如数组、字典、集合等。此外，我们还可以定义自己的数据结构，如链表、栈、队列等。

算法

算法是解决问题的步骤。在Swift中，我们可以使用各种内置的算法，如排序算法、搜索算法等。此外，我们还可以定义自己的算法。

链表

链表是一种数据结构，它由一组节点组成，每个节点包含一个值和一个指向下一个节点的指针。链表可以用来存储各种类型的数据，如字符串、数字、对象等。

class Node<T> {
    var value: T
    var next: Node<T>?

    init(value: T, next: Node<T>? = nil) {
        self.value = value
        self.next = next
    }
}

class LinkedList<T> {
    var head: Node<T>?
    var tail: Node<T>?

    func append(_ value: T) {
        let newNode = Node(value: value)
        if let tailNode = tail {
            tailNode.next = newNode
        } else {
            head = newNode
        }
        tail = newNode
    }

    func removeFirst() -> T? {
        guard let headNode = head else {
            return nil
        }
        head = headNode.next
        if head == nil {
            tail = nil
        }
        return headNode.value
    }

    func insert(_ value: T, after node: Node<T>) {
        guard let nextNode = node.next else {
            append(value)
            return
        }
        let newNode = Node(value: value, next: nextNode)
        node.next = newNode
        if node === tail {
            tail = newNode
        }
    }

    func remove(_ node: Node<T>) {
        guard node !== head else {
            removeFirst()
            return
        }
        var prevNode = head
        while prevNode?.next !== node {
            prevNode = prevNode?.next
        }
        prevNode?.next = node.next
        if node === tail {
            tail = prevNode
        }
    }
}

栈

栈是一种数据结构，它遵循先进后出（LIFO）的原则。也就是说，后进栈的元素总是先出栈。栈可以用来实现各种操作，如函数调用、括号匹配等。

class Stack<T> {
    private var elements: [T] = []

    func push(_ element: T) {
        elements.append(element)
    }

    func pop() -> T? {
        return elements.popLast()
    }

    func peek() -> T? {
        return elements.last
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }
}

队列

队列是一种数据结构，它遵循先进先出（FIFO）的原则。也就是说，先入队列的元素总是先出队列。队列可以用来实现各种操作，如消息队列、任务队列等。

class Queue<T> {
    private var elements: [T] = []

    func enqueue(_ element: T) {
        elements.append(element)
    }

    func dequeue() -> T? {
        return elements.removeFirst()
    }

    func peek() -> T? {
        return elements.first
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }
}