剑指编程（5）

一、
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

public class Solution {
    Stack<Integer> stk = new Stack<>();
    public void push(int node) {
        stk.push(node);
    }

    public void pop() {
        stk.pop();
    }

    public int top() {
        return stk.peek();
    }
    //逐个比较，O(n)的复杂度
    public int min() {
        int minNum = Integer.MAX_VALUE;
        for(int i : stk) {
            minNum = Math.min(minNum, i);
        }
        return minNum;
    }
}

二、
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。
假设压入栈的所有数字均不相等。
例如序列1,2,3,4,5是某栈的压入顺序，
序列4,5,3,2,1是该压栈序列对应的一个弹出序列，
但4,3,5,1,2就不可能是该压栈序列的弹出序列。
（注意：这两个序列的长度是相等的）

public class Solution {
    //通过栈模拟实际情况
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if(pushA == null || pushA.length == 0 || popA == null || popA.length == 0) {
            return false;
        }
        Stack<Integer> stk = new Stack<>();
        int pop = 0;
        for(int i = 0; i < pushA.length; i++) {
            stk.push(pushA[i]);
            while(!stk.isEmpty() && stk.peek() == popA[pop]) {
                stk.pop();
                pop++;
            }
        }
        return stk.isEmpty();
    }
}

三、
从上往下打印出二叉树的每个节点，同层节点从左至右打印。

public class Solution {
    //二叉树的层序遍历，可以用队列
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<>();
        if(root == null) {
            return res;
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()) {
            TreeNode cur = q.poll();
            res.add(cur.val);
            if(cur.left != null) {
                q.add(cur.left);
            }
            if(cur.right != null) {
                q.add(cur.right);
            }
        }
        return res;
    }
}

四、
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。
假设输入的数组的任意两个数字都互不相同。

public class Solution {
    /* 后序遍历的特性：
     * 去掉最后一个元素，剩余元素序列可以分为两段后序遍历序列：
     * 一段元素都小于最后一个元素的，
     * 另一段的元素都大于最后一个元素的。
     */
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence == null || sequence.length == 0) {
            return false;
        }
        int pos = sequence.length - 1;
        while(pos >= 0) {
            int index = 0;
            while(sequence[index] < sequence[pos]) {
                index++;
            }
            while(sequence[index] > sequence[pos]) {
                index++;
            }
            if(index < pos) {
                return false;
            }
            pos--;
        }
        return true;
    }
}

五、
输入一颗二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。
路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。

public class Solution {
    //打印路径，可以用深度优先遍历
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        dfs(root, target, res, new ArrayList<Integer>(), 0);
        return res;
    }

    public void dfs(TreeNode root,int target, ArrayList<ArrayList<Integer>> res, ArrayList<Integer> sub, int sum) {
        if(root == null) {
            return;
        }
        //路径定义为到叶子节点
        if(root.left == null && root.right == null) {
            if(sum + root.val == target) {
                ArrayList<Integer> tmp = new ArrayList<>(sub);
                tmp.add(root.val);
                res.add(tmp);
            }
            return;
        }
        sub.add(root.val);
        dfs(root.left, target, res, sub, sum + root.val);
        dfs(root.right, target, res, sub, sum + root.val);
        sub.remove(Integer.valueOf(root.val));
    }
}