栈的链式和数组存储实现

栈的链式存储实现代码：

public class LinkStack<E> {
    //定义一个内部类Node，Node实例代表链栈的节点
    private class Node{
        private E data;
        private Node next;
        public Node(){
        }
        public Node(E data, Node next) { 
            this.data = data;
            this.next = next;
        }
    }
    //栈顶元素，为链表的第一个节点
    private Node top;
    private int size;
    //创建空的链栈
    public LinkStack(){
        top=null;
    }
    //以指定元素来创建链栈，该链栈只有一个元素
    public LinkStack(E element){
        top=new Node(element,null);
        size++;
    }
    //返回链栈的长度
    public int length(){
        return size;
    }
    //入栈
    public void push(E element){
        //让top指向新创建的元素，新元素top的next指针指向原来的栈顶元素top
        top=new Node(element,top);
        size++;
    }
    //出栈
    public E pop(){
        //新建一个节点来暂存出栈的栈顶元素top
        Node oldTop=top;
        //设置出栈后新的栈顶，即为top.next
        top=top.next;
        //释放出栈的栈顶的存储空间
        oldTop.next=null;
        size--;
        return oldTop.data;
    }
    //返回栈顶元素，但不删除栈顶元素
    public E peek(){
        return top.data;
    }
    //判断栈是否为空
    public boolean empty(){
        return size==0;
    }
    //清空链栈
    public void clear(){
        top=null;
        size=0;
    }
    public String toString(){
        if(empty()){
            return "[]";
        }else{
            StringBuilder sb=new StringBuilder("[");
            for(Node current=top;current!=null;current=current.next){
                sb.append(current.data.toString()+",");
            }

            int len=sb.length();
            return sb.delete(len-1, len).append("]").toString();
        }
    }
    public static void main(String[] args) {
        LinkStack<String> stack=new LinkStack<String>();
        stack.push("aaaa");
        stack.push("bbbb");
        stack.push("cccc");
        stack.push("dddd");
        stack.push("eeee");
        System.out.println("当前的栈为："+stack);
        System.out.println("返回当前栈顶元素top："+stack.peek());
        System.out.println("当前栈的长度为："+stack.length());
        stack.pop();
        System.out.println("当前的栈为："+stack);
        System.out.println("当前栈的长度为："+stack.length());
    }
}

栈的数组实现代码：

import java.util.Arrays;


public class ArrayStack<E> {
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //存储栈元素的数组
    protected Object[] elementData;
    //数组元素个数
    protected int elementCount;
    //当存储栈的数组内存不足时，拓展数组大小的增量
    protected int capacityIncrement;
    //创建一个空栈
    public ArrayStack(){
    }
    //根据指定的容器大小和容器扩展增量来创建一个空栈
    public ArrayStack(int initialCapacity,int capacityIncrement){
        if(initialCapacity<0){
            throw new IllegalArgumentException("Illegal Capacity:"+initialCapacity);
        }
        this.elementData=new Object[initialCapacity];
        this.capacityIncrement=capacityIncrement;
    }
    //根据指定的容器大小来创建一个空栈
    public ArrayStack(int initialCapacity){
        this.elementData=new Object[initialCapacity];
    }
    //入栈
    public void push(E element){
        ensureCapacity(elementCount+1);
        elementData[elementCount++]=element;
    }
    //出栈
    public E pop(){
        E element;
        int len=size();
        element=peek();
        elementData[elementCount--]=null;
        return element;
    }
    //返回栈的大小
    public int size(){
        return elementCount;
    }
    //返回栈顶元素
    public E peek(){
        return (E) elementData[elementCount-1];
    }
    //判断栈是否为空
    public boolean empty(){
        return elementCount==0;
    }

    private void ensureCapacity(int minCapacity){
        int oldCapacity=elementData.length;
        int newCapacity=oldCapacity+((capacityIncrement>0)?capacityIncrement:oldCapacity);
        //将旧的数组元素copy到新拓展后的数组
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    public String toString(){
        if(empty()){
            return "[]";
        }else{
            StringBuilder sb=new StringBuilder("[");
            for(int i=0;i<elementCount;i++){
                sb.append(elementData[i]+",");
            }

            int len=sb.length();
            return sb.delete(len-1, len).append("]").toString();
        }
    }
    public static void main(String[] args) {
        ArrayStack<String> stack=new ArrayStack<String>(100);
        stack.push("aaaa");
        stack.push("bbbb");
        stack.push("cccc");
        stack.push("dddd");
        stack.push("eeee");
        System.out.println("此时栈为："+stack);
        System.out.println("栈顶元素为："+stack.peek());
        System.out.println("此时栈的大小为："+stack.size());
        stack.pop();
        System.out.println("此时栈为："+stack);
        System.out.println("栈顶元素为："+stack.peek());
        System.out.println("此时栈的大小为："+stack.size());
    }
}