[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）线性表。

类版本队列

  1 class Queue
  2 {
  3     //给类添加一个Any类型的数组属性
  4     //Any可以表示任何类型，包括函数类型、可选类型
  5     var queue: [Any]
  6     
  7     //属性：获取队列的大小
  8     var count: Int
  9     {
 10         get {
 11             return queue.count
 12         } 
 13     }
 14     
 15     // 计算属性：返回队列的存储容量,数组会自动扩大为原来两倍
 16     // - get：获取队列的存储空间，但不会分配新的存储空间
 17     // - set：分配足够的空间来存储指定数量的元素
 18     var capacity: Int {
 19         get {
 20             return queue.capacity
 21         }
 22         set {
 23             queue.reserveCapacity(newValue)
 24         }
 25     }
 26     
 27     //初始化方法用来对数组属性初始化
 28     //如果定义了默认值，则可以在调用函数时省略该参数
 29     init()
 30     {
 31         queue = [Any]()
 32     }
 33     
 34     //通过既定数组构造队列
 35     init(_ arr:[Any]){
 36         queue = arr
 37     }
 38     
 39     // 如果定义了默认值，则可以在调用函数时省略该参数
 40     init(_ elements: Any...) {
 41         queue = elements
 42     }
 43     
 44     //判断队列是否为空
 45     func isEmpty() -> Bool
 46     {
 47         return queue.isEmpty
 48     }
 49     
 50     //检查队列是否已满
 51     //如果队列已满，则返回true，否则返回false
 52     public func isFull() -> Bool {
 53         return count == queue.capacity
 54     }
 55     
 56     //清空队列
 57     func clear()
 58     {
 59         queue.removeAll()
 60     }
 61     
 62     //入队列(一次可入队一个或多个元素)
 63     //可变参数参数接受具有指定类型的零个或更多的值
 64     func enQueue(_ objects: Any...)
 65     {
 66         for obj in objects {
 67             queue.append(obj)
 68         } 
 69     }
 70     
 71     //出队列
 72     func deQueue() -> Any?
 73     {
 74         //判断队列是否为空
 75         if isEmpty()
 76         {
 77             return nil
 78         }
 79         else
 80         {
 81             //数组中移除第一个元素
 82             return queue.removeFirst()
 83         }
 84     } 
 85     
 86     //获取最后队列第一个元素
 87     func getFirst() -> Any?
 88     {
 89         //判断堆栈是否为空
 90         if isEmpty()
 91         {
 92             return nil
 93         }
 94         else
 95         {
 96             //获取队列第一个元素
 97             return queue.first!
 98         }
 99     }
100     
101      // 在打印队列及其元素时，输出简洁的格式
102     var description: String {
103         get {
104             return queue.description
105         }
106     }
107     
108     // 打印时输出简洁漂亮的格式，主要用于调试
109     var debugDescription: String {
110         get {
111             return queue.debugDescription
112         }
113     }   
114 }
115 
116 //初始化队列
117 var queue1 = Queue()
118 var queue2 = Queue([1,2,3])
119 dump(queue2)
120 /*
121 ▿ prog.Queue #0
122   ▿ queue: 1 element
123     ▿ 3 elements
124       - 1
125       - 2
126       - 3
127 */
128 var queue3 = Queue(4,5,6)
129 dump(queue3)
130 /*
131 ▿ prog.Queue #0
132   ▿ queue: 3 elements
133     - 4
134     - 5
135     - 6
136 */
137 //入队
138 queue1.enQueue(1,2,3,4,5,6)   
139 //出队
140 queue1.deQueue()
141 dump(queue1)
142 /*
143 ▿ prog.Queue #0
144   ▿ queue: 5 elements
145     - 2
146     - 3
147     - 4
148     - 5
149     - 6
150 */
151 queue1.clear()
152 dump(queue1)
153 /*
154 ▿ prog.Queue #0
155   - queue: 0 elements
156 */

泛型版本队列

 1 public struct Queue<T> {
 2     
 3     // 泛型数组：用于存储数据元素
 4     fileprivate var queue: [T] 
 5 
 6     // 返回队列中元素的个数
 7     public var count: Int {
 8         return queue.count
 9     }
10     
11     // 计算属性：返回队列的存储容量
12     // - get：获取队列的存储空间，但不会分配新的存储空间
13     // - set：分配足够的空间来存储指定数量的元素
14     public var capacity: Int {
15         get {
16             return queue.capacity
17         }
18         set {
19             queue.reserveCapacity(newValue)
20         }
21     }
22     
23     // 构造函数：创建一个空的队列
24     public init() {
25         queue = [T]()
26     }
27     
28     //通过既定数组构造队列
29     init(_ arr:[T]){
30         queue = arr
31     }
32     
33     // 如果定义了默认值，则可以在调用函数时省略该参数
34     init(_ elements: T...) {
35         queue = elements
36     }
37     
38     // 检查队列是否为空
39     // - returns: 如果队列为空，则返回true，否则返回false
40     public func isEmpty() -> Bool {
41         return queue.isEmpty
42     }
43     
44     // 检查队列是否已满
45     // -returns: 如果队列已满，则返回true，否则返回false
46     public func isFull() -> Bool {
47         return count == queue.capacity
48     }
49     
50     // 将队列重置为空状态
51     public mutating func clear() {
52         queue.removeAll()
53     }
54     
55     // 入队列操作：将元素添加到队列的末尾
56     public mutating func enQueue(_ element: T) {
57         queue.append(element)
58     }
59     
60     // 出队列操作：删除并返回队列中的第一个元素
61     public mutating func deQueue() -> T? {
62         return queue.removeFirst()
63     }
64  
65     // 返回队列中的第一个元素(不删除)
66     public func getFirst() -> T? {
67         return queue.first!
68     }
69     
70      // 在打印队列及其元素时，输出简洁的格式
71     public var description: String {
72         return queue.description
73     }
74     
75     
76     // 打印时输出简洁的格式，主要用于调试
77     public var debugDescription: String {
78         return queue.debugDescription
79     }   
80 }