栈和队列基础训练(一)

题目一：

　　请设计一个栈，除pop与push方法，还支持min方法，可返回栈元素中的最小值。push、pop和min三个方法的时间复杂度必须为O(1)。

　　思路：题目要求时间复杂度为O(1)，所以肯定不能用循环遍历的方式去解决，于是我们想到用空间换时间的方式去解决，如果我们已经维护好一个已经排好序的栈的话，那么min方法直接返回当前的栈顶元素就好了。于是我们可以定义另一个栈，然后用push方法和pop方法去维护这个栈。另一个栈的栈顶始终存的是在当前状态下最小的元素，如果再来一个数据小于另一个栈的栈顶，那么两个栈同时压入这个数。否则只是原栈压入，而另一个栈还是重复压入当前最小的数据。另外pop的时候两个栈需要同时弹出。

　　注意：代码中找不到的类前面的博客都有介绍，这里就没有重复写了。

import java.util.EmptyStackException;

public class StackWithMin extends DoubleLinkedList<Integer> implements IStack<Integer> {
    @Override
    public void push(Integer e) {
        super.add(e);
        if (brother.empty()) {
            brother.push(e);
        } else {
            Integer peek = brother.peek();
            if (e < peek) {
                brother.push(e);
            } else {
                brother.push(peek);
            }
        }
    }

    @Override
    public Integer pop() {
        if (size <= 0)
            throw new EmptyStackException();
        ListNode<Integer> the = super.last.getPre();
        Integer res = the.getData();

        the.getPre().setNext(last);
        last.setPre(the.getPre());
        the.setNext(null);
        the.setPre(null);
        size--;
        brother.pop();
        return res;
    }

    @Override
    public boolean empty() {
        return getSize() == 0;
    }

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

    @Override
    public Integer peek() {
        return last.getPre().getData();
    }

    private MyStack<Integer> brother = new MyStack<>();

    public int min() throws Exception {
        // ListNode<T> h = first.getNext();
        // int min = -1;
        // while(h!=last){
        // if ((int)(h.getData())<min){
        // min = (int)(h.getData());
        // }
        // }
        // return min;
        if (!brother.empty())
            return brother.peek();
        else
            throw new Exception("没有元素了");
    }

    public static void main(String[] args) throws Exception {
        StackWithMin stack = new StackWithMin();
        stack.push(2);
        stack.push(9);
        stack.push(3);
        stack.push(1);
        stack.push(5);

        System.out.println(stack.min());  // 输出1
    }
}

　　我们可以发现另一个栈里面重复的元素太多，也是可以继续优化的，就是在上面的基础上，做些简单的判断即可，就是如果再来的数据如果大于另一个栈的栈顶元素，那么另一个栈就不重复压入当前最小的数据了。而这里pop的时候两个栈的栈顶就不需要同时弹出了，需要做大小判断然后根据大小弹出哪个栈的栈顶元素。

题目二：　　

　　请实现一种数据结构SetOfStacks，由多个栈组成，其中每个栈的大小为size，当前一个栈填满时，新建一个栈。该数据结构应支持与普通栈相同的push和pop操作。

　　给定一个操作序列int[][2] ope，每个操作的第一个数代表操作类型，若为1，则为push操作，后一个数为应push的数字；若为2，则为pop操作，后一个数无意义。请返回一个int[][]，为完成所有操作后的SetOfStacks，顺序应为从下到上，默认初始的SetOfStacks为空。保证数据合法。这道题目是作为面试题目，所以只有思路，没有结果。

　　思路：这道题目很简单，但是这里有一个知识点需要注意，这道题目本身不知道size大小，所以必须使用ArrayList去实现，所以这里需要掌握的点就是二维动态数组的建立以及使用动态数组模拟栈的行为。

import java.util.ArrayList;

public class SetOfStacks {
    public ArrayList<ArrayList<Integer>> setOfStacks(int[][] ope, int size) {
        // 动态的二维数组
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> currStack = new ArrayList<Integer>(size);// 正在操作的栈
        res.add(currStack);
        for (int[] opAndValue : ope) {
            int op = opAndValue[0];
            int value = opAndValue[1];

            if (op == 1) {
                if (currStack.size() == size) { // 当前满
                    currStack = new ArrayList<Integer>(size);// 创建一个新的栈
                    res.add(currStack);
                }
                currStack.add(value);
            } else {// 出栈
                if (currStack.size() == 0) {
                    res.remove(currStack);// 栈的列表中移除
                    currStack = res.get(res.size() - 1);// 被操作的栈是列表中的上一个栈
                }
                currStack.remove(currStack.size() - 1);
            }
        }
        return res;
    }
}

题目三：

　　实现一个MyQueue类，该类用两个栈来实现一个队列。

　　思路：该题最原始的想法呢就是把另一个栈作为缓冲区，在入栈的时候直接压入堆栈即可，在弹出堆栈的时候把第一个堆栈的元素全部压入到第二个堆栈中然后弹出第二个堆栈的栈顶元素这样就完成了队列先进先出的要求，然后再把第二个堆栈的元素重新移到第一个堆栈中。但是这个思路如果重复出栈或者入栈的话就会导致频繁的移动元素操作，增加了不必要的开销。下面给出优化过后的代码。

import java.util.Stack;

public class QueueByTwoStack {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

    public void enqueue(int node) {
        if (stack1.isEmpty()) {
            move(stack2, stack1);
        }
        stack1.push(node);
    }

    public int dequeue() {
        if (stack2.isEmpty())
            move(stack1, stack2);
        int result = stack2.pop();

        return result;
    }

    private void move(Stack source, Stack target) {
        while (!source.empty()) {
            target.push(source.pop());
        }
    }

    public static void main(String[] args) {
        QueueByTwoStack obj = new QueueByTwoStack();
        obj.enqueue(1);
        obj.enqueue(2);
        System.out.println(obj.dequeue());// 1
        obj.enqueue(3);

        System.out.println(obj.dequeue());// 2
        obj.enqueue(4);
        System.out.println(obj.dequeue());// 3
        System.out.println(obj.dequeue());// 4
        obj.enqueue(5);
        System.out.println(obj.dequeue());// 5

    }
}