高效电话目录管理系统设计与实现

1. 电话目录管理系统设计概述

这道LeetCode 379题要求我们设计一个电话目录管理系统，核心功能是高效管理一组号码资源。系统需要支持三个基本操作：分配号码、检查号码可用性和释放号码。这类问题在实际工程中非常常见，比如数据库连接池管理、线程池资源分配等场景。

作为面试题，它考察的是我们对数据结构的理解与选择能力。我们需要在保证功能正确的前提下，尽可能优化操作的时间复杂度。题目给出的约束条件（maxNumbers ≤ 10^4，总操作次数约2×10^4）意味着我们需要设计出O(1)时间复杂度的解决方案。

2. 数据结构选择与设计思路

2.1 核心数据结构对比分析

要实现高效的号码管理，我们需要考虑以下几种数据结构的特性：

• 数组(Array)：

  • 优点：随机访问O(1)，尾部操作O(1)
  • 缺点：查找特定元素需要O(n)，删除非尾部元素需要O(n)

• 集合(Set)：

  • 优点：查找、插入、删除平均O(1)
  • 缺点：无法保证顺序，无法快速获取任意元素

• 队列(Queue)：

  • 优点：先进先出，入队出队O(1)
  • 缺点：无法随机访问中间元素

• 链表(Linked List)：

  • 优点：插入删除O(1)
  • 缺点：查找需要O(n)，空间开销较大

2.2 最优组合方案

经过分析，我们采用Set + Array的组合方案：

swift复制class PhoneDirectory {
    private let maxNumbers: Int
    private var available: Set<Int>
    private var queue: [Int]
    // 其余实现...
}

这种设计的精妙之处在于：

• available Set负责快速查找（O(1)）
• queue Array负责快速分配（O(1) removeLast）
• 两者配合实现所有操作O(1)时间复杂度

3. 详细实现解析

3.1 初始化方法

swift复制init(_ maxNumbers: Int) {
    self.maxNumbers = maxNumbers
    self.available = Set(0..<maxNumbers)
    self.queue = Array(0..<maxNumbers)
}

初始化时我们需要：

1. 存储maxNumbers用于边界检查
2. 创建包含0到maxNumbers-1的Set
3. 创建相同范围的Array

时间复杂度：O(n)，因为需要初始化n个元素

3.2 号码分配(get)实现

swift复制func get() -> Int {
    guard !queue.isEmpty else {
        return -1
    }
    let num = queue.removeLast()
    available.remove(num)
    return num
}

关键点：

1. 检查队列是否为空
2. 从数组尾部移除元素(O(1))
3. 从Set中移除该号码(O(1))
4. 返回分配的号码

注意：使用removeLast()而非removeFirst()是为了保证O(1)时间复杂度，因为Swift数组头部操作是O(n)

3.3 号码检查(check)实现

swift复制func check(_ number: Int) -> Bool {
    guard number >= 0 && number < maxNumbers else {
        return false
    }
    return available.contains(number)
}

实现要点：

1. 边界检查（避免非法输入）
2. 使用Set的contains方法(O(1))检查存在性

3.4 号码释放(release)实现

swift复制func release(_ number: Int) {
    guard number >= 0 && number < maxNumbers else {
        return
    }
    if !available.contains(number) {
        available.insert(number)
        queue.append(number)
    }
}

关键逻辑：

1. 边界检查
2. 检查号码是否已被分配（不在available中）
3. 将号码重新加入Set和Array

技巧：使用contains检查避免重复释放，保证幂等性

4. 复杂度分析与优化

4.1 时间复杂度对比

4.2 空间复杂度

虽然使用了两个数据结构存储号码，但：

• 它们存储的是相同的数据
• 没有额外的空间开销
• 总空间复杂度仍为O(n)

这是典型的"空间换时间"策略，在资源管理系统中很常见。

5. 边界条件处理

5.1 非法输入处理

swift复制// check方法中的边界检查
guard number >= 0 && number < maxNumbers else {
    return false
}

// release方法中的边界检查
guard number >= 0 && number < maxNumbers else {
    return
}

5.2 重复释放问题

swift复制if !available.contains(number) {
    available.insert(number)
    queue.append(number)
}

这段代码确保：

1. 只有已分配的号码会被释放
2. 重复释放不会造成问题
3. 保持数据结构的一致性

5.3 资源耗尽情况

swift复制guard !queue.isEmpty else {
    return -1
}

当所有号码都已分配时，get()返回-1表示失败，符合题目要求。

6. 实际应用场景扩展

6.1 数据库连接池管理

swift复制class ConnectionPool {
    private var available: Set<Connection>
    private var queue: [Connection]
    
    func getConnection() -> Connection? {
        guard !queue.isEmpty else { return nil }
        let conn = queue.removeLast()
        available.remove(conn)
        return conn
    }
    
    func release(_ conn: Connection) {
        if !available.contains(conn) {
            available.insert(conn)
            queue.append(conn)
        }
    }
}

6.2 线程池实现

swift复制class ThreadPool {
    private var availableThreads: Set<WorkerThread>
    private var idleThreads: [WorkerThread]
    
    func getThread() -> WorkerThread? {
        guard !idleThreads.isEmpty else { return nil }
        let thread = idleThreads.removeLast()
        availableThreads.remove(thread)
        return thread
    }
    
    func release(_ thread: WorkerThread) {
        if !availableThreads.contains(thread) {
            availableThreads.insert(thread)
            idleThreads.append(thread)
        }
    }
}

6.3 会议室预订系统

swift复制class MeetingRoomManager {
    private var availableRooms: Set<Int>
    private var freeRooms: [Int]
    
    func bookRoom() -> Int? {
        guard !freeRooms.isEmpty else { return nil }
        let room = freeRooms.removeLast()
        availableRooms.remove(room)
        return room
    }
    
    func releaseRoom(_ room: Int) {
        if !availableRooms.contains(room) {
            availableRooms.insert(room)
            freeRooms.append(room)
        }
    }
}

7. 性能测试与验证

7.1 单元测试示例

swift复制func testPhoneDirectory() {
    let dir = PhoneDirectory(3)
    
    // 测试初始状态
    XCTAssertEqual(dir.check(0), true)
    XCTAssertEqual(dir.check(1), true)
    XCTAssertEqual(dir.check(2), true)
    
    // 测试分配
    let num1 = dir.get()
    XCTAssertTrue([0,1,2].contains(num1))
    XCTAssertEqual(dir.check(num1), false)
    
    // 测试释放
    dir.release(num1)
    XCTAssertEqual(dir.check(num1), true)
    
    // 测试边界
    XCTAssertEqual(dir.check(-1), false)
    XCTAssertEqual(dir.check(3), false)
}

7.2 压力测试

swift复制func testPerformance() {
    let dir = PhoneDirectory(10_000)
    
    measure {
        // 执行大量操作
        for _ in 0..<20_000 {
            let num = dir.get()
            if num != -1 {
                dir.release(num)
            }
        }
    }
}

预期结果：即使在最大数据量下，所有操作也应保持O(1)时间复杂度。

8. 替代方案比较

8.1 仅使用队列的实现

swift复制class PhoneDirectoryQueueOnly {
    private var queue: [Int]
    
    func get() -> Int {
        return queue.isEmpty ? -1 : queue.removeFirst()
    }
    
    func check(_ number: Int) -> Bool {
        return queue.contains(number)
    }
    
    func release(_ number: Int) {
        if !queue.contains(number) {
            queue.append(number)
        }
    }
}

缺点：

• check()和release()中的contains是O(n)操作
• 不适合大规模数据

8.2 使用位图的实现

swift复制class PhoneDirectoryBitVector {
    private var bitVector: [Bool]
    private var nextAvailable: Int
    
    init(_ maxNumbers: Int) {
        bitVector = Array(repeating: true, count: maxNumbers)
        nextAvailable = 0
    }
    
    func get() -> Int {
        guard nextAvailable < bitVector.count else { return -1 }
        let num = nextAvailable
        bitVector[num] = false
        nextAvailable = bitVector.firstIndex(of: true) ?? bitVector.count
        return num
    }
    
    func check(_ number: Int) -> Bool {
        guard number >= 0 && number < bitVector.count else { return false }
        return bitVector[number]
    }
    
    func release(_ number: Int) {
        guard number >= 0 && number < bitVector.count else { return }
        if !bitVector[number] {
            bitVector[number] = true
            if number < nextAvailable {
                nextAvailable = number
            }
        }
    }
}

优点：

• 空间效率高
• 适合号码范围大的情况

缺点：

• get()操作在最坏情况下是O(n)
• 实现复杂度较高

9. 常见问题与解决方案

9.1 为什么选择Swift实现？

Swift作为现代编程语言：

1. 语法简洁清晰
2. 标准库提供了高效的集合类型
3. 可选类型(Optional)能很好地表示操作可能失败的情况
4. 性能接近C/C++级别

9.2 如何处理并发访问？

实际生产环境中需要考虑线程安全：

swift复制class ConcurrentPhoneDirectory {
    private let lock = NSLock()
    private var available: Set<Int>
    private var queue: [Int]
    
    func get() -> Int {
        lock.lock()
        defer { lock.unlock() }
        guard !queue.isEmpty else { return -1 }
        let num = queue.removeLast()
        available.remove(num)
        return num
    }
    // 其他方法也需要加锁...
}

9.3 如何扩展更多功能？

可以根据需求扩展：

1. 预约特定号码
2. 设置号码有效期
3. 统计使用情况
4. 优先级分配等

10. 工程实践建议

1. 日志记录：重要操作添加日志，便于调试
2. 监控指标：统计分配成功率、等待时间等
3. 容量规划：根据历史数据合理设置初始大小
4. 故障处理：设计优雅降级方案
5. 自动化测试：覆盖所有边界条件

在实现这类资源管理系统时，我通常会：

1. 先明确需求和约束条件
2. 分析各种数据结构的优缺点
3. 编写单元测试验证边界条件
4. 进行性能测试确保满足要求
5. 考虑扩展性和维护性

这种设计模式的价值在于它的通用性。掌握了这种Set+Array的组合方案后，你可以轻松应对各种资源管理场景。在实际工程中，我曾在数据库连接池、线程池、缓存对象管理等多个场景成功应用过这种模式。