摘要

这道题其实挺有意思的，它让我们设计一个电话目录管理系统。听起来像是实际业务场景中的问题，但实际上是一道经典的数据结构设计题。我们需要实现三个操作：分配号码、检查号码是否可用、释放号码。这三个操作都需要高效地执行，所以选择合适的数据结构很重要。

这道题的核心在于如何高效地管理可用号码的集合，既要能快速分配，又要能快速检查状态，还要能快速释放。今天我们就用 Swift 来搞定这道题，顺便聊聊这种设计模式在实际开发中的应用场景。

描述

题目要求是这样的：设计一个电话目录管理系统，这个系统初始化时有maxNumbers个电话号码槽位，从0到maxNumbers - 1。我们需要实现以下三个操作：

1. get()：分配一个还没被使用的号码，返回那个号码。如果没有可用号码了，返回-1。
2. check(number)：检查某个号码是否可用（即没被分配出去）。如果可用返回true，否则返回false。
3. release(number)：将一个已经分配出去的号码释放，使其可以被后续get()再次分配。

示例：

PhoneDirectory directory = PhoneDirectory(3); // 初始化后，可用号码：0, 1, 2 directory.get(); // 返回 0（或其他可用号码） directory.get(); // 返回 1（或其他可用号码） directory.check(2); // 返回 true，因为 2 还没被分配 directory.get(); // 返回 2 directory.check(2); // 返回 false，因为 2 已经被分配了 directory.release(2); // 释放号码 2 directory.check(2); // 返回 true，因为 2 已经被释放，现在可用了

约束：

• 1 <= maxNumbers <= 10^4
• 0 <= number < maxNumbers
• 总调用次数最多接近2 * 10^4

这道题的核心思路是什么呢？我们需要维护一个可用号码的集合，能够快速地进行分配、检查和释放操作。可以用 Set 来存储可用号码，用队列或数组来快速分配号码。这样get()和check()都能达到 O(1) 的时间复杂度。

题解答案

下面是完整的 Swift 解决方案：

classPhoneDirectory{privateletmaxNumbers:Intprivatevaravailable:Set<Int>privatevarqueue:[Int]init(_maxNumbers:Int){self.maxNumbers=maxNumbersself.available=Set(0..<maxNumbers)self.queue=Array(0..<maxNumbers)}/// 分配一个可用号码，如果没有就返回 -1funcget()->Int{guard!queue.isEmptyelse{return-1}letnum=queue.removeLast()available.remove(num)returnnum}/// 检查某号码是否可用funccheck(_number:Int)->Bool{guardnumber>=0&&number<maxNumberselse{returnfalse}returnavailable.contains(number)}/// 释放一个号码，让它可再次被分配funcrelease(_number:Int){guardnumber>=0&&number<maxNumberselse{return}// 只有之前被分配（即当前不可用）的才需要释放if!available.contains(number){available.insert(number)queue.append(number)}}}

题解代码分析

让我们一步步分析这个解决方案：

1. 数据结构的选择

这道题的关键在于选择合适的数据结构来高效地支持三个操作：

privateletmaxNumbers:Intprivatevaravailable:Set<Int>privatevarqueue:[Int]

我们使用了三个数据结构：

• maxNumbers：记录最大号码数，用于边界检查
• available：一个Set<Int>，存储所有当前可用的号码。Set 的查找和插入操作平均时间复杂度都是 O(1)，非常适合快速检查号码是否可用
• queue：一个Array<Int>，维护未分配的号码序列，用于快速分配号码。我们使用数组而不是真正的队列，因为我们可以从尾部移除元素，这样操作是 O(1) 的

2. 初始化方法

init(_maxNumbers:Int){self.maxNumbers=maxNumbersself.available=Set(0..<maxNumbers)self.queue=Array(0..<maxNumbers)}

初始化时，我们需要：

1. 保存maxNumbers用于后续的边界检查
2. 将所有号码0到maxNumbers - 1都加入到available集合中
3. 将所有号码也加入到queue数组中，这样get()操作可以快速分配

时间复杂度是 O(maxNumbers)，因为需要初始化集合和数组。

3. get() 方法：分配号码

funcget()->Int{guard!queue.isEmptyelse{return-1}letnum=queue.removeLast()available.remove(num)returnnum}

get()方法的逻辑是：

1. 检查是否有可用号码：如果queue为空，说明没有可用号码了，返回-1
2. 从队列中取出一个号码：使用removeLast()从数组尾部移除一个元素，这是 O(1) 操作
3. 从可用集合中移除：将这个号码从available集合中移除，标记为已分配
4. 返回号码：返回分配到的号码

时间复杂度是 O(1)（平均情况），因为removeLast()和Set.remove()都是 O(1) 操作。

4. check() 方法：检查号码是否可用

funccheck(_number:Int)->Bool{guardnumber>=0&&number<maxNumberselse{returnfalse}returnavailable.contains(number)}

check()方法的逻辑是：

1. 边界检查：首先检查number是否在合法范围内（0 <= number < maxNumbers）。如果不在范围内，直接返回false
2. 检查是否在可用集合中：使用available.contains(number)检查号码是否在可用集合中。如果在，说明可用，返回true；否则返回false

时间复杂度是 O(1)（平均情况），因为Set.contains()是 O(1) 操作。

5. release() 方法：释放号码

funcrelease(_number:Int){guardnumber>=0&&number<maxNumberselse{return}// 只有之前被分配（即当前不可用）的才需要释放if!available.contains(number){available.insert(number)queue.append(number)}}

release()方法的逻辑是：

1. 边界检查：首先检查number是否在合法范围内。如果不在范围内，直接返回，不做任何操作
2. 检查是否需要释放：检查号码是否当前不在available集合中（即已被分配）。如果已经在集合中（即已经可用），就不需要重复释放，直接返回
3. 释放号码：如果号码已被分配，需要：
   • 将号码加入到available集合中，标记为可用
   • 将号码加入到queue数组的尾部，这样后续get()操作可以再次分配这个号码

时间复杂度是 O(1)（平均情况），因为Set.contains()、Set.insert()和Array.append()都是 O(1) 操作。

6. 为什么使用 Set + Array 的组合？

我们同时使用Set和Array的原因：

• Set 的优势：check()操作需要快速检查号码是否可用，Set 的contains()操作是 O(1)，非常适合这个需求
• Array 的优势：get()操作需要快速分配一个号码，Array 的removeLast()操作是 O(1)，非常适合这个需求
• 两者配合：release()操作需要同时更新两个数据结构，虽然看起来有冗余，但能保证两个操作都是 O(1)

如果只用 Set，get()操作需要遍历 Set 来找到一个可用号码，时间复杂度会变成 O(n)。如果只用 Array，check()操作需要遍历数组来检查号码是否存在，时间复杂度也会变成 O(n)。所以两者结合使用是最优解。

7. 边界情况处理

代码中处理了几个重要的边界情况：

1. get()时没有可用号码：返回-1
2. check()时号码超出范围：返回false
3. release()时号码超出范围：直接返回，不做任何操作
4. release()时重复释放：检查号码是否已经在可用集合中，如果是就不重复释放

这些边界情况的处理确保了代码的健壮性。

示例测试及结果

让我们用几个例子来测试一下这个解决方案：

示例 1：基本操作

letdirectory=PhoneDirectory(3)print("初始化后，可用号码：0, 1, 2")print("---")letnum1=directory.get()print("get() 返回:\(num1)")print("check(\(num1)):\(directory.check(num1))")// falseletnum2=directory.get()print("get() 返回:\(num2)")print("check(\(num2)):\(directory.check(num2))")// falseprint("check(2):\(directory.check(2))")// true（如果 2 还没被分配）letnum3=directory.get()print("get() 返回:\(num3)")print("check(2):\(directory.check(2))")// false（现在 2 已经被分配了）directory.release(2)print("release(2) 后")print("check(2):\(directory.check(2))")// true（2 现在可用了）letnum4=directory.get()print("get() 返回:\(num4)")// 可能是 2

可能的输出：

初始化后，可用号码：0, 1, 2 --- get() 返回: 2 check(2): false get() 返回: 1 check(1): false check(2): false get() 返回: 0 check(2): false release(2) 后 check(2): true get() 返回: 2

注意：由于我们使用removeLast()，号码的分配顺序是从大到小的（2, 1, 0），但这是正常的，因为题目没有要求特定的分配顺序。

示例 2：边界情况测试

letdirectory=PhoneDirectory(3)// 测试边界检查print("check(-1):\(directory.check(-1))")// falseprint("check(3):\(directory.check(3))")// falseprint("check(0):\(directory.check(0))")// true// 分配所有号码letnum1=directory.get()letnum2=directory.get()letnum3=directory.get()print("分配了三个号码:\(num1),\(num2),\(num3)")// 尝试再分配一个letnum4=directory.get()print("get() 返回:\(num4)")// -1// 释放一个号码directory.release(num1)print("release(\(num1))后")print("check(\(num1)):\(directory.check(num1))")// true// 再次分配letnum5=directory.get()print("get() 返回:\(num5)")// 应该是 num1

输出：

check(-1): false check(3): false check(0): true 分配了三个号码: 2, 1, 0 get() 返回: -1 release(2) 后 check(2): true get() 返回: 2

示例 3：重复释放测试

letdirectory=PhoneDirectory(3)letnum=directory.get()print("分配号码:\(num)")directory.release(num)print("第一次 release(\(num))")print("check(\(num)):\(directory.check(num))")// truedirectory.release(num)print("第二次 release(\(num))（重复释放）")print("check(\(num)):\(directory.check(num))")// 仍然是 true，不会出错

输出：

分配号码: 2 第一次 release(2) check(2): true 第二次 release(2)（重复释放） check(2): true

重复释放不会导致错误，因为我们的代码会检查号码是否已经在可用集合中。

示例 4：大量操作测试

letdirectory=PhoneDirectory(1000)// 分配 500 个号码varallocated:[Int]=[]for_in0..<500{letnum=directory.get()allocated.append(num)}print("分配了 500 个号码")print("check(0):\(directory.check(0))")// false（如果 0 被分配了）// 释放前 100 个foriin0..<100{directory.release(allocated[i])}print("释放了 100 个号码")print("check(\(allocated[0])):\(directory.check(allocated[0]))")// true// 再分配 100 个for_in0..<100{letnum=directory.get()print("重新分配号码:\(num)")}

这个测试展示了系统在处理大量操作时的正确性。

时间复杂度

让我们分析一下每个操作的时间复杂度：

总体时间复杂度：

• 初始化：O(maxNumbers)
• 每次操作：O(1) 平均时间复杂度

对于题目约束（maxNumbers <= 10^4，总调用次数接近2 * 10^4），这个时间复杂度是完全可接受的。

空间复杂度

空间复杂度分析：

• maxNumbers：一个整数，O(1)
• available：一个 Set，最多存储maxNumbers个整数，O(maxNumbers)
• queue：一个 Array，最多存储maxNumbers个整数，O(maxNumbers)

总空间复杂度：O(maxNumbers)

虽然我们使用了两个数据结构（Set 和 Array），但它们存储的是相同的数据（可用号码），所以空间复杂度仍然是 O(maxNumbers)，这是必要的，因为我们需要同时支持 O(1) 的查找和分配操作。

实际应用场景

这种电话目录管理系统的设计模式在实际开发中应用非常广泛：

场景一：资源池管理

在很多系统中，我们需要管理资源池，比如：

• 数据库连接池：分配和释放数据库连接
• 线程池：分配和释放线程
• 对象池：分配和释放对象

这些场景都需要类似的操作：分配资源、检查资源是否可用、释放资源。

// 伪代码示例：数据库连接池classConnectionPool{privatevaravailable:Set<Connection>privatevarqueue:[Connection]funcgetConnection()->Connection?{// 类似 get() 操作}funcisAvailable(_connection:Connection)->Bool{// 类似 check() 操作}funcrelease(_connection:Connection){// 类似 release() 操作}}

场景二：ID 分配器

在很多系统中，我们需要分配唯一的 ID，比如：

• 用户 ID 分配：为新用户分配唯一 ID
• 订单号分配：为新订单分配唯一订单号
• 会话 ID 分配：为新会话分配唯一会话 ID

// 伪代码示例：用户 ID 分配器classUserIDAllocator{privatevaravailable:Set<Int>privatevarqueue:[Int]funcallocateUserID()->Int{// 类似 get() 操作}funcisUserIDAvailable(_id:Int)->Bool{// 类似 check() 操作}funcreleaseUserID(_id:Int){// 类似 release() 操作（比如用户注销时）}}

场景三：端口号管理

在网络编程中，我们需要管理端口号：

// 伪代码示例：端口号管理器classPortManager{privatevaravailable:Set<Int>privatevarqueue:[Int]funcallocatePort()->Int?{// 分配一个可用端口}funcisPortAvailable(_port:Int)->Bool{// 检查端口是否可用}funcreleasePort(_port:Int){// 释放端口}}

场景四：会议室预订系统

在会议室预订系统中，我们需要管理会议室的可用性：

// 伪代码示例：会议室管理器classMeetingRoomManager{privatevaravailable:Set<Int>// 可用会议室编号privatevarqueue:[Int]funcbookRoom()->Int?{// 预订一个会议室}funcisRoomAvailable(_roomId:Int)->Bool{// 检查会议室是否可用}funcreleaseRoom(_roomId:Int){// 释放会议室}}

总结

这道题虽然看起来简单，但实际上涉及了很多重要的设计思想：

1. 数据结构的选择：选择合适的数据结构来支持不同的操作。Set 适合快速查找，Array 适合快速分配，两者结合使用能达到最优性能。

2. 时间复杂度优化：通过合理的数据结构选择，让所有操作都达到 O(1) 的平均时间复杂度。

3. 边界情况处理：正确处理边界情况，如号码超出范围、重复释放等，确保代码的健壮性。

4. 实际应用：这种设计模式在实际开发中应用广泛，如资源池管理、ID 分配、端口管理等。

关键点总结：

• 使用Set来快速检查号码是否可用（O(1) 查找）
• 使用Array来快速分配号码（O(1) 移除尾部元素）
• 两者配合使用，保证所有操作都是 O(1) 时间复杂度
• 正确处理边界情况，确保代码健壮性