java_stack

栈是一种数据结构，它代表只能在某一端进行插入、删除操作的特殊线性表。

栈的最大特点是是后进先出（First In Last Out），对栈的操作主要是入栈和出栈，判断栈是否为空，计算栈的大小。

对栈而言，允许插入删除的一端是栈顶，另一端则称为栈底。

实际应用：表达式求值和语法解析，校验和解析XML，文本编辑器里的撤销动作，浏览器里的浏览记录

栈的顺序存储实现：(基于数组实现)

package collectionsFramework.stack;



/** 

 * @Package collectionsFramework.stack



 * @ClassName: SequenceStack



 * @Description: TODO(这里用一句话描述这个类的作用)



 * @author andy



 * @date 2013-11-22 下午04:03:14



 */

public class SequenceStack<T>{

    //栈里面的元素个数

    private int size = 0;

    //栈的默认容量大小

    private int defaultCapacity = 10;

    //栈的容量

    private int capacity;

    //容纳栈的数组

    private Object[] elementData;

    //栈满了之后,增量大小

    private int incrementCapacity; 

    

    //默认大小的空堆栈

    public SequenceStack(){

        capacity = defaultCapacity;

        elementData = new Object[capacity];

    }

    

    //指定容量大小的空堆栈

    public SequenceStack(int capacity){

        elementData = new Object[this.capacity];

    }

    

    //指定容量大小和增量大小的空堆栈

    public SequenceStack(int capacity,int incrementCapacity){

        this(capacity);

        this.incrementCapacity = incrementCapacity;

    }

    

    //保证空间足够

    private void ensureCapacity() throws Exception{

        if(elementData.length == size){

            Object[] copyElementData = elementData;

            

            int length = 0;

            if(incrementCapacity > 0){

                length = copyElementData.length + incrementCapacity;

            }else{

                length = copyElementData.length<<1;

            }

            elementData  = new Object[length];

            try {

                System.arraycopy(copyElementData, 0, elementData, 0, elementData.length-1);

            } catch (Exception e) {

                throw new Exception("扩充数组时出现系统错误!");

            }

        }

    }

    

    //入栈

    public synchronized T push(T object){

        boolean flag = true;

        if(null != object){

            try {

                ensureCapacity();

            } catch (Exception e) {

                try {

                    ensureCapacity();

                } catch (Exception e1) {

                    System.out.println("第二次扩容再次失败！");

                    flag = false;

                }

            }

            if(flag){

                elementData[size++] = object;

                return object;

            }else{

                return null;

            }

        }

        

        return null;

    }

    

    //出栈

    public synchronized T pop(){

        if(size == 0){

            throw new RuntimeException("空栈");

        }

        return (T)elementData[--size];

    }

    

    //获取栈顶元素但不移除

    public synchronized T peek(){

        if(size  == 0){

            throw new RuntimeException("空栈");

        }

        return (T)elementData[size-1];

    }

    

    //获取元素个数

    public synchronized int size(){

        return size;

    }

    

    //堆栈是否为空

    public boolean empty() {

        return size() == 0;

    }

    

    public static void main(String[] args) {

        SequenceStack<String> stack = new SequenceStack<String>();

        System.out.println("元素" + stack.push("a") + "入栈");

        System.out.println("元素" + stack.push("b") + "入栈");

        System.out.println("元素" + stack.push("c") + "入栈");

        System.out.println("元素" + stack.push("d") + "入栈");

        System.out.println("元素" + stack.push("e") + "入栈");

        

        System.out.println("-----------");

        System.out.println("栈顶元素：" + stack.peek());

        System.out.println("元素个数：" + stack.size());

        System.out.println("-----------");

        while(stack.size > 0){

            System.out.println("元素" + stack.pop() + "出栈");

        }

        

    }

}

 

栈的链式存储实现：（保存本节点数据，并保存对下一个结点的引用即指针）跟单链表差不多

 

package collectionsFramework.stack;



/**

 * @Package collectionsFramework.stack

 * 

 * @ClassName: LinkStack

 * 

 * @Description: TODO(这里用一句话描述这个类的作用)

 * 

 * @author andy

 * 

 * @date 2013-11-22 下午05:58:55

 */

public class LinkStack<T> {

    // 节点

    private class Node {

        // 保存本节点数据

        private T data;

        // 指向下个节点的引用

        private Node next;

        

        public Node() {



        }

        public Node(T data, Node next) {

            this.data = data;

            this.next = next;

        }

    }

    

    //栈顶元素

    private Node top;

    //节点数

    private int size;

    

    //创建空链栈

    public LinkStack(){

        top = null;        

    }

    

    //以指定数据元素来创建链栈，该链栈只有一个元素  

    public LinkStack(T element){

        top = new Node(element, null);

        size++;

    }

    

     //进栈 

    public synchronized T push(T element) {

        if(size==0){

            top = new Node(element,null);

        }else{

            Node oldTop = top;

            top = new Node(element,oldTop);

        }

        

        size++;

        return top.data;

    }

    

    //出栈 

    public synchronized T pop() {

        if(!empty()){

            Node oldTop = top;

            top = oldTop.next;

            oldTop.next = null;

            size--;

            return oldTop.data;

        }

        return null;

    }

    

    //访问栈顶元素，但不删除栈顶元素 

    public synchronized T peek() {

        if(!empty()){

            return top.data;

        }

        return null;

    }



    // 判断链栈是否为空栈

    public boolean empty() {

        return size == 0;

    }



    // 返回链栈的长度

    public synchronized int length() {

        return size;

    }

    

    public static void main(String[] args) {

        LinkStack<Character> stack = new LinkStack<Character>();

        System.out.println("元素：" + stack.push('a') + "进栈");

        System.out.println("元素：" + stack.push('b') + "进栈");

        System.out.println("元素：" + stack.push('c') + "进栈");

        System.out.println("元素：" + stack.push('d') + "进栈");

        System.out.println("元素：" + stack.push('e') + "进栈");

        

        System.out.println("-------");

        System.out.println("栈顶元素：" + stack.peek());

        System.out.println("-------");

        while(stack.size >0){

            System.out.println("元素:" + stack.pop() + "出栈");

        }

    }



}