通过 LeetCode 最简单的一道题探究 Swift 源码

转自我的 blog: 通过 LeetCode 最简单的一道题探究 Swift 源码

今天下午闲来无事，突然想到一直都没有完成的刷爆 LeetCode 的成就，于是就又跃跃欲试了。
之前通过 Java 和 Python 刷过十几道题，然后就不了了之了。现在 LeetCode 也支持 Swift 了，所以就想用 Swift 解锁成就。
我是个算法渣，在这方面从来没有过自信，「算法导论」中那些面试经常提到的算法看了三四遍也始终无法牢牢把握，前几天又入手了据说更适合实际应用的「算法」，心想一定要偿还这部分的技术负债。

打开 LeetCode 网站，直接按难易度排序，先从最简单的开始。

leetcode.png

第一道题，Reverse String，反转字符串。没什么特别复杂的，就是纯逐个字符反转，并不是反转单词。
第一想法非常简单，就是创建一个空字符串，遍历给定的字符串，挨个字符插入到新字符串的第一位置，这样遍历结束后新的字符串就是反转后的结果，so easy！
打开 Playground，分分钟就写好了下面的代码：

class Solution {
    func reverseString(s: String) -> String {
        var ret: String = ""
        for c in s.characters {
            ret.insert(c, atIndex: ret.startIndex)
        }
        return ret
    }
}

复制到 LeetCode 中，先是猛击 Run Code，没毛病，然后就猛击 Submit Solution 了。果不其然，Time Limit Exceeded……败在了一个无比长的字符串手里。

于是就顺其自然地想到了第二个解决方案：交换字符位置。Swift 的 String，所有的字符都是放在 characters 这个属性里的（看命名是个集合，其实真正的类型是 String.CharacterView，这个类封装了对于字符集合的各种操作），所以操作这个 characters 的索引，应该就可以达到交换字符的目的。正当我准备动手的时候，Xcode 的自动补全蹦出个 reverse() 方法，原来 Swift 已经提供了反转功能，这下子可方便多了，一句代码的事，这个 solution 也通过了：

func reverseString(s: String) -> String {
    return String(s.characters.reverse())
}

这里值得一提的是：在 Dash 的文档里，这个 reverse() 是 Swift 3 之前的 API，返回的是一个 [Character]，复杂度是 O(N)。到了 Swift 3，这个方法改为了 reversed()，复杂度也变成了 O(1)，返回的是 ReversedCollection。对于这两种返回值，String 都可以直接作为参数来初始化。

不知道为什么，在 Xcode 7.3.1 中这个 reverse() 自动补全会有两个:

reverse_autocomplete.png

但 option+click 显示的是：

reverse_xcode.png

返回 ReversedCollection 应该是 Swift 3 才有的，但是 cmd+click 进去发现这个方法声明在 CollectionType 的一个 extension 中，在2.2的源代码中也发现了：

reverse_source.png

从这段代码里也可以看出这个方法的复杂度是 O(1)，而且在 Swift 3 中也要改名为 reversed()。
~~奇怪，文档中明明写的是 O(N) 的版本，但是 Playground 却显示的是这个，不知道 Swift 是如何动态选择到这个方法的。这个 ReversedCollection 我看了初始化方法的实现过程，也没有发现有实现反转的代码，也搞不清楚是如何做到 O(1)的。
所以下面的分析都是针对 O(N) 版本的 reverse().~~~

很荣幸得到了喵神的指点，这里引述一下他的评论：

实际上你提交的确实是返回 ReversedCollection 的 O(1) 版本，它也不是 Swift 3 才有的。Swift 在多个方法满足签名的时候，会帮你选择最具体的那个方法，也就是约束最强的方法。这里 String 的 reverse 同时可以匹配到 SequenceType 和 CollectionType 的 Index 满足 BidirectionalIndexType 的两个版本。因为后者相比于前者的约束更多 (也就是说满足后者的话一定是满足前者的)，因此 Swift 将更有机会使用经过优化的代码。String.characters 的索引满足 BidirectionalIndexType 双向索引，所以在 reverse 的时候只需要返回一个交换了 startIndex 和 endIndex 的结构体 (ReversedCollection) 就可以了。

所以可能是文档和实际代码出现了出入，导致我以为我用的是 O(N) 的方法。下面就是针对 O(N) 版的分析。

一句代码就解决了这个问题，成就感不是很大啊，于是我就想看看 Swift 是如何实现这个方法的。通过查文档（Swift 2.2），发现这个 String.CharacterView 采纳（沿用了 The Swift Programming Language 中文版里的翻译）的协议有 RangeReplaceableCollectionType, CollectionType, SequenceType ：

reverse.png

这个方法最后发现是在 SequenceType 这个协议中声明的：

reverse_sequence_type.png

但是在源码中的 SequenceType.swift 这个文件中并没有找到关于这个方法的任何声明，通过对源码的全局搜索，找到这个方法的实现是写在 SequenceAlgorithms.swift.gyb 这个文件中（关于 gyb 文件是什么，请点击这里)：

//===----------------------------------------------------------------------===//
// reverse()
//===----------------------------------------------------------------------===//

extension SequenceType {
  /// Returns an `Array` containing the elements of `self` in reverse
  /// order.
  ///
  /// Complexity: O(N), where N is the length of `self`.
  @swift3_migration(renamed="reversed")
  @warn_unused_result
  public func reverse() -> [${GElement}] {
    // FIXME(performance): optimize to 1 pass?  But Array(self) can be
    // optimized to a memcpy() sometimes.  Those cases are usually collections,
    // though.
    var result = Array(self)
    let count = result.count
    for i in 0..

这段代码写的很明白了，就是不断向数组的中间靠近，交换首尾的元素。还有值得挖的就是 swap 的实现了，这个方法是在 Sort.swift.gyb 中：

/// Exchange the values of `a` and `b`.
///
/// - Requires: `a` and `b` do not alias each other.
public func swap(inout a : T, inout _ b : T) {
  // Semantically equivalent to (a, b) = (b, a).
  // Microoptimized to avoid retain/release traffic.
  let p1 = Builtin.addressof(&a)
  let p2 = Builtin.addressof(&b)
  _debugPrecondition(
    p1 != p2,
    "swapping a location with itself is not supported")

  // Take from P1.
  let tmp : T = Builtin.take(p1)
  // Transfer P2 into P1.
  Builtin.initialize(Builtin.take(p2) as T, p1)
  // Initialize P2.
  Builtin.initialize(tmp, p2)
}

这段代码也是交换的基本操作了，显示比较两个元素的地址，如果地址相同就不做交换，然后就是通过中间变量来交换两个元素的值。