算法刷题-二叉树的锯齿形层序遍历、用栈实现队列 栈设计、买卖股票的最佳时机 IV

- [二叉树的锯齿形层序遍历（树、广度优先搜索）](https://cloud.tencent.com/developer)
- [用栈实现队列（栈、设计）](https://cloud.tencent.com/developer)
- [买卖股票的最佳时机 IV（数组、动态规划）](https://cloud.tencent.com/developer)

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> list = new LinkedList<>();
        if (root == null) {
            return list;
        }
        Stack<TreeNode> stack1 = new Stack<>();
        stack1.push(root);
        boolean postive = true;
        while (!stack1.isEmpty()) {
            Stack<TreeNode> stack2 = new Stack<>();
            List<Integer> subList = new LinkedList<>();
            while (!stack1.isEmpty()) {
                TreeNode current = stack1.pop();
                subList.add(current.val);
                if (postive) {
                    if (current.left != null) {
                        stack2.push(current.left);
                    }
                    if (current.right != null) {
                        stack2.push(current.right);
                    }
                } else {
                    if (current.right != null) {
                        stack2.push(current.right);
                    }
                    if (current.left != null) {
                        stack2.push(current.left);
                    }
                }
            }
            postive = !postive;
            stack1 = stack2;
            list.add(subList);
        }
        return list;
    }
}

输入： ["MyQueue", "push", "push", "peek", "pop", "empty"] [[], [1], [2], [], [], []] 输出： [null, null, null, 1, 1, false] 
解释： MyQueue myQueue = new MyQueue(); myQueue.push(1); // queue is: [1] myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue) myQueue.peek(); // return 1 myQueue.pop(); // return 1, queue is [2] myQueue.empty(); // return false

class MyQueue {
    Stack<Integer> s1;
    Stack<Integer> s2;
    /** Initialize your data structure here. */
    public MyQueue() {
        s1 = new Stack<Integer>();
        s2 = new Stack<Integer>();
    }
    /** Push element x to the back of queue. */
    public void push(int x) {
        while (!s1.empty())
            s2.push(s1.pop());
        s1.push(x);
        while (!s2.empty())
            s1.push(s2.pop());
        return;
    }
    /** Removes the element from in front of queue and returns that element. */
    public int pop() {
        return s1.pop();
    }
    /** Get the front element. */
    public int peek() {
        int ret = s1.pop();
        s1.push(ret);
        return ret;
    }
    /** Returns whether the queue is empty. */
    public boolean empty() {
        return s1.empty();
    }
}
/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */

class Solution {
    public int maxProfit(int k, int[] prices) {
        if (k < 1)
            return 0;
        if (k >= prices.length / 2)
            return greedy(prices);
        int[][] t = new int[k][2];
        for (int i = 0; i < k; ++i)
            t[i][0] = Integer.MIN_VALUE;
        for (int p : prices) {
            t[0][0] = Math.max(t[0][0], -p);
            t[0][1] = Math.max(t[0][1], t[0][0] + p);
            for (int i = 1; i < k; ++i) {
                t[i][0] = Math.max(t[i][0], t[i - 1][1] - p);
                t[i][1] = Math.max(t[i][1], t[i][0] + p);
            }
        }
        return t[k - 1][1];
    }
    private int greedy(int[] prices) {
        int max = 0;
        for (int i = 1; i < prices.length; ++i) {
            if (prices[i] > prices[i - 1])
                max += prices[i] - prices[i - 1];
        }
        return max;
    }
}