2019-05-24（剑指offer19~24）

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.https://www.nowcoder.com/practice/9b4c81a02cd34f76be2659fa0d54342a?tpId=13&tqId=11172&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

我最喜欢的一种做法是左上角，右下角一层层往里缩

import java.util.ArrayList;
public class Solution {
    public ArrayList printMatrix(int [][] matrix) {
        ArrayList ret = new ArrayList<>();
        int x = 0, y = 0, a = matrix.length - 1, b = matrix[0].length - 1;
        while(x <= a && y <= b) process(matrix, ret, x ++, y ++, a --, b --);
        return ret;
    }
    public void process(int[][] matrix, ArrayListret, int x, int y, int a, int b){
        if(x == a) for(int i = y; i <= b; i ++) ret.add(matrix[x][i]);
        else if(y == b) for(int i = x; i <= a; i ++) ret.add(matrix[i][y]);
        else{
            for(int i = y; i < b; i ++) ret.add(matrix[x][i]);
            for(int i = x; i < a; i ++) ret.add(matrix[i][b]);
            for(int i = b; i > y; i --) ret.add(matrix[a][i]);
            for(int i = a; i > x; i --) ret.add(matrix[i][y]);
        }
    }
}

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。https://www.nowcoder.com/practice/4c776177d2c04c2494f2555c9fcc1e49?tpId=13&tqId=11173&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

维护两个栈，一个存元素另一个为单调栈

• 当我们向栈中压入一个数时，如果该数 ≤ 单调栈的栈顶元素，则将该数同时压入单调栈中；否则，压入单调栈顶。
• 单调栈由于其具有单调性，所以它的栈顶元素，就是当前栈中的最小数。

import java.util.Stack;

public class Solution {
    Stack s1 = new Stack<>();//data
    Stack s2 = new Stack<>();//min
    
    public void push(int node) {
        s1.push(node);
        if(s2.isEmpty()) s2.push(node);
        else s2.push(node < s2.peek() ? node : s2.peek());
    }
    public void pop() {
        s2.pop();
        s1.pop();
    }
    public int top() { return s1.peek(); }
    public int min() { return s2.peek(); }
}

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）https://www.nowcoder.com/practice/d77d11405cc7470d82554cb392585106?tpId=13&tqId=11174&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

模拟题意即可，但栈不为空且栈顶等于当前弹出序列的头就弹出

import java.util.Stack;

public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        Stack s  = new Stack<>();
        int k = 0;
        for(int i = 0; i < pushA.length; i ++){
            s.push(pushA[i]);
            while(!s.isEmpty() && popA[k] == s.peek()){
                s.pop();
                k ++;
            }
        }
        if(s.isEmpty()) return true;
        return false;
    }
}

从上往下打印出二叉树的每个节点，同层节点从左至右打印。https://www.nowcoder.com/practice/7fe2212963db4790b57431d9ed259701?tpId=13&tqId=11175&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

bfs

import java.util.ArrayList;
import java.util.Queue;
import java.util.LinkedList;

public class Solution {
    public ArrayList PrintFromTopToBottom(TreeNode root) {
        ArrayList ret = new ArrayList<>();
        Queue q = new LinkedList<>();
        if(root == null) return ret;
        q.offer(root);
        while(!q.isEmpty()){
            TreeNode node = q.poll();
            ret.add(node.val);
            if(node.left != null) q.offer(node.left);
            if(node.right != null) q.offer(node.right);
        }
        return ret;
    }
}

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。https://www.nowcoder.com/practice/a861533d45854474ac791d90e447bafd?tpId=13&tqId=11176&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

根据二叉搜索树性质

• 当有元素大于根节点说明为右子树节点
• 如果上一步中判定的右子树里面有元素小于根返回false
• 递归左右子树

public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length == 0) return false;
        return dfs(sequence, 0, sequence.length - 1);
    }
    public boolean dfs(int[] s, int l, int r){
        if(l >= r) return true;
        int x = s[r], p = -1;
        for(int i = l; i <= r; i ++){
            if(s[i] > x) {
                p = i;
                break;
            }
        }
        if(p == -1) return true;
        for(int i = p; i <= r; i ++) if(s[i] < x) return false;
        return dfs(s, l, p - 1) && dfs(s, p, r - 1);
    }
}

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)https://www.nowcoder.com/practice/b736e784e3e34731af99065031301bca?tpId=13&tqId=11177&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

dfs当到达叶结点时判断一下target即可

import java.util.ArrayList;

public class Solution {
    public ArrayList> FindPath(TreeNode root,int target) {
        ArrayList> ret = new ArrayList<>();
        dfs(root, target, ret, new ArrayList());
        return ret;
    }
    public void dfs(TreeNode root, int target, ArrayList> ret, ArrayList path){
        if(root == null) return;
        target -= root.val;
        path.add(root.val);
        if(root.left == null && root.right == null && target == 0){
            ret.add(new ArrayList(path));
            path.remove(path.size() - 1);
            return;
        }
        dfs(root.left, target, ret, path);
        dfs(root.right, target, ret, path);
        path.remove(path.size() - 1);
    }
}