今天我们来看几个最基本的数据结构：数组，字符串，集合和字典。
数组
数组是最基本的数据结构。Swift编程语言中改变了以前Objective-C时代NSMutableArray和NSArray分开的做法，统一到了Array唯一的数据结构。下面是最基本的一些实现。
|
1 2 3 4 5 6 7 8 9 10 11 |
// 声明一个不可修改的数组 let nums = [1， 2， 3] let nums = [Int]（count: 5， repeatedValue: 0） // 声明一个可以修改的数组 var nums = [3， 1， 2] // 增加一个元素 nums.append（4） // 对原数组进行升序排序 nums.sortInPlace（{$0 < $1}） // 将原数组除了最后一个以外的所有元素赋值给另一个数组 let anotherNums = Array（nums[0 ..< nums.count - 1]） |
不要小看这些简单的操作：数组可以依靠它们实现更多的数据结构。Swift虽然不像Java中有现成的队列和栈，但我们完全可以用数组配合最简单的操作实现这些数据结构，下面就是用数组实现栈的示例代码。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
// 用数组实现栈 class Stack { var stack: [AnyObject] init（） { stack = [AnyObject]（） } func push（object: AnyObject） { stack.append（object） } func pop（） -> AnyObject? { if （!isEmpty（）） { return stack.removeLast（） } else { return nil } } func isEmpty（） -> Bool { return stack.isEmpty } func peek（） -> AnyObject? { return stack.last } } |
集合和字典
这两个数据结构经常使用的原因在于，查找数据的时间复杂度为O（1）。这两个在实战中经常与数组配合使用，请看下面这道题：
给一个整型数组和一个目标值，判断数组中是否有两个数字之和等于目标值
这道题是传说中经典的2Sum，我们已经有一个数组记为nums，也有一个目标值记为target，最后要返回一个Bool值。
最粗暴的方法就是每次选中一个数，然后遍历整个数组，判断是否有另一个数使两者之和为target。这种做法时间复杂度为O（n^2）。
采用集合可以优化时间复杂度。在遍历数组的过程中，用集合每次保存当前值。假如集合中已经有了目标值减去当前值，则证明在之前的遍历中一定有一个数与当前值之和等于目标值。这种做法时间复杂度为O（n），代码如下。
|
1 2 3 4 5 6 7 8 9 10 |
func twoSum（nums: [Int]， _ target: Int） -> Bool { var set = Set<int>（） for num in nums { if set.contains（target - num） { return true } set.insert（num） } return false }</int> |
如果把题目稍微修改下，变为
给定一个整型数组中有且仅有两个数字之和等于目标值，求两个数字在数组中的序号
思路与上题基本类似，但是为了方便拿到序列号，我们采用字典，时间复杂度依然是O（n）。代码如下。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
func twoSum（nums: [Int]， _ target: Int） -> [Int] { var res = [Int]（） var dict = [Int: Int]（） for i in 0 ..< nums.count { guard let lastIndex = dict[target - nums[i]] else { dict[nums[i]] = i continue } res.append（lastIndex） res.append（i） break } return res } |
字符串
字符串在算法实战中极其常见。首先还是列举一下字符串的通常用法。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
// 字符串和数字之间的转换 let str = "3" let num = Int（str） let number = 3 let string = String（num） // 字符串长度 let len = str.characters.count // 访问字符串中的单个字符，时间复杂度为O（n） let char = str[str.startIndex.advancedBy（n）] // 修改字符串 str.removeAtIndex（n） str.append（"c"） str += "hello world" // 检测字符串是否是由数字构成 func isStrNum（str: String） -> Bool { return Int（str） != nil } // 将字符串按字母排序（不考虑大小写） func sortStr（str: String） -> String { var chars = [Character]（str.characters） chars.sortInPlace（{$0 < $1}） return String（chars） } |
下面是本篇的精华所在，我们来一起看一道以前的Google面试题。
Given an input string， reverse the string word by word.
A word is defined as a sequence of non-space characters.
The input string does not contain leading or trailing spaces and the words are always separated by a single space.
For example，
Given s = "the sky is blue"，
return "blue is sky the".
Could you do it in-place without allocating extra space?
这道题目一看好简单，不就是翻转字符串的翻版吗？这种方法有以下两个问题
每个单词长度不一样
空格需要特殊处理
这样一来代码写起来会很繁琐而且容易出错。不如我们先实现一个字符串翻转的方法。
|
1 2 3 4 5 |
private func _swap（inout chars:[Character]， _ p: Int， _ q: Int） { let temp = chars[p] chars[p] = chars[q] chars[q] = temp } |
有了这个方法，我们就可以实行下面两种字符串翻转：
整个字符串翻转，"the sky is blue" -> "eulb si yks eht"
每个单词作为一个字符串单独翻转，"eulb si yks eht" -> "blue is sky the"
整体思路有了，我们就可以解决这道问题了
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
func reverseWords（s: String） -> String { var chars = [Character]（s.characters） _reverse（&chars， 0， chars.count - 1） var start = 0 for i in 0 ..< chars.count { if i == chars.count - 1 || chars[i + 1] == " " { _reverse（&chars， start， i） start = i + 2 } } return String（chars） } private func _reverse（inout chars: [Character]， _ start: Int， _ end: Int） { var start = start var end = end while start < end { _swap（&chars， start， end） start += 1 end -= 1 } } |
时间复杂度还是O（n），整体思路和代码简单很多。
总结
Swift中数组、字符串、集合以及字典是最基本的数据结构，但是围绕这些数据结构的问题层出不穷。幸运的是解决方法也并不是千变万化、高深莫测，大家做好相应的积累即可。下期我们讲链表、栈、队列这三种数据结构。