Swift: 二进制搜索标准数组？

Question

我有一个排序数组，想对其进行二分查找。

所以我想问一下 Swift 库中是否已经有一些东西可以使用，比如 sort 等等？或者是否有可用的类型独立版本？

当然可以自己写，但我喜欢避免重复造轮子

Answer 1

这是使用二进制搜索的通用方法：

func binarySearch<T:Comparable>(_ inputArr:Array<T>, _ searchItem: T) -> Int? {
    var lowerIndex = 0
    var upperIndex = inputArr.count - 1

    while (true) {
        let currentIndex = (lowerIndex + upperIndex)/2
        if(inputArr[currentIndex] == searchItem) {
            return currentIndex
        } else if (lowerIndex > upperIndex) {
            return nil
        } else {
            if (inputArr[currentIndex] > searchItem) {
                upperIndex = currentIndex - 1
            } else {
                lowerIndex = currentIndex + 1
            }
        }
    }
}

var myArray = [1,2,3,4,5,6,7,9,10]
if let searchIndex = binarySearch(myArray, 5) {
    print("Element found on index: \(searchIndex)")
}

Answer 2

这是我最喜欢的二分搜索实现。它不仅对查找元素很有用，而且对查找插入索引也很有用。通过提供相应的谓词（例如 { [=12=] < x } vs { [=13=] > x } vs { [=14=] <= x } vs { [=15=] >= x }）来控制关于假定排序顺序（升序或降序）和关于相等元素的行为的详细信息.该评论明确说明了它的具体作用。

extension RandomAccessCollection {
    /// Finds such index N that predicate is true for all elements up to
    /// but not including the index N, and is false for all elements
    /// starting with index N.
    /// Behavior is undefined if there is no such N.
    func binarySearch(predicate: (Element) -> Bool) -> Index {
        var low = startIndex
        var high = endIndex
        while low != high {
            let mid = index(low, offsetBy: distance(from: low, to: high)/2)
            if predicate(self[mid]) {
                low = index(after: mid)
            } else {
                high = mid
            }
        }
        return low
    }
}

用法示例：

(0 ..< 778).binarySearch { [=11=] < 145 } // 145

Answer 3

这里有一个更好的实现方式，returns 多于一个索引，如果数组中的索引多于 1 个。

extension Array where Element: Comparable {

/* Array Must be sorted */

func binarySearch(key: Element) -> [Index]? {
    return self.binarySearch(key, initialIndex: 0)
}

private func binarySearch(key: Element, initialIndex: Index) -> [Index]? {

    guard count > 0 else { return nil }

    let midIndex = count / 2
    let midElement = self[midIndex]

    if key == midElement {

        // Found!

        let foundIndex = initialIndex + midIndex

        var indexes = [foundIndex]

        // Check neighbors for same values

        // Check Left Side

        var leftIndex = midIndex - 1

        while leftIndex >= 0 {

            //While there is still more items on the left to check

            print(leftIndex)

            if self[leftIndex] == key {

                //If the items on the left is still matching key

                indexes.append(leftIndex + initialIndex)
                leftIndex--

            } else {

                // The item on the left is not identical to key

                break
            }
        }

        // Check Right side

        var rightIndex = midIndex + 1

        while rightIndex < count {

            //While there is still more items on the left to check

            if self[rightIndex] == key {

                //If the items on the left is still matching key

                indexes.append(rightIndex + initialIndex)
                rightIndex++

            } else {

                // The item on the left is not identical to key

                break
            }
        }

        return indexes.sort{ return [=10=] <  }
    }

    if count == 1 {

        guard let first = first else { return nil }

        if first == key {
            return [initialIndex]
        }
        return nil
    }


    if key < midElement {

        return Array(self[0..<midIndex]).binarySearch(key, initialIndex: initialIndex + 0)
    }

    if key > midElement {

        return Array(self[midIndex..<count]).binarySearch(key, initialIndex: initialIndex + midIndex)
    }

    return nil
}

}

Answer 4

我在 Indexable 上使用 extension 实现 indexOfFirstObjectPassingTest。

它需要一个 test 谓词，并且 returns 第一个元素 的索引 才能通过测试。
如果没有这样的索引，那么就returnsendIndex的Indexable。
如果 Indexable 为空，则得到 endIndex。

例子

let a = [1,2,3,4]

a.map{[=10=]>=3}
// returns [false, false, true, true]

a.indexOfFirstObjectPassingTest {[=10=]>=3}
// returns 2

重要

您需要确保 test 永远不会 returns in false 对于索引之后的任何索引，它已经说 true 了。这相当于通常的前提条件，即二进制搜索要求您的数据是有序的。

具体来说，你不能 a.indexOfFirstObjectPassingTest {[=26=]==3}。这将无法正常工作。

为什么？

indexOfFirstObjectPassingTest 很有用，因为它可以让您 查找数据中内容的范围 。通过调整测试，可以找到"stuff".

的下限和上限

这是一些数据：

let a = [1,1,1, 2,2,2,2, 3, 4, 5]

我们可以像这样找到所有 2 中的 Range…

let firstOf2s = a.indexOfFirstObjectPassingTest({[=12=]>=2})
let endOf2s = a.indexOfFirstObjectPassingTest({[=12=]>2})
let rangeOf2s = firstOf2s..<endOf2s

如果数据中没有 2，我们将返回 一个空范围 ，我们不需要任何特殊处理。
只要有 2 个，我们就会全部找到。

例如，我在 layoutAttributesForElementsInRect 的实现中使用了它。我的 UICollectionViewCells 存储在一个数组中垂直排序。很容易编写一对调用来查找特定矩形内的所有单元格并排除任何其他单元格。

代码

extension Indexable {
  func indexOfFirstObjectPassingTest( test: (Self._Element -> Bool) ) -> Self.Index {
    var searchRange = startIndex..<endIndex

    while searchRange.count > 0 {
      let testIndex: Index = searchRange.startIndex.advancedBy((searchRange.count-1) / 2)
      let passesTest: Bool = test(self[testIndex])

      if(searchRange.count == 1) {
        return passesTest ? searchRange.startIndex : endIndex
      }

      if(passesTest) {
        searchRange.endIndex = testIndex.advancedBy(1)
      }
      else {
        searchRange.startIndex = testIndex.advancedBy(1)
      }
    }

    return endIndex
  }
}

免责声明和注意事项

我有大约 6 年的 iOS 经验，10 年的 Objective C，以及 >18 年的编程经验……

…但我在 Swift 的第 3 天:-)

我使用了 Indexable 协议的扩展。这可能是一种愚蠢的方法——欢迎提供反馈。
Binary searches are notoriously hard 才能正确编码。您确实应该阅读 link 以了解其实施中的常见错误，但这里是摘录：

When Jon Bentley assigned it as a problem in a course for professional programmers, he found that an astounding ninety percent failed to code a binary search correctly after several hours of working on it, and another study shows that accurate code for it is only found in five out of twenty textbooks. Furthermore, Bentley's own implementation of binary search, published in his 1986 book Programming Pearls, contains an error that remained undetected for over twenty years.

鉴于最后一点，这里是对这段代码的测试。他们通过了。它们不太可能是详尽无遗的——因此肯定仍然存在错误。不能保证测试实际上是正确的！没有测试的测试。

测试

class BinarySearchTest: XCTestCase {

  func testCantFind() {
    XCTAssertEqual([].indexOfFirstObjectPassingTest {(_: Int) -> Bool in false}, 0)
    XCTAssertEqual([1].indexOfFirstObjectPassingTest {(_: Int) -> Bool in false}, 1)
    XCTAssertEqual([1,2].indexOfFirstObjectPassingTest {(_: Int) -> Bool in false}, 2)
    XCTAssertEqual([1,2,3].indexOfFirstObjectPassingTest {(_: Int) -> Bool in false}, 3)
    XCTAssertEqual([1,2,3,4].indexOfFirstObjectPassingTest {(_: Int) -> Bool in false}, 4)
  }

  func testAlwaysFirst() {
    XCTAssertEqual([].indexOfFirstObjectPassingTest {(_: Int) -> Bool in true}, 0)
    XCTAssertEqual([1].indexOfFirstObjectPassingTest {(_: Int) -> Bool in true}, 0)
    XCTAssertEqual([1,2].indexOfFirstObjectPassingTest {(_: Int) -> Bool in true}, 0)
    XCTAssertEqual([1,2,3].indexOfFirstObjectPassingTest {(_: Int) -> Bool in true}, 0)
    XCTAssertEqual([1,2,3,4].indexOfFirstObjectPassingTest {(_: Int) -> Bool in true}, 0)
  }

  func testFirstMatch() {
    XCTAssertEqual([1].indexOfFirstObjectPassingTest {1<=[=14=]}, 0)
    XCTAssertEqual([0,1].indexOfFirstObjectPassingTest {1<=[=14=]}, 1)
    XCTAssertEqual([1,2].indexOfFirstObjectPassingTest {1<=[=14=]}, 0)
    XCTAssertEqual([0,1,2].indexOfFirstObjectPassingTest {1<=[=14=]}, 1)
  }

  func testLots() {
    let a = Array(0..<1000)
    for i in a.indices {
      XCTAssertEqual(a.indexOfFirstObjectPassingTest({Int(i)<=[=14=]}), i)
    }
  }
}

Answer 5

这里是 Swift 3.1 的几个测试用例的完整示例。这不可能比默认实现更快，但这不是重点。数组扩展在底部：

//  BinarySearchTests.swift
//  Created by Dan Rosenstark on 3/27/17
import XCTest
@testable import SwiftAlgos

class BinarySearchTests: XCTestCase {

    let sortedArray : [Int] = [-25, 1, 2, 4, 6, 8, 10, 14, 15, 1000]

    func test5() {
        let traditional = sortedArray.index(of: 5)
        let newImplementation = sortedArray.indexUsingBinarySearch(of: 5)
        XCTAssertEqual(traditional, newImplementation)
    }

    func testMembers() {
        for item in sortedArray {
            let traditional = sortedArray.index(of: item)
            let newImplementation = sortedArray.indexUsingBinarySearch(of: item)
            XCTAssertEqual(traditional, newImplementation)
        }
    }

    func testMembersAndNonMembers() {
        for item in (-100...100) {
            let traditional = sortedArray.index(of: item)
            let newImplementation = sortedArray.indexUsingBinarySearch(of: item)
            XCTAssertEqual(traditional, newImplementation)
        }
    }

    func testSingleMember() {
        let sortedArray = [50]
        for item in (0...100) {
            let traditional = sortedArray.index(of: item)
            let newImplementation = sortedArray.indexUsingBinarySearch(of: item)
            XCTAssertEqual(traditional, newImplementation)
        }
    }

    func testEmptyArray() {
        let sortedArray : [Int] = []
        for item in (0...100) {
            let traditional = sortedArray.index(of: item)
            let newImplementation = sortedArray.indexUsingBinarySearch(of: item)
            XCTAssertEqual(traditional, newImplementation)
        }
    }
}

extension Array where Element : Comparable {
    // self must be a sorted Array
    func indexUsingBinarySearch(of element: Element) -> Int? {
        guard self.count > 0 else { return nil }
        return binarySearch(for: element, minIndex: 0, maxIndex: self.count - 1)
    }

    private func binarySearch(for element: Element, minIndex: Int, maxIndex: Int) -> Int? {
        let count = maxIndex - minIndex + 1
        // if there are one or two elements, there is no futher recursion:
        // stop and check one or both values (and return nil if neither)
        if count == 1 {
            return element == self[minIndex] ? minIndex : nil
        } else if count == 2 {
            switch element {
                case self[minIndex]: return minIndex
                case self[maxIndex]: return maxIndex
                default: return nil
            }
        }

        let breakPointIndex = Int(round(Double(maxIndex - minIndex) / 2.0)) + minIndex
        let breakPoint = self[breakPointIndex]

        let splitUp = (breakPoint < element)
        let newMaxIndex : Int = splitUp ? maxIndex : breakPointIndex
        let newMinIndex : Int = splitUp ? breakPointIndex : minIndex

        return binarySearch(for: element, minIndex: newMinIndex, maxIndex: newMaxIndex)
    }
}

这是自制的，所以...买者自负。它确实有效并且确实进行了二进制搜索。

Answer 6

这是一个排序的字符串数组的实现。

var arr = ["a", "abc", "aabc", "aabbc", "aaabbbcc", "bacc", "bbcc", "bbbccc", "cb", "cbb", "cbbc", "d" , "defff", "deffz"]

func binarySearch(_ array: [String], value: String) -> String {

    var firstIndex = 0
    var lastIndex = array.count - 1
    var wordToFind = "Not founded"
    var count = 0

    while firstIndex <= lastIndex {

        count += 1
        let middleIndex = (firstIndex + lastIndex) / 2
        let middleValue = array[middleIndex]

        if middleValue == value {
            wordToFind = middleValue
            return wordToFind
        }
        if value.localizedCompare(middleValue) == ComparisonResult.orderedDescending {
            firstIndex = middleIndex + 1
        }
        if value.localizedCompare(middleValue) == ComparisonResult.orderedAscending {
            print(middleValue)
            lastIndex = middleIndex - 1
        }
    }
    return wordToFind
}
//print d
print(binarySearch(arr, value: "d"))

Answer 7

这里是使用 while 语法的二进制搜索

func binarySearch<T: Comparable>(_ a: [T], key: T) -> Int? {
    var lowerBound = 0
    var upperBound = a.count
    while lowerBound < upperBound {
        let midIndex = lowerBound + (upperBound - lowerBound) / 2
        if a[midIndex] == key {
            return midIndex
        } else if a[midIndex] < key {
            lowerBound = midIndex + 1
        } else {
            upperBound = midIndex
        }
    }
    return nil
}

Answer 8

extension ArraySlice where Element: Comparable {
    func binarySearch(_ value: Element) -> Int? {
        guard !isEmpty else { return nil }

        let midIndex = (startIndex + endIndex) / 2
        if value == self[midIndex] {
            return midIndex
        } else if value > self[midIndex] {
            return self[(midIndex + 1)...].binarySearch(value)
        } else {
            return self[..<midIndex].binarySearch(value)
        }
    }
}

extension Array where Element: Comparable {
    func binarySearch(_ value: Element) -> Int? {
        return self[0...].binarySearch(value)
    }
}

在我看来，这是非常可读的，并且利用了这样一个事实，即 Swift 的 ArraySlice 是 Array 的一个视图，并保留与它共享存储的原始 Array 相同的索引，因此，没有突变（就像在这种情况下），因此非常有效。

Answer 9

通过递归二分查找，

func binarySearch(data : [Int],search: Int,high : Int,low:Int) -> Int? {
    if (low >  high)
    {
        return nil
    }
    let mid = low + (low + high)/2

    if (data[mid] == search) {
        return mid
    }
    else if (search < data[mid]){
        return binarySearch(data: data, search: search, high: high-1, low: low)
    }else {
        return binarySearch(data: data, search: search, high: high, low: low+1)
    }
}

输入：let arry = Array(0...5) // [0,1,2,3,4,5]

print(binarySearch(data: arry, search: 0, high: arry.count-1, low: 0))

Answer 10

Swift 5 中的简单解决方案：

func binarySerach(list: [Int], item: Int) -> Int? {
    var low = 0
    var high = list.count - 1
    while low <= high {
        let mid = (low + high) / 2
        let guess = list[mid]
        if guess == item {
            return mid
        } else if guess > item {
            high = mid - 1
        } else {
            low = mid + 1
        }
    }
    return nil
}

let myList = [1,3,4,7,9]

print(binarySerach(list: myList, item: 9))
//Optional(4)

Answer 11

详情

Swift5.2，Xcode11.4 (11E146)

解决方案

import Foundation

extension RandomAccessCollection where Element: Comparable {

    private func binarySearchIteration(forIndexOf value: Element, in range: Range<Index>? = nil,
                                       valueDetected: ((Index, _ in: Range<Index>) -> Index?)) -> Index? {
        let range = range ?? startIndex..<endIndex

        guard range.lowerBound < range.upperBound else { return nil }

        let size = distance(from: range.lowerBound, to: range.upperBound)
        let middle = index(range.lowerBound, offsetBy: size / 2)

        switch self[middle] {
        case value: return valueDetected(middle, range) ?? middle
        case ..<value: return binarySearch(forIndexOf: value, in: index(after: middle)..<range.upperBound)
        default: return binarySearch(forIndexOf: value, in: range.lowerBound..<middle)
        }
    }

    func binarySearch(forIndexOf value: Element, in range: Range<Index>? = nil) -> Index? {
        binarySearchIteration(forIndexOf: value, in: range) { currentIndex, _ in currentIndex }
    }

    func binarySearch(forFirstIndexOf value: Element, in range: Range<Index>? = nil) -> Index? {
        binarySearchIteration(forIndexOf: value, in: range) { currentIndex, range in
            binarySearch(forFirstIndexOf: value, in: range.lowerBound..<currentIndex)
        }
    }

    func binarySearch(forLastIndexOf value: Element, in range: Range<Index>? = nil) -> Index? {
        binarySearchIteration(forIndexOf: value, in: range) { currentIndex, range in
            binarySearch(forFirstIndexOf: value, in: index(after: currentIndex)..<range.upperBound)
        }
    }

    func binarySearch(forIndicesRangeOf value: Element, in range: Range<Index>? = nil) -> Range<Index>? {
        let range = range ?? startIndex..<endIndex
        guard range.lowerBound < range.upperBound else { return nil }

        guard let currentIndex = binarySearchIteration(forIndexOf: value, in: range, valueDetected: { index, _ in index
        }) else { return nil }

        let firstIndex = binarySearch(forFirstIndexOf: value, in: range.lowerBound ..< index(after: currentIndex)) ?? currentIndex
        let lastIndex = binarySearch(forFirstIndexOf: value, in: index(after: currentIndex) ..< range.upperBound) ?? currentIndex

        return firstIndex..<index(after: lastIndex)
    }
}

用法

//let array = ["one", "two", "three", "three", "three", "three", "three", "four", "five", "five"]
//let value = "three"
let array = [1, 2, 3, 3, 3, 3, 3, 4, 5, 5]
let value = 3
print(array.binarySearch(forFirstIndexOf: value))
print(array.binarySearch(forLastIndexOf: value))
print(array.binarySearch(forIndicesRangeOf: value))

测试

protocol _BinarySearchTestable: class where Collection: RandomAccessCollection, Collection.Element: Comparable {
    associatedtype Collection
    var array: Collection! { get set }
    var elementToSearch: Collection.Element! { get set }
    func testFindFirstIndexOfValueInCollection()
    func testFindLastIndexOfValueInCollection()
    func testFindIndicesRangeOfValueInCollection()
}

extension _BinarySearchTestable where Self: XCTest {

    typealias Element = Collection.Element
    typealias Index = Collection.Index

    func _testFindFirstIndexOfValueInCollection() {
        _testfindFirstIndex(comparableArray: array, testableArray: array)
    }

    func _testFindLastIndexOfValueInCollection() {
        let index1 = array.lastIndex(of: elementToSearch)
        let index2 = array.binarySearch(forLastIndexOf: elementToSearch)
        _testElementsAreEqual(indexInComparableArray: index1, comparableArray: array,
                              indexInTestableArray: index2, testableArray: array)
    }

    func _testFindIndicesRangeOfValueInCollection() {
        var range1: Range<Index>?
        if  let firstIndex = array.firstIndex(of: elementToSearch),
            let lastIndex = array.lastIndex(of: elementToSearch) {
                range1 = firstIndex ..< array.index(after: lastIndex)
        }
        let range2 = array.binarySearch(forIndicesRangeOf: elementToSearch)
        XCTAssertEqual(range1, range2)
    }

    private func _testElementsAreEqual(indexInComparableArray: Index?, comparableArray: Collection,
                                       indexInTestableArray: Index?, testableArray: Collection) {
        XCTAssertEqual(indexInComparableArray, indexInTestableArray)
        var valueInComparableArray: Element?
        if let index = indexInComparableArray { valueInComparableArray = comparableArray[index] }

        var valueInTestableArray: Element?
        if let index = indexInComparableArray { valueInTestableArray = testableArray[index] }
        XCTAssertEqual(valueInComparableArray, valueInTestableArray)
    }

    private func _testfindFirstIndex(comparableArray: Collection, testableArray: Collection) {
        let index1 = comparableArray.firstIndex(of: elementToSearch)
        let index2 = testableArray.binarySearch(forFirstIndexOf: elementToSearch)
        _testElementsAreEqual(indexInComparableArray: index1, comparableArray: comparableArray,
                              indexInTestableArray: index2, testableArray: testableArray)
    }
}

class TestsInEmptyArray: XCTestCase, _BinarySearchTestable {

    var array: [String]!
    var elementToSearch: String!

    override func setUp() {
        array = []
        elementToSearch = "value"
    }

    func testFindFirstIndexOfValueInCollection() { _testFindFirstIndexOfValueInCollection() }
    func testFindLastIndexOfValueInCollection() { _testFindLastIndexOfValueInCollection() }
    func testFindIndicesRangeOfValueInCollection() { _testFindIndicesRangeOfValueInCollection() }
}

class TestsInArray: XCTestCase, _BinarySearchTestable {

    var array: [Int]!
    var elementToSearch: Int!

    override func setUp() {
        array = [1, 2, 3, 3, 3, 3, 3, 4, 5, 5]
        elementToSearch = 3
    }

    func testFindFirstIndexOfValueInCollection() { _testFindFirstIndexOfValueInCollection() }
    func testFindLastIndexOfValueInCollection() { _testFindLastIndexOfValueInCollection() }
    func testFindIndicesRangeOfValueInCollection() { _testFindIndicesRangeOfValueInCollection() }
}

class TestsInArrayWithOneElement: XCTestCase, _BinarySearchTestable {

    var array: [Date]!
    var elementToSearch: Date!

    override func setUp() {
        let date = Date()
        array = [date]
        elementToSearch = date
    }

    func testFindFirstIndexOfValueInCollection() { _testFindFirstIndexOfValueInCollection() }
    func testFindLastIndexOfValueInCollection() { _testFindLastIndexOfValueInCollection() }
    func testFindIndicesRangeOfValueInCollection() { _testFindIndicesRangeOfValueInCollection() }
}

Answer 12

另一种实现方式：如果您想让您的结构或类可搜索而不使它们 Comparable，请将它们设为 BinarySearchable：

public protocol BinarySearchable {
    associatedtype C: Comparable
    var searchable: C { get }
}


public extension Array where Element: BinarySearchable {

    func binarySearch(_ prefix: Element.C) -> Index {
        var low = 0
        var high = count
        while low != high {
            let mid = (low + high) / 2
            if self[mid].searchable < prefix {
                low = mid + 1
            } else {
                high = mid
            }
        }
        return low
    }
}

应按 name 排序和搜索的结构的示例用法：

struct Country: BinraySearchable {
    var code: String
    var name: String

    var searchable: String { name }
}

// Suppose you have a list of countries sorted by `name`, you want to find
// the index of the first country whose name starts with "United", others
// will follow:

let index = listOfCountries.binarySearch("United")

Answer 13

为了完整起见，这里有一个完全基于模式匹配的实现：

extension Collection where Element: Comparable {
    func binarySearch(for element: Element) -> Index? {
        switch index(startIndex, offsetBy: distance(from: startIndex, to: endIndex) / 2) {
        case let i where i >= endIndex: return nil
        case let i where self[i] == element: return i
        case let i where self[i] > element: return self[..<i].binarySearch(for: element)
        case let i: return self[index(after: i)..<endIndex].binarySearch(for: element)
        }
    }
}

以上代码应该适用于任何类型的集合，切片或未切片，零偏移或非零偏移。

Answer 14

下面是如何在 swift 中创建二分查找功能 5，在这个例子中，我假设您要查找的项目保证在列表中，但是如果您的项目不保证在列表中在列表中然后您可以运行此代码首先检查：

yourList.contains(yourItem) //will return true or false

这里是二分查找函数：

override func viewDidLoad() {
    super.viewDidLoad()
    
    print(binarySearch(list: [1, 2, 4, 5, 6], num: 6)) //returns 4
}

func binarySearch(list: [Int], num: Int) -> Int //returns index of num
{
    var firstIndex = 0
    var lastIndex = list.count - 1
    
    var middleIndex = (firstIndex + lastIndex) / 2
    var middleValue = list[middleIndex]
    
    while true //loop until we find the item we are looking for
    {
        middleIndex = (firstIndex + lastIndex) / 2 //getting the list's middle index
        middleValue = list[middleIndex]
        
        if middleValue > num
        {
            lastIndex = middleIndex - 1 //get the left side of the remaining list
        }
        else if middleValue < num
        {
            firstIndex = middleIndex + 1 //get the right side of the remaining list
        }
        else if middleValue == num
        { 
            break //found the correct value so we can break out of the loop
        }
    }
    return middleIndex
}

我制作了一个 youtube 视频来解释这个 here

Swift: 二进制搜索标准数组？

Swift: Binary search for standard array?

arrays

types

binary-search

swift

例子

重要

为什么？

代码

免责声明和注意事项

测试

详情

解决方案

用法

测试