栈

栈的定义  

      栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。  

    (1)通常称插入、删除的这一端为栈顶 （Top），另一端称为栈底 （Bottom）。  

    (2)当表中没有元素时称为空栈。  

    (3)栈为后进先出（Last In First Out）的线性表，简称为 LIFO 表。  

    栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中" 

最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部， 

要到最后才能删除。

    

    

【示例】元素是以a1，a2，…，an的顺序进栈，退栈的次序却是an，an-1，…， 

a1。  

 

2、栈的基本运算  

 （1）InitStack（S）  

      构造一个空栈S。  

 （2）StackEmpty（S）  

      判栈空。若S为空栈，则返回TRUE，否则返回FALSE。  

 （3）StackFull（S）  

      判栈满。若S为满栈，则返回TRUE，否则返回FALSE。  

注意： 该运算只适用于栈的顺序存储结构。  

 （4）Push（S，x）  

      进栈。若栈S不满，则将元素x插入S的栈顶。  

 （5）Pop（S）

定义堆栈ADT
    

public interface StackADT {
    public void push(Object element);//压栈
    public Object pop();//出栈
    public boolean isEmpty();
    public int size();
    public Object peek();//返回栈顶对象的一个引用
    public String toString();
}

链式实现：
    

public class LinkedStack implements StackADT {
    private LinearNode top; //指向栈顶
    private int count;//标记栈的大小
    public static void main(String[] args){
        LinkedStack stack = new LinkedStack();
        System.out.println("将0到10依次压栈");
        for(int i = 0;i < 10;i++)
            stack.push(i);
        System.out.println("连续执行5次出栈操作");
        for(int i = 0;i < 5;i++)
            stack.pop();
        System.out.println("栈为空吗？： " + stack.isEmpty());
        System.out.println("栈的大小为： " + stack.size());
        System.out.println("栈顶元素为： " + stack.top.getElement());
        System.out.println("栈顶元素为： " + stack.peek());
    }
    public LinkedStack()
    {
        top = null;
        count = 0;
    }
    public int size() {
        return count;
    }
    public boolean isEmpty() {
        return (size() == 0);
    }
    public void push(Object element) {
        LinearNode node = new LinearNode(element);
        node.setNext(top);
        top = node;
        count++;
    }
    public Object pop() {
        if(isEmpty())
        {
            System.out.println("stack is empty!");
            System.exit(1);
        }
        Object result = top.getElement();
        top = top.getNext();
        count--;
        return result;
    }
    public Object peek() {
        Object result = top.getElement();
        return result;
    }
}

运行结果：
将0到10依次压栈
连续执行5次出栈操作
栈为空吗？： false
栈的大小为： 5
栈顶元素为： 4
栈顶元素为： 4

数组实现：
    

public class ArrayStack implements StackADT {
    private Object[] contents;
    private int top;//top标记下一个入栈的位置，同时也表示栈的容量大小，跟链式实现的count比较一下！！！
    private static int SIZE = 10;
    public ArrayStack()
    {
        contents = new Object[SIZE];
        top = 0;
    }
    public void expand(){//借助于申请一个辅助空间,每次扩展容量一倍
        Object[] larger = new Object[size()*2];
        for(int index = 0;index < top;index++)
            larger[index] = contents[index];
        contents = larger;
    }
    public int size() {
        return top;
    }
    public boolean isEmpty() {
        return (size() == 0);
    }
    public void push(Object element) {
        //if(isEmpty())
            //expand();
        if(top == contents.length)
            expand();
        contents[top] = element;
        top++;
    }
    public Object pop() {
        if(isEmpty())
        {
            System.out.println("stack is empty!");
            System.exit(1);
        }
        Object result = contents[top-1];
        contents[top-1] = null;//出栈
        top--;
        return result;
        /*书上这样写简便一点：：：
         * top--;
         * Object result = contents[top];
         * contents[top] = null;*/
    }
    public Object peek() {
        Object result;
        if(isEmpty())
            result = null;
        else
            result = contents[top-1];
        return result;
    }
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack();
        System.out.println("将0到24依次压栈，然后连续10次出栈");
        for(int i = 0;i < 25;i++)
            stack.push(i);
        for(int i = 0;i < 10;i++)
            stack.pop();
        System.out.println("栈的大小为： " + stack.size());
        System.out.println("栈为空吗？： " + stack.isEmpty());
        System.out.println("栈顶元素为： " + stack.peek());
    }
}

运行结果：
将0到24依次压栈，然后连续10次出栈
栈的大小为： 15
栈为空吗？： false
栈顶元素为： 14