[剑指offer] 队列&栈篇

JZ9 用两个栈实现队列

/* 模拟入队 */
public class JZ9_1
{
    public static Stack<Integer> stack1 = new Stack<Integer>();
    public static Stack<Integer> stack2 = new Stack<Integer>();

    public static void push(int node)
    {
        if (stack1.isEmpty())
        {
            while (!stack2.isEmpty())
                stack1.push(stack2.pop());
            stack2.push(node);
            while (!stack1.isEmpty())
                stack2.push(stack1.pop());
        }
    }

    public static int pop()
    {
        return stack2.pop();
    }
}

/* ⭐模拟出队⭐ */
public class JZ9_2
{
    public static Stack<Integer> stack1 = new Stack<Integer>();
    public static Stack<Integer> stack2 = new Stack<Integer>();

    public static void push(int node)
    {
        stack1.push(node);
    }

    public static int pop()
    {
        if (stack2.empty())
            while (!stack1.empty())
                stack2.push(stack1.pop());
        return stack2.pop();
    }
}

JZ30 包含min函数的栈⭐

/*
* stack: 正常保存每一个入栈的数字
* minStack: 当数字入栈后，保存栈当前状态最小的数
* */
public class JZ30_1
{
    public static Stack<Integer> stack = new Stack<>();
    public static Stack<Integer> minStack = new Stack<>();

    public static void push(int node)
    {
        stack.push(node);
        if (minStack.isEmpty() || node < minStack.peek())
            minStack.push(node);
        else
            minStack.push(minStack.peek());
    }

    public static void pop()
    {
        stack.pop();
        minStack.pop();
    }

    public static int top()
    {
        return stack.peek();
    }

    public static int min()
    {
        return minStack.peek();
    }
}

/*
 * stack: 正常保存每一个入栈的数字
 * minStack: 最小元素每一次都进栈，造成重复，所以可以优化成只有当进栈元素≤目前最小元素时，进栈元素才放入最小栈
 * */
public class JZ30_2
{
    public static Stack<Integer> stack = new Stack<>();
    public static Stack<Integer> minStack = new Stack<>();

    public static void push(int node)
    {
        stack.push(node);
        if (minStack.isEmpty() || node <= minStack.peek())
            minStack.push(node);
    }

    public static void pop()
    {
        if (stack.peek() <= minStack.peek())
            minStack.pop();
        stack.pop();
    }

    public static int top()
    {
        return stack.peek();
    }

    public static int min()
    {
        return minStack.peek();
    }
}

JZ31 栈的压入、弹出序列

/* 辅助栈 */
public class JZ31_1
{
    public static boolean IsPopOrder(int[] pushV, int[] popV)
    {
        Stack<Integer> sta = new Stack<>();
        int idx = 0;
        for (int i = 0; i < popV.length; i++)
        {
            while (sta.isEmpty() || sta.peek() != popV[i])
            {
                if (idx == pushV.length) return false;
                sta.push(pushV[idx++]);
            }
            sta.pop();
        }
        return sta.isEmpty();
    }
}

/* ⭐原地栈⭐ */
public class JZ31_2
{
    public static boolean IsPopOrder(int[] pushV, int[] popV)
    {
        int stackTop = -1, idx = 0;
        for (int i = 0; i < pushV.length; i++)
        {
            pushV[++stackTop] = pushV[i];
            while (stackTop >= 0 && pushV[stackTop] == popV[idx])
            {
                idx++;
                stackTop--;
            }
        }
        return idx == popV.length;
    }
}

JZ73 翻转单词序列

/* 字符串翻转 */
public class JZ73_1
{
    public static String ReverseSentence(String str)
    {
        StringBuilder res = new StringBuilder();
        String[] s = str.split(" ");
        for (int i = s.length - 1; i >= 0; i--)
            res.append(s[i] + (i != 0 ? " " : ""));
        return new String(res);
    }
}

/* 滑动窗口 */
public class JZ73_2
{
    public static String ReverseSentence(String str)
    {
        int left = 0, right = 0;
        StringBuilder res = new StringBuilder();
        StringBuilder rev_str = new StringBuilder(str).reverse();
        while (true)
        {
            if (right == rev_str.length() || rev_str.charAt(right) == ' ')
            {
                res.append(new StringBuilder(rev_str.substring(left, right)).reverse());
                left = right + 1;
                if (right == rev_str.length())
                    break;
                res.append(" ");
            }
            right++;
        }
        return res.toString();
    }
}

/* 栈 */
public class JZ73_3
{
    public static String ReverseSentence(String str)
    {
        Stack<String> sta = new Stack<String>();
        StringBuilder res = new StringBuilder();
        String[] temp = str.split(" ");
        for (int i = 0; i < temp.length; i++)
            sta.push(temp[i] + (i == 0 ? "" : " "));
        while (!sta.isEmpty())
            res.append(sta.pop());
        return res.toString();
    }
}

JZ59 滑动窗口的最大值⭐

/* 单调队列 */
public class JZ59_1
{
    public static ArrayList<Integer> maxInWindows(int[] num, int size)
    {
        ArrayList<Integer> res = new ArrayList<>();
        Deque<Integer> deque = new LinkedList<>();
        if (size == 0) return res;
        for (int i = 0; i < num.length; i++)
        {
            while (!deque.isEmpty() && num[deque.getLast()] < num[i])
                deque.removeLast();
            deque.addLast(i);
            if (i - deque.getFirst() >= size) deque.removeFirst();
            if (i >= size - 1) res.add(num[deque.getFirst()]);
        }
        return res;
    }
}