[Swift]队列Queue的两种版本：(1)用类包装Queue (2)用泛型包装Queue

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/ ）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9854901.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。

 

类版本队列

class Queue
{
    //给类添加一个Any类型的数组属性
    //Any可以表示任何类型，包括函数类型、可选类型
    var queue: [Any]
    
    //属性：获取队列的大小
    var count: Int
    {
        get {
            return queue.count
        } 
    }
    
    // 计算属性：返回队列的存储容量,数组会自动扩大为原来两倍
    // - get：获取队列的存储空间，但不会分配新的存储空间
    // - set：分配足够的空间来存储指定数量的元素
    var capacity: Int {
        get {
            return queue.capacity
        }
        set {
            queue.reserveCapacity(newValue)
        }
    }
    
    //初始化方法用来对数组属性初始化
    //如果定义了默认值，则可以在调用函数时省略该参数
    init()
    {
        queue = [Any]()
    }
    
    //通过既定数组构造队列
    init(_ arr:[Any]){
        queue = arr
    }
    
    // 如果定义了默认值，则可以在调用函数时省略该参数
    init(_ elements: Any...) {
        queue = elements
    }
    
    //判断队列是否为空
    func isEmpty() -> Bool
    {
        return queue.isEmpty
    }
    
    //检查队列是否已满
    //如果队列已满，则返回true，否则返回false
    public func isFull() -> Bool {
        return count == queue.capacity
    }
    
    //清空队列
    func clear()
    {
        queue.removeAll()
    }
    
    //入队列(一次可入队一个或多个元素)
    //可变参数参数接受具有指定类型的零个或更多的值
    func enQueue(_ objects: Any...)
    {
        for obj in objects {
            queue.append(obj)
        } 
    }
    
    //出队列
    func deQueue() -> Any?
    {
        //判断队列是否为空
        if isEmpty()
        {
            return nil
        }
        else
        {
            //数组中移除第一个元素
            return queue.removeFirst()
        }
    } 
    
    //获取最后队列第一个元素
    func getFirst() -> Any?
    {
        //判断堆栈是否为空
        if isEmpty()
        {
            return nil
        }
        else
        {
            //获取队列第一个元素
            return queue.first!
        }
    }
    
     // 在打印队列及其元素时，输出简洁的格式
    var description: String {
        get {
            return queue.description
        }
    }
    
    // 打印时输出简洁漂亮的格式，主要用于调试
    var debugDescription: String {
        get {
            return queue.debugDescription
        }
    }   
}

//初始化队列
var queue1 = Queue()
var queue2 = Queue([1,2,3])
dump(queue2)
/*
▿ prog.Queue #0
  ▿ queue: 1 element
    ▿ 3 elements
      - 1
      - 2
      - 3
*/
var queue3 = Queue(4,5,6)
dump(queue3)
/*
▿ prog.Queue #0
  ▿ queue: 3 elements
    - 4
    - 5
    - 6
*/
//入队
queue1.enQueue(1,2,3,4,5,6)   
//出队
queue1.deQueue()
dump(queue1)
/*
▿ prog.Queue #0
  ▿ queue: 5 elements
    - 2
    - 3
    - 4
    - 5
    - 6
*/
queue1.clear()
dump(queue1)
/*
▿ prog.Queue #0
  - queue: 0 elements
*/

泛型版本队列

public struct Queue<T> {
    
    // 泛型数组：用于存储数据元素
    fileprivate var queue: [T] 

    // 返回队列中元素的个数
    public var count: Int {
        return queue.count
    }
    
    // 计算属性：返回队列的存储容量
    // - get：获取队列的存储空间，但不会分配新的存储空间
    // - set：分配足够的空间来存储指定数量的元素
    public var capacity: Int {
        get {
            return queue.capacity
        }
        set {
            queue.reserveCapacity(newValue)
        }
    }
    
    // 构造函数：创建一个空的队列
    public init() {
        queue = [T]()
    }
    
    //通过既定数组构造队列
    init(_ arr:[T]){
        queue = arr
    }
    
    // 如果定义了默认值，则可以在调用函数时省略该参数
    init(_ elements: T...) {
        queue = elements
    }
    
    // 检查队列是否为空
    // - returns: 如果队列为空，则返回true，否则返回false
    public func isEmpty() -> Bool {
        return queue.isEmpty
    }
    
    // 检查队列是否已满
    // -returns: 如果队列已满，则返回true，否则返回false
    public func isFull() -> Bool {
        return count == queue.capacity
    }
    
    // 将队列重置为空状态
    public mutating func clear() {
        queue.removeAll()
    }
    
    // 入队列操作：将元素添加到队列的末尾
    public mutating func enQueue(_ element: T) {
        queue.append(element)
    }
    
    // 出队列操作：删除并返回队列中的第一个元素
    public mutating func deQueue() -> T? {
        return queue.removeFirst()
    }
 
    // 返回队列中的第一个元素(不删除)
    public func getFirst() -> T? {
        return queue.first!
    }
    
     // 在打印队列及其元素时，输出简洁的格式
    public var description: String {
        return queue.description
    }
    
    
    // 打印时输出简洁的格式，主要用于调试
    public var debugDescription: String {
        return queue.debugDescription
    }   
}