swift写数据结构栈,队列

栈是一种运算受限的线性表，它具有 后进先出（Last In First Out）的特性。仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。这种操作过程就有 入栈，出栈。

用数组的方式就能很简单的实现（主要是在数组的末端操作，如果在数组的首端操作会存在数组元素移动使时间复杂度O(n)，而在数组末端操作O(1)）

public struct Stack<T>{
    
    var array = [T]()
    
    //栈是否为空
    public var isEmpty:Bool{
        return array.isEmpty
    }
    
    //栈元素个数
    public var count:Int{
        return array.count
    }
    
    //入栈
    public mutating func push(_ element:T){
        return array.append(element)
    }
    
    //出栈
    public mutating func pop()->T? {
        return array.popLast()
    }
    
    //栈顶元素
    public var topElemet:T? {
        return array.last
    }
    
    //清栈
    public mutating func clearStack() {
        array.removeAll()
    }
}

队列
队列是FIFO 先进先出的特性，用数据的方法实现也很简单,这种简单的实现 dequeue的算法复杂库O(n),
The reason thatdequeue()andenqueueFront()are **O(n)** is that they work on the front of the array. If you remove an element at the front of an array, what happens is that all the remaining elements need to be shifted in memory.

public struct Deque<T> {
    var array = [T]()
    
    var isEmpty:Bool{
        return array.isEmpty
    }
    var count:Int {
        return array.count
    }
    //入队
    mutating func enqueue(element:T) {
        array.append(element)
    }
    //出队
    mutating func dequeue(element:T)  {
        array.removeFirst()
    }
    
    //拿到队列的 队头元素
    func getQueueFirstData() -> T? {
        return array.first
    }
    
    //队尾元素
    func getQueueLastData()->T?{
        return array.last
    }
}

换一种写法也可以把入队，出队的操作时间复杂度变为O(1),提高效率。
具体的详情有介绍 https://github.com/raywenderlich/swift-algorithm-club/blob/master/Queue/README.markdown