Java 实现栈

链式存储结构实现

public class LinkStack<E> {
    //链栈的节点
    private class Node<E>{
        Node<E> next;
        E e;
        public Node(E e,Node<E> next){
            this.e = e;
            this.next = next;
        }
    }
    private Node<E> top;  //栈顶元素
    private int size;   //栈大小

    public LinkStack(){
        top = null;
    }
    
    //判空
    public boolean isEmpty() {
        return size == 0;
    }
    
    //进栈
    public boolean push(E e){
        Node<E> node = new Node(e,null);新节点元素
        node.next = top; //把新节点的next指向栈顶元素
        top = node; //栈顶指向新节点
        size++;
        return true;
    }
    
    //出栈
    public E pop(){
        if(isEmpty())
            throw new NullPointerException("元素为空！");
        else{
            Node<E> data = top; //栈顶元素
            top = top.next; ///top引用指向原栈顶元素的next
            data.next = null; //释放原栈顶元素的next引用
            size--;
            return data.e;
        }
    }
    
    //查看栈顶元素
    public E peek(){
        if(isEmpty())
            throw new NullPointerException("元素为空！");
        return top.e;
    }
    
    //大小
    public int size(){
        return this.size;
    }
    

顺序存储结构实现

import java.util.Arrays;

public class ListStack<E> {
    Object[] stack;
    int size;
    
    public ListStack(){
        stack = new Object[10];
    }
    //判空
    public boolean isEmpty(){
        return size ==0;
    }
    
    //进栈
    public E push(E data){
        if(size >= stack.length){
            int len = stack.length+10;
            stack = Arrays.copyOf(stack,len);
        }
        stack[size++] = data;
        return data;
    }
    
    //出栈
    public E pop(){
        if(isEmpty())
            throw new NullPointerException("元素为空！");
        E data = (E)stack[size-1];
        stack[size-1]=null;
        size--;
        return data;
    } 
     
    //查看栈顶元素
    public E peek(){
        return (E)stack[size-1];
    }

    //大小
    public int length(){
        return size;
    }