数据结构与算法之栈与队列<四>

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

栈与队列是重要的基础数据结构，其作用更多体现在其思想上。
栈 是先进后出原则
队列 是先进先出原则
这两种不同的思想决定了他们不同的用途，
栈的应用场景
1.符号匹配
2.中缀表达式转化为后缀表达式
3.计算后缀表达式
4.实现函数的调用
5.文本编译器中的撤销按钮
6.网页浏览器的历史记录。
7.作为一个算法辅助数据结构 比如树的遍历
队列的应用场景
1.操作系统的顺序调度
2.多道程序设计
3.异步数据传输
4.作为算法的辅助数据结构（树的层次遍历）

栈与队列都可以使用数组和链表实现而且实现的效果类似
限于篇幅，这里就给出栈的实现代码，队列可以以此类推

数组实现栈

//利用动态数组来实现动态栈
public class StackByDynamicArray {
    // 栈的大小
    private int stackSize;
    // 栈顶
    private int top;
    // 栈的容器类型
    private Object[] array;

    // 初始化栈 栈大小默认为10
    public StackByDynamicArray() {
        stackSize = 10;
        array = new Object[stackSize];
        top = -1;
    }

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

    // 判断栈是否满了
    public boolean isFull() {
        return (top == array.length);
    }

    // 若栈满则扩充栈，每次扩充是当前栈的一倍
    public void doubleStack() {

        stackSize = stackSize * 2;
        // 创建新栈
        Object[] doubleArray = new Object[stackSize];
        // 将旧栈复制到新栈
        System.arraycopy(array, 0, doubleArray, 0, array.length);
        // 新栈替代旧栈
        array = doubleArray;
    }

    // 压栈
    public void push(Object obj) {
        if (isFull()) {
            doubleStack();
        } else
            array[++top] = obj;
    }

    // 出栈
    public Object pop() throws Exception {
        if (isEmpty()) {
            throw new Exception("空栈");
        } else
            return array[top--];
    }

    // 删栈
    public void deleteStack() {
        top = -1;
    }

链表实现栈

//栈的节点对象
public class StackNode {
    // 指向下一个节点
    private StackNode next;
    // 储存的内容
    private Object data;

    public StackNode getNext() {
        return next;
    }

    public void setNext(StackNode next) {
        this.next = next;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
}



public class StackByLinkedList {
    private StackNode headNode;

    // 压栈
    public void push(Object data) {
        StackNode stackNode = new StackNode();
        stackNode.setData(data);
        if (null == headNode) {
            headNode = stackNode;
        } else {
            stackNode.setNext(headNode);
            headNode = stackNode;
        }
    }

    // 返回栈顶的数据
    public Object top() {
        if (headNode == null)
            return null;
        else
            return headNode.getData();
    }

    // 出栈
    public Object pop() throws Exception {
        if (headNode == null)
            throw new Exception("空栈");
        else {
            Object object = headNode.getData();
            headNode = headNode.getNext();
            return object;
        }
    }

    // 是否为空
    public boolean isEmpty() {
        return (null == headNode);
    }

    // 删除栈
    public void deleteStack() {
        headNode = null;
    }

就此栈的实现差不多就完成了。