返回

iOS标准库中不可错过的查找算法与数据结构大盘点！

IOS

一、查找算法

  1. 线性查找

线性查找是最简单的一种查找算法，它通过逐个比较目标元素与数组中的每个元素来查找目标元素。线性查找的优点是实现简单，时间复杂度为O(n)，其中n为数组的长度。但线性查找的缺点也很明显，随着数组长度的增加，查找时间也会变得很长。

func linearSearch<T: Equatable>(_ array: [T], _ target: T) -> Int? {
    for (index, element) in array.enumerated() {
        if element == target {
            return index
        }
    }
    return nil
}
  1. 二分查找

二分查找是一种高效的查找算法，它通过将数组划分为两部分，然后逐层缩小查找范围来查找目标元素。二分查找的优点是时间复杂度为O(log n)，比线性查找快很多。但二分查找的缺点是要求数组必须是有序的。

func binarySearch<T: Comparable>(_ array: [T], _ target: T) -> Int? {
    var low = 0
    var high = array.count - 1

    while low <= high {
        let mid = (low + high) / 2
        let midElement = array[mid]

        if midElement == target {
            return mid
        } else if midElement < target {
            low = mid + 1
        } else {
            high = mid - 1
        }
    }

    return nil
}

二、数据结构

  1. 数组

数组是一种最基本的数据结构，它由一组有序的元素组成。数组的优点是访问元素非常快，时间复杂度为O(1)。但数组的缺点是插入和删除元素的开销很大，时间复杂度为O(n)。

var array = [1, 2, 3, 4, 5]
  1. 链表

链表是一种动态的数据结构，它由一系列节点组成，每个节点包含一个数据项和一个指向下一个节点的指针。链表的优点是插入和删除元素的开销很小，时间复杂度为O(1)。但链表的缺点是访问元素的开销很大，时间复杂度为O(n)。

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

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

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

    func append(_ data: T) {
        let newNode = Node(data: data)

        if let tailNode = tail {
            tailNode.next = newNode
        } else {
            head = newNode
        }

        tail = newNode
    }

    func remove(_ data: T) {
        if head?.data == data {
            head = head?.next
            if head == nil {
                tail = nil
            }
            return
        }

        var previousNode: Node<T>?
        var currentNode = head

        while currentNode != nil {
            if currentNode?.data == data {
                previousNode?.next = currentNode?.next
                if currentNode === tail {
                    tail = previousNode
                }
                break
            }

            previousNode = currentNode
            currentNode = currentNode?.next
        }
    }
}
  1. 字典

字典是一种键值对的数据结构，它可以通过键来快速查找对应的值。字典的优点是查找元素非常快，时间复杂度为O(1)。但字典的缺点是插入和删除元素的开销很大，时间复杂度为O(n)。

var dictionary = ["name": "John", "age": 30, "city": "New York"]

三、结语

iOS标准库中提供了丰富的查找算法和数据结构，可以帮助开发人员快速高效地构建应用程序。在选择查找算法和数据结构时，开发人员需要根据具体的问题和需求来做出权衡。