栈介绍及简单实现

来源：互联网发布：淘宝返现卡片编辑：程序博客网时间：2024/06/07 02:24

一、栈介绍

1.1 简单介绍

栈(stack) 是一个有序线性表，只能在表的一端(称为栈顶(top))执行插入和删除操作。最后插入的元素最后一个被删除，所以，栈也称为后进先出(LIFO)或先进后出(FILO)线性表。

入栈(push)：表示在栈顶插入一个元素。

出栈(pop):表示从栈顶删除一个元素。

试图对一个空栈执行出栈操作称为下溢(underflow)

对一个满栈进行入栈操作称为溢出(overflow)。

通常情况下下溢和溢出均认为异常。

1.2 操作

简单起见，我们使用int类型。

void push(int data) 将data插入栈

int pop() 删除并返回最后一个插入的元素。

int top() 返回一个最后插入的元素。

int size() 返回存储在栈中的元素的个数。

boolean isEmpty() 判断栈中是否有元素

boolean isStackFull() 判断栈中是否存满元素。

1.3 栈的常见应用

符号匹配
中辍表达式转为后辍表达式
计算后辍表达式
实现函数调用（包括递归）
文本编辑器的撤销操作。
浏览器后退按钮的实现。

在后面的介绍中，会对栈的常见应用给出对应案例。

二、栈的实现

2.1 抽象栈

public abstract  class Stack {
    /**
     * 栈顶插入元素
     * @param data
     */
    public abstract void push(int data);
    /**
     * 删除并返回栈顶元素
     * @return
     */
    public abstract int pop();
    /**
     * 返回栈顶元素
     * @return
     */
    public abstract int top();
    /**
     * 返回栈中元素个数
     * @return
     */
    public abstract int size();
    /**
     * 判断栈是否为空
     * @return
     */
    public abstract boolean isEmpty();
    /**
     * 判断栈是否满了
     * @return
     */
    public abstract boolean isStackFull();
}

我们使用三种方式实现栈，一种是简单数组，一种是动态数组，最后是单向链表

2.2 简单数组实现栈

import java.util.Arrays;
/**
 * Created by Administrator on 2017/6/24 0024.
 */
public class SimpleDynamicArrayStack extends  Stack {
    private int top;
    private int capacity;
    private int[] array;
    public SimpleDynamicArrayStack(int capacity) {
        this.capacity = capacity;
        array = new int[capacity];
    }
    public void push(int data) {
        if(isStackFull()){
            expansion();
        }
        array[top] = data;
        top++;
    }
    public int pop() {
        if(isEmpty()){
            throw new IllegalMonitorStateException("该栈为空栈，无法探出元素");
        }
        top--;
        return array[top-1];
    }
    public int top() {
        if(isEmpty()){
            throw new IllegalMonitorStateException("该栈为空栈，没有元素");
        }
        top--;
        int temp = array[top-1];
        //如果栈中存储的不是基本数据类型，这里注意将array[top-1]置为null，否则可能出现内存泄漏
        return temp;
    }
    public int size() {
        return 0;
    }
    public boolean isEmpty() {
        return top == 0;
    }
    public boolean isStackFull() {
        return top == capacity;
    }
    /**
     * 数组扩容操作
     */
    private void expansion(){
        capacity = 2*capacity;
        array = Arrays.copyOf(array,capacity);
    }
}

性能和局限性

性能：假设n为栈中元素个数，在基于简单数组的栈的实现中，各种栈操作的算法复杂度如下:

空间复杂度(用于n次push操作)O(n)size()的时间复杂度O(1)push()的时间复杂度O(1)isEmpty()的时间复杂度O(1)pop()的事件复杂度O(1)isStackFull()的时间复杂度O(1)

局限性:栈的最大容量在初始化的时候指定不能改变。

2.2 基于动态数组的实现

我们采取的方式是当栈满了，就能让栈的容量扩充为原来的两倍

import java.util.Arrays;
/**
 * Created by Administrator on 2017/6/24 0024.
 */
public class SimpleDynamicArrayStack extends  Stack {
    private int top;
    private int capacity;
    private int[] array;
    public SimpleDynamicArrayStack(int capacity) {
        this.capacity = capacity;
        array = new int[capacity];
    }
    public void push(int data) {
        if(isStackFull()){
            expansion();
        }
        array[top] = data;
        top++;
    }
    public int pop() {
        if(top == 0){
            throw new IllegalMonitorStateException("该栈为空栈，无法探出元素");
        }
        top--;
        return array[top-1];
    }
    public int top() {
        if(isEmpty()){
            throw new IllegalMonitorStateException("该栈为空栈，没有元素");
        }
        top--;
        int temp = array[top-1];
        //如果栈中存储的不是基本数据类型，这里注意将array[top-1]置为null，否则可能出现内存泄漏
        return temp;
    }
    public int size() {
        return 0;
    }
    public boolean isEmpty() {
        return top == 0;
    }
    public boolean isStackFull() {
        return top == capacity;
    }
    /**
     * 数组扩容操作
     */
    private void expansion(){
        capacity = 2*capacity;
        array = Arrays.copyOf(array,capacity);
    }
}

性能：假设n为栈中元素个数。算法复杂度如下

空间复杂度(用于n次push操作)O(n)size()的时间复杂度O(1)push()的时间复杂度O(1)（平均）isEmpty()的时间复杂度O(1)pop()的事件复杂度O(1)isStackFull()的时间复杂度O(1)

2.2 使用链表实现

/**
链表节点
*/
public class Node {
    private int data;
    private Node next;
    public Node(int data) {
        this.data = data;
    }
    public int getData() {
        return data;
    }
    public void setData(int data) {
        this.data = data;
    }
    public Node getNext() {
        return next;
    }
    public void setNext(Node next) {
        this.next = next;
    }
}
import cn.lx.node.Node;
/**
 * Created by Administrator on 2017/6/24 0024.
 */
public class SimpleNodeStack extends Stack{
    private Node headNode;
    private int size;
    @Override
    public void push(int data) {
        Node node = new Node(data);
        if(isEmpty()){
            headNode = node;
            return;
        }
        size++;
        node.setNext(headNode);
        headNode = node;
    }
    @Override
    public int pop() {
        if(isEmpty()){
            throw new IllegalMonitorStateException("该栈为空栈，无法探出元素");
        }
        int temp = headNode.getData();
        headNode = headNode.getNext();
        size--;
        return temp;
    }
    @Override
    public int top() {
        if(isEmpty()){
            throw new IllegalMonitorStateException("该栈为空栈，无法探出元素");
        }
        int temp = headNode.getData();
        return temp;
    }
    @Override
    public int size() {
        return 0;
    }
    @Override
    public boolean isEmpty() {
        return    headNode == null;
    }
    @Override
    public boolean isStackFull() {
        return false;
    }
}