java 实现栈的顺序存储和链式存储

一、栈的顺序存储，也就是使用数组存储：

注意事项：（用红色字体表示）

1.构造器必须要给数组进行初始化，即分配内存

2.数组初始化后的元素类型为Object，取出该元素的时候必须要进行强制转换，即向下转换类型。

 

/**
* 基于数组实现的顺序栈
* @param <E>
*/
public class Stack<E>{
    private Object[] data = null;     //由于不知道数组存储的类型，只能设置为Object类型
    private int maxSize = 0;          //栈容量
    private int top = -1;             //栈顶指针(从-1开始计起)

    public Stack(){
        this.maxSize = 10;      //默认栈大小为10

       data = new Object[maxSize];    

    }

    /**
     * 初始化时指定数组长度
     * @param initialSize
     */
    public Stack(int initialSize){
        if (initialSize > 0){
            this.maxSize = initialSize;
            data = new Object[initialSize];
        }
    }

    /**
     * 判断栈是否为空
     * @return
     */
    public boolean empty(){
//        if (top == -1){
//            return true;
//        }
//        return false;
        return top==-1? true: false;
    }

    /**
     * 进栈
     * @param e
     */
    public void push(E e){
        if (top == maxSize-1){
            System.out.println("该栈已满");
            return;
        }
        top ++;
        data[top] = e;
    }

    /**
     * 出栈
     * @return
     */
    public E pop(){
        if (top == -1){
           throw new RuntimeException("栈为空");
        }
        E e = (E)data[top];     //将元素类型进行转换
        top--;
        return e;
    }

    public static void main(String[] args){
        Stack<Integer> s1 = new Stack<>(10);
        System.out.println("该栈是否为空:" + s1.empty());

        s1.push(5);
        s1.push(0);
        s1.push(8);
        s1.push(3);
        s1.push(2);
        s1.push(1);
        System.out.println("出栈的元素依次是:");
        while (! s1.empty()){
            System.out.println(s1.pop());
        }
    }
}

 

二、栈的链式存储，即单链表

注意事项：（也用青色字体表示）

1.这里使用了内部类，也可以将其摘取出来，单独形成一个类，但是要注意泛型的使用方法和范围;

2.就是关于Node类中的构造器，这个构造器的作用就是传入一个新的节点，并将其作为本节点所指向的节点，即本节点初始化的时候，就可以指定“我”要所指的对象是谁。这个功能是很重要的，因为在实现进栈的时候，就可以在每次添加新元素的时候将top指针作为本节点的下一个元素，从而实现了栈顶添加元素。

/**
*  栈的链式存储
* @param <E>
*/
public class LinkStack <E>{
    private class Node<E>{
        E data;
        Node<E> next;

        public Node(E data, Node next){
            this.data = data;
            this.next = next;
        }
    }

    private Node<E> top;    //栈顶元素
    private int size = 0;             //当前栈大小

    public LinkStack(){
        this.top = null;
    }

    /**
     * 判断栈是否为空
     * @return
     */
    public boolean empty(){
        if (top == null){
            return true;
        }
        return false;
    }

    /**
     * 入栈
     * @param e
     */
    public void push(E e){
        top = new Node(e, top);     //  添加一个新元素时，直接将其放在top上面，然后将top往上移动一个
        size ++;
     }

    /**
     * 出栈
     * @return
     */
    public E pop(){
        if (empty()){
            throw new RuntimeException("空栈异常");
        }
        Node<E> value = top;
        E e = top.data;
        top = value.next;
        value = null;       //释放原栈顶元素
        size --;
        return e;
     }

     public int stackLength(){
        return size;
     }

     public  static  void main(String[] args){
        LinkStack<Integer> ls = new LinkStack<>();
         System.out.println("该栈是否为空:" + ls.empty());

         ls.push(5);
         ls.push(0);
         ls.push(8);
         ls.push(3);
         ls.push(2);
         ls.push(1);
         System.out.println("该栈是否为空:" + ls.empty());
         System.out.println("出栈的元素依次是:");
         while (! ls.empty()){
             System.out.println(ls.pop());
         }
     }
}