[Swift]堆栈Stack的两种版本：(1)用类包装Stack (2)用泛型包装Stack

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

堆栈是一个在计算机科学中经常使用的抽象数据类型。堆栈中的物体具有一个特性： 最后一个放入堆栈中的物体总是被最先拿出来， 这个特性通常称为后进先出(LIFO)队列。 堆栈中定义了一些操作。 两个最重要的是PUSH和POP。 PUSH操作在堆栈的顶部加入一 个元素。POP操作相反， 在堆栈顶部移去一个元素， 并将堆栈的大小减一。

类版本堆栈

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

//初始化堆栈
var stack1 = Stack()
var stack2 = Stack([1,2,3])
dump(stack2)
/*
▿ prog.Stack #0
  ▿ stack: 1 element
    ▿ 3 elements
      - 1
      - 2
      - 3
*/
var stack3 = Stack(4,5,6)
dump(stack3)
/*
▿ prog.Stack #0
  ▿ stack: 3 elements
    - 4
    - 5
    - 6
*/
//入队
stack1.push(1,2,3,4,5,6)   
//出队
stack1.pop()
dump(stack1)
/*
▿ prog.Stack #0
  ▿ stack: 5 elements
    - 1
    - 2
    - 3
    - 4
    - 5
*/
stack1.clear()
dump(stack1)
/*
▿ prog.Stack #0
  - stack: 0 elements
*/

泛型版本堆栈

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

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