数据结构和算法三-栈的简单实现

1 栈的简单介绍

栈是一种先进后出的数据结构，主要的api如下
pop：弹栈，返回并弹出栈顶元素
push：压栈，往栈里添加元素
peek：返回栈顶元素

2 通过链表实现栈

public class LinkedStack<T> implements Iterable<T>, Stack<T> {

    /**
     * 定义一个指向栈顶的引用
     */
    private Node<T> top;

    private Integer size = 0;

    @Override
    public void push(T t) {
        // 新建一个节点指向top，新top的next指向old top
        Node<T> oldTop = top;
        top = new Node<>(t);
        top.next = oldTop;
        size ++;
    }

    @Override
    public T peek() {
        return Objects.nonNull(top)? top.data: null;
    }

    @Override
    public T pop() {
        T t = null;
        if(Objects.nonNull(top)) {
            // 获取top数据，然后top向后移
            t = top.data;
            top = top.next;
            size --;
        }
        return t;
    }


    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private Node<T> current = top;

            @Override
            public boolean hasNext() {
                return current != null;
            }

            @Override
            public T next() {
                T t = null;
                if(Objects.nonNull(current)) {
                    t = current.data;
                    current = current.next;
                }
                return t;
            }
        };
    }

    private class Node<T> {
        T data;

        Node<T> next;

        public Node(T data) {
            this.data = data;
        }
    }

    @Test
    public void testLinkedStack() {
        LinkedStack<Integer> linkedStack = new LinkedStack<>();
        for (int i = 0; i < 10; i++) {
            linkedStack.push(i);
        }

        Iterator iterator = linkedStack.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(linkedStack.pop());
        }
    }
}

3 通过数组实现栈，可动态调整数组大小

public class ResizingArrayStack<T> implements Iterable<T>, Stack<T> {

    /**
     * 初始化一个容量为1的数组
     */
    private Object[] objs = new Object[1];

    private Integer size = 0;

    @Override
    public void push(T t) {
        if (Objects.isNull(t)) {
            throw new NullPointerException();
        }
        if (size >= objs.length) {
            // 扩容
            resize(objs.length * 2);
        }
        // size使用后+1
        objs[size ++] = t;
    }

    @Override
    public T pop() {
        if (size > 0) {
            Object object = objs[--size];
            // gc
            objs[size] = null;
            if (size < objs.length / 2) {
                // 缩容
                resize(objs.length / 2);
            }
            return (T) object;
        }
        return null;
    }

    @Override
    public T peek() {
        if (size > 0) {
            return (T) objs[size - 1];
        }
        return null;
    }

    private void resize(int max) {
        Object[] temps = new Object[max];
        System.arraycopy(objs, 0, temps, 0, size);
        objs = temps;
    }

    public Integer capecity() {
        return objs.length;
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private Integer n = size;

            @Override
            public boolean hasNext() {
                return n > 0;
            }

            @Override
            public T next() {
                return (T) objs[--n];
            }
        };
    }

    @Override
    public void forEach(Consumer<? super T> action) {

    }

    @Override
    public Spliterator<T> spliterator() {
        return null;
    }

    public Boolean isEmpty() {
        return size == 0;
    }

    @Test
    public void testResizingArrayStack() {
        ResizingArrayStack resizingArrayStack = new ResizingArrayStack();
        for (int i = 0; i < 10; i++) {
            resizingArrayStack.push(i);
            System.out.println(i + "->" + resizingArrayStack.capecity());
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(resizingArrayStack.pop() + "->" + resizingArrayStack.capecity());
        }
    }

    @Override
    public String toString() {
        return "ResizingArrayStack{" +
                "objs=" + Arrays.toString(objs) +
                '}';
    }
}

输出：
0->1
1->2
2->4
3->4
4->8
5->8
6->8
7->8
8->16
9->16
9->16
8->16
7->8
6->8
5->8
4->8
3->4
2->4
1->2
0->1