数组和栈与队列

用数组实现固定大小的栈与对列

栈：只在一端进行插入和弹出（先进后出）

public class StackArray {

    private Object[] stack = null;
    private int indexPop = -1;

    public StackArray(int size) {
        this.stack = new Object[size];
    }

    public Object pop() {
        if (indexPop == -1) {
            throw new ArrayIndexOutOfBoundsException("栈为空");
        }
        return stack[indexPop--];

    }

    public void push(Object o) {
        if (indexPop == stack.length - 1) {
            throw new ArrayIndexOutOfBoundsException("栈满");
        }
        stack[++indexPop] = o;
    }

    public Object peek() {
        if (indexPop == -1) {
            throw new ArrayIndexOutOfBoundsException("栈为空");
        }
        return stack[indexPop];
    }

}

队列：一端插入，另一端弹出（先进先出）

设置三个变量，分别表示队头、队尾，队列的大小，再加入元素时，如果列的大小小于数组的长度，就将元素加入到数组中，如果队头等于数组长度，将对头赋值为0。

public class QueueArray<V> {
    private Object[] object = null;
    private int queueHead = 0;
    private int queueEnd = 0;
    private int queueSize = 0;

    public QueueArray(int size) {
        if (size <= 0) {
            throw new ArrayIndexOutOfBoundsException("队列大小不能为" + size);
        }
        this.object = new Object[size];
    }
    
    public boolean addObject(V o) {
        boolean rest = false;
        if (queueSize < object.length) {
            object[queueHead++] = o;
            queueSize++;
            if (queueHead == object.length ) {
                queueHead = 0;
            }
            rest = true;
        } else {
            throw new ArrayIndexOutOfBoundsException("队列已满");
        }
        return rest;
    }

    public V getObject() {

        if (queueSize == 0) {
            throw new ArrayIndexOutOfBoundsException("队列为空");
        }
        Object o = object[queueEnd++];
        if (queueEnd == object.length ) {
            queueEnd = 0;
        }
        queueSize--;
        return (V) o;
    }

    public V getHead(){
        if (queueSize == 0) {
            throw new ArrayIndexOutOfBoundsException("队列为空");
        }

      return (V) object[queueEnd];
    }

}

实现一个特殊功能的栈，在实现站的基本功能的基础上，在实现返回栈中的最小值，时间复杂度O(1)。

创建两个栈，一个用来保存插入的元素，一个用来保存最小值。

public class StackMinNumber {
    private Stack<Integer> stackOne = new Stack();
    private Stack<Integer> stackTwo = new Stack();

    public void addObject(int o) {
        if (stackTwo.isEmpty() || stackTwo.peek() > o) {
            stackTwo.add(o);
        } else {
            stackTwo.add(stackTwo.peek());
        }
        stackOne.add(0);
    }

    public int getmin() {
        return stackTwo.pop();
    }

}

队列如何实现栈（后进先出）

创建两个对列，弹出元素时将一个队列(M)的N-1个元素放入另一个队列(N)，将最后一个元素弹出，然后将然后将N队列中的元素从新放入M队列中。

 

 

栈如何实现队列

创建两个栈，弹出元素时将栈(M)的元素全部放入栈(N)中，然后从栈(N)中弹出一个元素，然后再将栈(N)中的N-1个元素全部放入栈(M)，才可以从新添加一个元素。