Java数据结构：栈

1. 概述

栈（stack）又称为堆栈，栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。

栈通常包括的三种操作：push、peek、pop。

push： 向栈中添加元素。

peek： 返回栈顶元素。

pop：返回并删除栈顶元素的操作。

下图是入栈和出栈的示意图：（此图片来自百度图片）

2. 栈的实现

栈可以使用静态数组结构或动态链表结构来实现，只要维持栈后进先出与从顶端读取数据的两个基本原则即可。

实现类：

package zzw.cn.stack;

/**
 * @author 鹭岛猥琐男
 * @create 2019/8/13 21:08
 */
public class ArrayStack
{
    private int[] arr;
    private int top;

    public ArrayStack(int stack_size)
    {
        arr = new int[stack_size];//建立数组
        top = -1;
    }

    /*
     * 往栈顶加入元素
     */
    public boolean push(int data)
    {
        if (top >= arr.length - 1)
        {
            System.out.println("栈已满，无法再加入。");
            return false;
        } else
        {
            arr[++top] = data;
            return true;
        }
    }

    /*
     * 判断栈是否为空
     */
    public boolean isEmpty()
    {
        if (top == -1)
        {
            return true;
        }
        return false;
    }

    /*
     * 往栈顶取出元素
     */
    public int pop()
    {
        if (isEmpty())
        {
            return -1;
        } else
        {
            return arr[top--];
        }
    }

    /*
     * 返回栈顶元素
     */
    public int peek()
    {
        if (isEmpty())
        {
            return -1;
        } else
        {
            return arr[top];
        }
    }
}

测试类：

package zzw.cn.stack;

/**
 * @author 鹭岛猥琐男
 * @create 2019/8/13 21:30
 */
public class TestStack
{
    public static void main(String[] args)
    {
        //设置栈的长度为5，依次往栈中加入6个元素，加入的顺序为1,2,3,4,5,6
        ArrayStack stack = new ArrayStack(5);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        System.out.println("返回栈顶的元素："+stack.peek());
        System.out.println("依次取出栈中的元素：");
        while (!stack.isEmpty())
        {
            System.out.print(stack.pop() + " ");
        }
    }
}

结果：

栈已满，无法再加入。
返回栈顶的元素：5
依次取出栈中的元素：
5 4 3 2 1 

3. JDK中Stack类

JDK包中也提供了"栈"的实现，它就是集合框架中的Stack类。

package java.util;

public
class Stack<E> extends Vector<E> {
    /**
     * Creates an empty Stack.
     */
    public Stack() {
    }


    public E push(E item) {
        addElement(item);

        return item;
    }


    public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }


    public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }


    public boolean empty() {
        return size() == 0;
    }


    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}

Stack继承于Vector，主要的方法有 push，pop，peek等方法。此方法的作用跟上面的例子中的方法一样。

4. 总结

对于栈的实现，数据入栈和出栈的时间复杂度都为O(1)，栈操作所耗的时间不依赖栈中数据项的个数。