八、数组模拟栈(扩容)/求栈中的最小值/栈实现队列/队列实现栈

数组模拟栈

public static class ArrayStack {
	private Integer[] arr;
	private Integer size;

	public ArrayStack(int initSize) {
		if (initSize < 0) {
			throw new IllegalArgumentException("The init size is less than 0");
		}
		arr = new Integer[initSize];
		size = 0;
	}

	public Integer peek() {
		if (size == 0) {
			return null;
		}
		return arr[size - 1];
	}

	public void push(int num) {
		if (size == arr.length) {
			throw new ArrayIndexOutOfBoundsException("The queue is full");
		}
		arr[size++] = num;
	}

	public Integer pop() {
		if (size == 0) {
			throw new ArrayIndexOutOfBoundsException("The queue is empty");
		}
		return arr[--size];
	}
}

数组模拟栈(自动扩容)

public class MyStack {
    public static void main(String[] args) {
        MyStack stack = new MyStack(3);
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.size());
    }
    private int[] storage;  //存放栈中元素的数组
    private int capacity;   //栈的容量
    private int count;      //栈中元素数量
    private static final int GROW_FACTOR = 2; //扩容因子

    //TODO：不带初始容量的构造方法，默认容量为8
    public MyStack() {
        this.capacity = 8;
        this.storage=new int[8];
        this.count = 0;
    }

    //TODO：带初始容量的构造方法
    public MyStack(int initialCapacity) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException("Capacity too small.");
        this.capacity = initialCapacity;
        this.storage = new int[initialCapacity];
        this.count = 0;
    }

    //TODO：入栈
    public void push(int value) {
        if (count == capacity) {
            ensureCapacity();
        }
        storage[count++] = value;
    }

    //TODO：扩容
    private void ensureCapacity() {
        // 扩容的容量
        int newCapacity = capacity * GROW_FACTOR;
        // 扩容后的数组，大小是原来的两倍，保留原数组中元素
        storage = Arrays.copyOf(storage, newCapacity);
        // 更新容量
        capacity = newCapacity;
    }

    //TODO：返回栈顶元素并出栈
    private int pop() {
        count--;
        if (count == -1)
            throw new IllegalArgumentException("Stack is empty.");

        return storage[count];
    }

    //TODO：返回栈顶元素不出栈
    private int peek() {
        if (count == 0){
            throw new IllegalArgumentException("Stack is empty.");
        }else {
            return storage[count-1];
        }
    }

    //TODO：判断栈是否为空
    private boolean isEmpty() {
        return count == 0;
    }

    //TODO：返回栈中元素的个数
    private int size() {
        return count;
    }
}

返回栈中的最小元素

public static class MyStack1 {
	private Stack<Integer> stackData;
	private Stack<Integer> stackMin;

	public MyStack1() {
           //放真实数据的栈
           this.stackData = new Stack<>();
           // 存放最小值的栈
           this.stackMin = new Stack<>();
	}

       public void push(int newNum) {
           // 如果min栈为空，则放入当前数
           if (this.stackMin.isEmpty()) {
               this.stackMin.push(newNum);
           } else if (newNum < this.getMin()) {
               // 如果当前数比min栈栈顶元素小，压入当前数
               this.stackMin.push(newNum);
           } else {
               // 否则min的栈顶更小，重复压入栈顶元素
               int newMin = this.stackMin.peek();
               this.stackMin.push(newMin);
           }
           // 压入data栈
           this.stackData.push(newNum);
       }

       public int pop() {
           if (this.stackData.isEmpty()) {
               throw new RuntimeException("Your stack is empty.");
           }
           this.stackMin.pop();
           return this.stackData.pop();
       }
       /**
        * 返回min栈的栈顶元素
        * @return
        */
       public int getMin() {
           if (this.stackMin.isEmpty()) {
               throw new RuntimeException("Your stack is empty.");
           }
           return this.stackMin.peek();
       }
}

栈实现一个队列

/**
 * 两个栈实现一个队列
 */
public static class TwoStacksQueue {
    private Stack<Integer> stackPush;
    private Stack<Integer> stackPop;

    public TwoStacksQueue() {
        stackPush = new Stack<>();
        stackPop = new Stack<>();
    }

    /**
     * 入队列
     * @param pushInt
     */
    public void push(int pushInt) {
        stackPush.push(pushInt);
    }

    /**
     * 出队列
     * @return
     */
    public int poll() {
        if (stackPop.empty() && stackPush.empty()) {
            throw new RuntimeException("Queue is empty!");
        } else if (stackPop.empty()) {
            // 如果pop栈为空，将push栈元素全部倒入pop栈，直到push栈为空
            while (!stackPush.empty()) {
                stackPop.push(stackPush.pop());
            }
        }
        // 从pop栈弹出一个就是最先进入push栈的元素
        return stackPop.pop();
    }

    /**
     * 返回队列头
     * @return
     */
    public int peek() {
        if (stackPop.empty() && stackPush.empty()) {
            throw new RuntimeException("Queue is empty!");
        } else if (stackPop.empty()) {
            while (!stackPush.empty()) {
                stackPop.push(stackPush.pop());
            }
        }
        return stackPop.peek();
    }
}

队列实现栈

/**
 * 两个队列实现栈
 */
public static class TwoQueuesStack {
    private Queue<Integer> dataQueue;
    private Queue<Integer> helpQueue;

    public TwoQueuesStack() {
        dataQueue = new LinkedList<>();
        helpQueue = new LinkedList<>();
    }

    /**
     * 入栈，都加入到data队列里
     * @param pushInt
     */
    public void push(int pushInt) {
        dataQueue.add(pushInt);
    }

    /**
     * 返回栈顶元素，数据总数不变
     * @return
     */
    public int peek() {
        if (dataQueue.isEmpty()) {
            throw new RuntimeException("Stack is empty!");
        }
        while (dataQueue.size() != 1) {
            //data队列中除了最后一个加入的元素外，其他元素都加入到help队列
            helpQueue.add(dataQueue.poll());
        }
        // 取出最后一个加入data队列的元素
        int res = dataQueue.poll();
        // 将该元素也加入到help队列
        helpQueue.add(res);
        // 交换引用
        swap();
        return res;
    }

    /**
     * 出栈
     * @return
     */
    public int pop() {
        if (dataQueue.isEmpty()) {
            throw new RuntimeException("Stack is empty!");
        }
        // 当data队列的元素大于1时,将data队列中的元素放入到help队列
        while (dataQueue.size() > 1) {
            helpQueue.add(dataQueue.poll());
        }
        // data队列中只剩一个元素时，上面操作停止，取出最后一个元素，就是最后加入的元素
        int res = dataQueue.poll();
        // 此时data队列为空，help队列存放最先加入的数据到倒数第二次加入的数据，交换引用
        swap();
        return res;
    }

    private void swap() {
        Queue<Integer> tmp = helpQueue;
        helpQueue = dataQueue;
        dataQueue = tmp;
    }
}