java数据结构YZP专栏版-----堆栈

1. 数组实现（Stack Array Implementation）

import java.util.Arrays;

public class Stack<E> {
    private int top = 0;//栈顶指针，总是指向最后一个可插入位置，如果等于array.length，表示栈满
    private Object[] array;//用数组实现
    //构建栈
    public Stack(){
        this.array = new Object[10];//默认栈初始大小10
        System.out.println("栈初始成功！！！初始大小10");
    }
    public Stack(int size){
        this.array = new Object[size];//指定栈大小
        System.out.println("栈初始成功！！！初始大小"+size);
    }

    //栈满
    private boolean isFull(){
        return top==array.length;
    }
    //栈空
    private boolean isEmpty(){
        return top == 0;
    }
    //数组扩容
    private void arrayExtend(){
        array = Arrays.copyOf(array, array.length * 2);
    }

    //入栈
    public void push(E o){
        if(isFull()){//栈满扩容
            arrayExtend();
            System.out.println("栈满扩容");
        }
        array[top] = o;
        top++;
        System.out.println((E)o+"入栈成功");
    }
    //返回栈顶数据，不对栈做操作
    public E peek(){
        if(isEmpty()){
            return null;
        }
        return (E)array[top-1];
    }

    //出栈
    public E pop(){
        if(top == 0){
            throw new RuntimeException("栈已空！！！");
        }
        System.out.print("出栈");
        return (E)array[--top];
    }

    //测试程序
    public static void main(String[] args) {
        Stack<Integer> integerStack = new Stack<>(2);
        integerStack.push(1);
        integerStack.push(2);
        integerStack.push(3);
        System.out.println(integerStack.pop());
        System.out.println(integerStack.pop());
        System.out.println(integerStack.pop());
        System.out.println(integerStack.pop());
    }
}

2. 链表实现（Linked List Implementation）

public class Stack<E> {
    /**
     * 链表结点
     */
    private static class Node<E> {
        E item;
        Stack.Node<E> prev;

        Node(Node<E> prev, E element) {
            this.item = element;
            this.prev = prev;
        }
    }

    private Node<E> top = null;//栈顶，初始为空

    private final Integer MAXSIZE = 65536;//栈最大为65536

    private Integer size = 6;//当前栈大小，初始为6

    private Integer length = 0;//当前元素个数

    //构建栈
    public Stack(){
        System.out.println("栈初始成功,当前栈没有元素，大小为6");
    }
    public Stack(int size){
        this.size = size;
        System.out.println("栈初始成功,当前栈没有元素，大小为"+size);
    }
    public Stack(E e){//直接构建头结点
        Node<E> eNode = new Node<>(null, e);
        this.length++;
        this.top = eNode;
        System.out.println("栈初始成功！！！当前栈顶元素为："+top.item+",栈大小为6");
    }
    public Stack(E e,int size){//直接构建头结点,指定初始大小
        this.size = size;
        Node<E> eNode = new Node<>(null, e);
        this.top = eNode;
        this.length++;
        System.out.println("栈初始成功！！！当前栈顶元素为："+top.item+",栈大小为"+size);
    }

    //栈满
    private boolean isFull(){
        return length == size;
    }
    //栈空
    private boolean isEmpty(){
        return length == 0;
    }
    //扩容，每次*2
    private void extendStack(){
        if(size == MAXSIZE){
            throw new RuntimeException("栈大小已达上限！！！");
        }
        if(size*2>=MAXSIZE){
            size = MAXSIZE;
        }else if(size*2<MAXSIZE) {
            size *= 2;
        }
    }

    //入栈
    public void push(E e){
        if(isFull()){//栈满扩容
            extendStack();
            System.out.println("栈满扩容");
        }
        if(top == null){
            Node<E> eNode = new Node<>(null, e);
            this.top = eNode;
            this.length++;
        }else{
            Node<E> eNode = new Node<>(top, e);
            this.top = eNode;
            this.length++;
        }
        System.out.println((E)e+"入栈成功");
    }
    //返回栈顶数据，不对栈做操作
    public E peek(){
        if(isEmpty()){
            return null;
        }
        return top.item;
    }

    //出栈
    public E pop(){
        if(isEmpty()){
            throw new RuntimeException("栈已空！！！");
        }
        System.out.print("出栈");
        E item = top.item;
        top = top.prev;
        this.length--;
        return item;
    }

    //测试程序
    public static void main(String[] args) {
        Stack<Integer> integerStack = new Stack<>(2);
        integerStack.push(1);
        integerStack.push(2);
        integerStack.push(3);
        System.out.println(integerStack.pop());
        System.out.println(integerStack.pop());
        System.out.println(integerStack.pop());
        System.out.println(integerStack.pop());
    }
}