数据结构———栈

目录

基本概念

常用操作

栈的实现

1.   基于链表的实现

2.   基于数组的实现

实现之间的对比

栈的典型应用

---

基本概念

栈（stack）是一种遵循先入后出逻辑的线性数据结构。

我们可以将栈类比为枪械上的弹夹，如果想打出底部的子弹，则需要先将上面的子弹依次移走。我们将子弹替换为各种类型的元素（如整数、字符、对象等），就得到了栈这种数据结构。

• 初始化（Initialization）：创建一个新的空栈。分配必要的内存空间。
• 入栈（Push）：向栈中添加一个元素。元素被放置在栈顶。
• 出栈（Pop）：从栈中移除栈顶的元素。移除的元素是最晚加入栈的元素（除了当前要移除的元素）。
• 读取栈顶元素（Peek/Top）：返回栈顶元素而不移除它。
• 判断栈是否为空（IsEmpty）：判断栈中是否还有元素存在。
• 销毁栈（DestroyStack）：释放栈占用的所有内存资源。

常用操作

栈的常用操作如表 5-1 所示，具体的方法名需要根据所使用的编程语言来确定。在此，我们以常见的 push()、pop()、peek() 命名为例。

方法                                        描述                                             时间复杂度

push()                                元素入栈（添加至栈顶）                      O(1)

pop()                                  栈顶元素出栈                                        O(1)

peek()                                访问栈顶元素                                        O(1)

/* 初始化栈 */
Stack<Integer> stack = new Stack<>();
 
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
 
/* 访问栈顶元素 */
int peek = stack.peek();
 
/* 元素出栈 */
int pop = stack.pop();
 
/* 获取栈的长度 */
int size = stack.size();
 
/* 判断是否为空 */
boolean isEmpty = stack.isEmpty();

栈的实现

栈遵循先入后出的原则，因此我们只能在栈顶添加或删除元素。然而，数组和链表都可以在任意位置添加和删除元素，因此栈可以视为一种受限制的数组或链表。

1.   基于链表的实现

使用链表实现栈时，我们可以将链表的头节点视为栈顶，尾节点视为栈底。

对于入栈操作，我们只需将元素插入链表头部，这种节点插入方法被称为“头插法”。而对于出栈操作，只需将头节点从链表中删除即可。

基于链表实现栈的示例代码：

/* 基于链表实现的栈 */
class LinkedListStack {
    private ListNode stackPeek; // 将头节点作为栈顶
    private int stkSize = 0; // 栈的长度
 
    public LinkedListStack() {
        stackPeek = null;
    }
 
    /* 获取栈的长度 */
    public int size() {
        return stkSize;
    }
 
    /* 判断栈是否为空 */
    public boolean isEmpty() {
        return size() == 0;
    }
 
    /* 入栈 */
    public void push(int num) {
        ListNode node = new ListNode(num);
        node.next = stackPeek;
        stackPeek = node;
        stkSize++;
    }
 
    /* 出栈 */
    public int pop() {
        int num = peek();
        stackPeek = stackPeek.next;
        stkSize--;
        return num;
    }
 
    /* 访问栈顶元素 */
    public int peek() {
        if (isEmpty())
            throw new IndexOutOfBoundsException();
        return stackPeek.val;
    }
 
    /* 将 List 转化为 Array 并返回 */
    public int[] toArray() {
        ListNode node = stackPeek;
        int[] res = new int[size()];
        for (int i = res.length - 1; i >= 0; i--) {
            res[i] = node.val;
            node = node.next;
        }
        return res;
    }
}

2.   基于数组的实现

使用数组实现栈时，我们可以将数组的尾部作为栈顶。如图 5-3 所示，入栈与出栈操作分别对应在数组尾部添加元素与删除元素，时间复杂度都为 O(1) 。

由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无须自行处理数组扩容问题。以下为示例代码：

/* 基于数组实现的栈 */
class ArrayStack {
    private ArrayList<Integer> stack;
 
    public ArrayStack() {
        // 初始化列表（动态数组）
        stack = new ArrayList<>();
    }
 
    /* 获取栈的长度 */
    public int size() {
        return stack.size();
    }
 
    /* 判断栈是否为空 */
    public boolean isEmpty() {
        return size() == 0;
    }
 
    /* 入栈 */
    public void push(int num) {
        stack.add(num);
    }
 
    /* 出栈 */
    public int pop() {
        if (isEmpty())
            throw new IndexOutOfBoundsException();
        return stack.remove(size() - 1);
    }
 
    /* 访问栈顶元素 */
    public int peek() {
        if (isEmpty())
            throw new IndexOutOfBoundsException();
        return stack.get(size() - 1);
    }
 
    /* 将 List 转化为 Array 并返回 */
    public Object[] toArray() {
        return stack.toArray();
    }
}

实现之间的对比

支持操作

两种实现都支持栈定义中的各项操作。数组实现额外支持随机访问，但这已超出了栈的定义范畴，因此一般不会用到。

时间效率

在基于数组的实现中，入栈和出栈操作都在预先分配好的连续内存中进行，具有很好的缓存本地性，因此效率较高。然而，如果入栈时超出数组容量，会触发扩容机制，导致该次入栈操作的时间复杂度变为 O(n) 。

在基于链表的实现中，链表的扩容非常灵活，不存在上述数组扩容时效率降低的问题。但是，入栈操作需要初始化节点对象并修改指针，因此效率相对较低。不过，如果入栈元素本身就是节点对象，那么可以省去初始化步骤，从而提高效率。

综上所述，当入栈与出栈操作的元素是基本数据类型时，例如 int 或 double ，我们可以得出以下结论。

• 基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。
• 基于链表实现的栈可以提供更加稳定的效率表现。

空间效率

在初始化列表时，系统会为列表分配“初始容量”，该容量可能超出实际需求；并且，扩容机制通常是按照特定倍率（例如 2 倍）进行扩容的，扩容后的容量也可能超出实际需求。因此，基于数组实现的栈可能造成一定的空间浪费。

然而，由于链表节点需要额外存储指针，因此链表节点占用的空间相对较大。

综上，我们不能简单地确定哪种实现更加节省内存，需要针对具体情况进行分析。

栈的典型应用

• 括号匹配：用于检查代码中的括号是否正确闭合。
• 表达式求值与转换：例如将中缀表达式转换为后缀表达式（逆波兰表示法）。
• 函数调用：用于存储函数调用时的局部变量和返回地址。
• 撤销操作：例如文本编辑器中的撤销功能。
• 浏览器历史记录：前进和后退功能。