基础数组实现栈

基础数组实现栈

栈是一种数据结构，就是存储数据的容器。

今天，我们来实现下栈。要实现栈，就是要实现栈的各种方法，包括进栈（push），出栈（pop），查看栈顶元素（peek）等。

用到的底层是数组。包含的方法有增、删、改、查，还有是否为空、容量、元素数量、输出。基本就是这些。

一、实现数组

1.根据索引添加元素

public void add(E e, int index) {
    if (size == data.length) {
        throw new IllegalArgumentException("数组已满");
    }
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("参数异常");
    }
    for (int i = size - 1; i >= index; i--) {
        data[i + 1] = data[i];
    }
    data[index] = e;
    size++;
}

会有数组已满的情况，也会有输入时索引越界的情况，要抛出异常。

添加时，核心思想就是从最后一个元素开始，依次往后“搬”元素，要腾出一个空间，放上元素e。

2.根据索引删除元素

public E remove(int index) {
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("参数不合法");
    }
    E ret = data[index]; //保存待删除元素
    for (int i = index + 1; i < size; i++) {
        data[i - 1] = data[i];
    }
    size--;
    return ret;
}

索引越界抛出异常还是要的。

删除时，核心思想就是从索引处开始依次往前“搬”元素，把索引处的元素覆盖掉。

3.其它操作较简单，源码奉上：

public class Array<E> {
    private E[] data;
    private int size;

    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    public Array() {
        this(10);
    }

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

    public int getSize() {
        return size;
    }

    public int getCapacity() {
        return data.length;
    }

    public void addLast(E e) {
//        if (size == data.length) {
//            throw new IllegalArgumentException("数组已满");
//        }
//        data[size] = e;
//        size++;
        add(e, size);
    }

    public void add(E e, int index) {
        if (size == data.length) {
            throw new IllegalArgumentException("数组已满");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("参数异常");
        }
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }

    public void addFirst(E e) {
        add(e, 0);
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Array:\t" + "size:" + size + "\tcapacity:" + getCapacity());
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(',');
            }
        }
        res.append(']');
        return res.toString();
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("参数不合法");
        }
        return data[index];
    }

    public boolean contain(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

    public void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("参数不合法");
        }
        data[index] = e;
    }

    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("参数不合法");
        }
        E ret = data[index]; //保存待删除元素
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        return ret;
    }

    public E removeFirst() {
        return remove(0);
    }

    public E removeLast() {
        return remove(size - 1);
    }

    public void removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }
}

二、栈的接口

此接口起规范作用。包含了栈的基本操作。

public interface ABCStack<E> {
    void push(E e);
    E pop();//底层用的数组，所以返回类型是E
    E peek();
    boolean isEmpty();
    int getSize();
}

三、实现栈的类

public class ArrayStack<E> implements ABCStack<E> {
    private Array<E> array;

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

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

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

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

    @Override
    public E peek() {
        return array.get(getSize() - 1);
    }

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

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

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

    @Override
    public String toString() {
        return "Stack" + array + "栈顶";
    }
}

基本都是调用基础数组的方法。