我用Java学数据结构之栈底层实现

栈和队列在很多地方都有应用，比如非递归前序遍历二叉树，还有做题的时候会经常用到

 首先定义栈的接口，与java内置的栈接口相同，依然使用泛型实现

public interface Stack<E> {
    int getSize();

    boolean isEmpty();

    void push(E e);

    E pop();

    E peek();
}

这里的栈的底层使用的是之前实现的动态数组，之前的动态数组的addLast与removeLast以及get操作就可以直接在这里使用，后续还会有基于链表的栈

import DynamicArray.Array;

public class ArrayStack<E> implements Stack<E> {
    Array<E> array;

    public ArrayStack(int capacity) {
        array = new Array<E>(capacity);
    }

    /**
     * 使用动态数组做为底层实现
     */
    public ArrayStack() {
        array = new Array<E>();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public void push(E e) {
        array.addLast(e);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.getLast();
    }

    public int getCapacity() {
        return array.getCapacity();
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder();
        result.append("Stack : [");
        for (int i = 0; i < array.getSize(); i++) {
            result.append(array.get(i));
            if (i != array.getSize() - 1) {
                result.append(", ");
            }
        }
        result.append("] top");
        return result.toString();
    }
}

最后当然得测试下栈的性能：

public class Main {
    private static double testStack(Stack<Integer> stack, int opCount) {
        long startTime = System.nanoTime();
        for (int i = 0; i < opCount; i++) {
            stack.push(i);
        }
        for (int i = 0; i < opCount; i++) {
            stack.pop();
        }

        Long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;
        ArrayStack<Integer> arrayStack = new ArrayStack<Integer>();
        System.out.println("ArrayListStack Time : " + testStack(arrayStack, opCount) + "  s ");

        LinkedStack<Integer> linkedStack = new LinkedStack<Integer>();
        System.out.println("LinkedListStack Time : " + testStack(linkedStack, opCount) + "  s ");

    }
}

在存取十万个数据的情况下，数组栈的性能和链栈的性能相差无几