《剑值offer 》第二版 编程题全解

面试题03. 数组中重复的数字

题目描述：
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

解题思路：
解法1： 最简单也是最容易想到的解法，调用Set记录出现过的数组。时间复杂度O(n),空间复杂度O(n)

    public int findRepeatNumber(int[] nums) {
        if(nums == null || nums.length == 0)
            return -1;
        Set<Integer> set = new HashSet<>();
        for (int i = 0;i < nums.length; i++) {
            if (set.contains(nums[i])) {
                return nums[i];
            }else {
                set.add(nums[i]);
            }
        }
        return -1;
    }

解法2： 降低一下空间复杂度，使用原地置换的方法，因为所有元素都在0~n-1范围内，所以可以使用一个置换算法，让每个元素要求元素与下标对应一一对应。如果调用过程中发现该位置元素出现相同的，那么即为重复元素。

public int findRepeatNumber(int[] nums) {
    if (nums == null || nums.length == 0)
        return -1;
    for (int i = 0;i < nums.length; i++) {
        while (nums[i] != i) {
            int tmp = nums[i];
            if (tmp == nums[tmp]) return tmp;
            nums[i] = nums[tmp];
            nums[tmp] = tmp;
        }
    }
    return -1;
}

面试题04. 二维数组中的查找

题目描述：
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题思路：
为了避免全局遍历，我们根据给定数组从左到右从上到下递增的规则，从右上角逐渐向左下扫描，根据大小逐级排查，避免了全局扫描。

public boolean findNumberIn2DArray(int[][] matrix, int target) {
    if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
        return false;
    int row = 0 , col = matrix[0].length - 1;
    while (row < matrix.length && col >= 0) {
        if (matrix[row][col] == target)
            return true;
        else if (matrix[row][col] > target) {
            col--;
        }else {
            row++;
        }
    }
    return false;
}

面试题05. 替换空格

题目描述：
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

题解：

在字符串尾部填充任意字符，使得字符串的长度等于替换之后的长度。因为一个空格要替换成三个字符（%20），因此当遍历到一个空格时，需要在尾部填充两个任意字符。

令 P1 指向字符串原来的末尾位置，P2 指向字符串现在的末尾位置。P1 和 P2 从后向前遍历，当 P1 遍历到一个空格时，就需要令 P2 指向的位置依次填充 02%（注意是逆序的），否则就填充上 P1 指向字符的值。

从后向前遍是为了在改变 P2 所指向的内容时，不会影响到 P1 遍历原来字符串的内容。

    public String replaceSpace(String s) {
        if(s == null)
            return null;
        StringBuffer sbf = new StringBuffer(s);
        int p = sbf.length() - 1;
        for(int i = 0;i <=p;i++) {
            if(sbf.charAt(i) == ' ')
                sbf.append("  ");
        }
        int n = sbf.length()-1;
        while (p >= 0 && p < n) {
            char c = sbf.charAt(p--);
            if (c == ' '){
                sbf.setCharAt(n--, '0');
                sbf.setCharAt(n--, '2');
                sbf.setCharAt(n--, '%');
            }else{
                sbf.setCharAt(n-- , c);
            }
        }


        return sbf.toString();
    }

面试题06. 从尾到头打印链表

题目描述：
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

题解：
首先用一个遍历，统计整个链表长度n，然后我们定义一个长度为n的数组，把链表第一个元素复制到第二个元素上去。时间复杂度O(n) ,

    public int[] reversePrint(ListNode head) {
        int len = 0;
        ListNode p = head;
        while (p != null) {
            len++;
            p = p.next;
        }
        int res[] = new int[len];
        p = head;
        for (int i = len-1;i >= 0; i-- ) {
            res[i] = p.val;
            p = p.next;
        }
        return res;
    }

面试题07. 重建二叉树

题目描述：
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

题解：
二叉树的先序遍历的顺序是先根节点，左子树然后右子树。
而二叉树的中序遍历顺序是先左子树然后根节点然后右子树。
所以，二叉树的先序遍历的第一个一定是根节点，同理，找到根节点在中序遍历中的位置，左边的元素是左子树，右边的元素是右子树。然后递归调用即可。

public TreeNode buildTree(int[] preorder, int[] inorder) {
    if (preorder == null || inorder == null || preorder.length == 0 || inorder.length == 0)
        return null;
    TreeNode treeNode = new TreeNode(preorder[0]);
    int index = getNums(treeNode.val , inorder);
    treeNode.left = buildTree(Arrays.copyOfRange(preorder , 1 , index + 1) ,
            Arrays.copyOfRange(inorder , 0 , index));
    treeNode.right = buildTree(Arrays.copyOfRange(preorder , index + 1 , preorder.length) ,
            Arrays.copyOfRange(inorder , index+1 , inorder.length));
    return treeNode;
}

private int getNums(int target , int[] inroder) {
    for (int i = 0;i < inroder.length; i++) {
        if (target == inroder[i])
            return i;
    }
    return -1;
}

面试题09. 用两个栈实现队列

题目描述：
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
题解：
用两个栈来模拟队列，因为栈的数据结构是后进先出。所以用两个栈，所有元素入栈时都入到第一个栈中。出栈时，把第一个栈中所有元素都加到第二个栈中，然后把第二个栈顶弹出即可。

class CQueue {

    private Stack<Integer> stack1;
    private Stack<Integer> stack2;

    public CQueue() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }


    public void appendTail(int value) {
        stack1.push(value);
    }

    public int deleteHead() {
        if (stack2.size() != 0)
            return stack2.pop();
        while (stack1.size() != 0) {
            stack2.push(stack1.pop());
        }
        if (stack2.size() == 0)
            return -1;
        return stack2.pop();
    }
}

面试题10.01 斐波那契数列

题目描述：
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项。斐波那契数列的定义如下：

F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.

斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。

题解：
经典的动态规划算法，状态转移方程 a[n] = a[n-1] + a[n - 1]。由于我们只用了a[n-1]和a[n-2]两个量，所以不用定义dp数组，定义两个变量即可。

    public int fib(int n) {
        if (n == 0)
            return 0;
        if (n == 1)
            return 1;
        int a = 0 , b = 1, res = 0;
        for (int i = 2;i <= n; i++) {
            res = (a+b) % 1000000007;
            a = b;
            b = res;

        }
        return res;
    }

面试题10- II. 青蛙跳台阶问题

题目描述：
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。

题解：
同上题。

    public int numWays(int n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return 1;
        if (n == 2)
            return 2;
        int a = 1 , b = 2, res = 0;
        for (int i = 3;i <= n; i++) {
            res = (a+b) % 1000000007;
            a = b;
            b = res;

        }
        return res;

    }

面试题11 . 旋转数组的最小数字

题目描述：
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

题解：
使用二分查找，首先定义左指针和右指针，然后取中间指针。如果中间指针元素大于右指针元素，说明最小值位于右边，令left = mid + 1，反之，说明最小值位于左边，令right = mid。

public int minArray(int[] numbers) {
    int left = 0, right = numbers.length - 1;
    while (left < right) {
        int mid = (left + right) >>> 1;
        if (numbers[mid] > numbers[right]) {
            left = mid + 1;
        }else if (numbers[mid] < numbers[right]){
            right = mid;
        }else {
            right--;
        }
    }
    return numbers[right];
}

面试题12 矩阵中的路径

题目描述：
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。

题解：
对每个元素进行遍历，遍历到某个元素对这个元素进行bfs搜索，如果找到对应单词路径，返回true。

    public boolean exist(char[][] board, String word) {
        char c[] = word.toCharArray();
        for (int i = 0;i < board.length; i++) {
            for (int j = 0;j < board[i].length; j++) {
                if (bfs(board , i , j , c , 0))
                    return true;
            }
        }
        return true;
    }

    private boolean bfs(char[][] board , int x , int y , char c[] , int k) {
        if (x >= board.length || x < 0 || y >= board[0].length || y < 0 || board[x][y] != c[k]){
            return false;
        }
        if (k == c.length - 1)
            return true;
        char tmp = board[x][y];
        board[x][y] = '/';
        boolean res = bfs(board , x + 1 , y ,c , k +1) || bfs(board , x , y  + 1,c , k +1)
                || bfs(board , x - 1 , y ,c , k +1) || bfs(board , x  , y - 1,c , k +1);
        board[x][y] = tmp;
        return res;
    }

面试题13. 机器人的运动范围

题目描述：
地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

题解：
从0 ， 0 开始对每个DFS算法，要么向下，要么向右。

    public int movingCount(int m, int n, int k) {
        int matrix[][] = new int[m][n];
        boolean visit[][] = new boolean[m][n];
        return dfs(0 ,0 , visit , matrix , k);
        

    }

    private int dfs(int x , int y , boolean visit[][],int matrix[][], int k) {
        if (check(x , y , visit , matrix , k)) {
            visit[x][y] = true;
            return 1 + dfs(x + 1, y, visit, matrix, k) + dfs(x, y + 1, visit, matrix, k);
        }
        return 0;
    }


    public boolean check(int x,int y,boolean visit[][] ,int matrix[][] , int k) {
        if (x >= 0 && y >= 0 && x < matrix.length && y < matrix[0].length && !visit[x][y] && (getSum(x)+getSum(y) <= k)) {
            return true;
        }
        return false;
    }

    public int getSum(int x) {
        int sum = 0;
        while (x > 0) {
            sum += x % 10;
            x /= 10;
        }
        return sum;
    }

面试题14-1. 剪绳子

题目描述：
给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m] 。请问 k[0]k[1]…*k[m] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

题解：
一道经典的动态规划题目。我们设置一个dp[n]数组来存储长度为i的数组所能取得的最大乘积。可以看出，dp[1] = 1 ,dp[2] = 1 , 2 = 1+1 。而dp[i] = max((i - j ) * j , dp[i-j] * j);

    public int cuttingRope(int n) {
        if (n == 1)
            return 1;
        if (n == 2)
            return 1;
        int dp[] = new int[n+1];
        dp[1] = 1;
        dp[2] = 1;
        for (int i = 3;i <= n; i++) {
            for (int j = 1; j < i; j++) {
                dp[i] = Math.max(dp[i] , Math.max((i - j) * j , dp[i- j] * j));
            }
        }
        return dp[n];
    }

面试题14-2. 剪绳子

题目描述：

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m] 。请问 k[0]k[1]…*k[m] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

题解：
分析可知，尽量分成长度为3时，乘积最大。所以我们尽可能分成3份。

    public int cuttingRope(int n) {
        long dp[] = new long[1001];
        dp[1]=1;
        dp[2]=1;
        dp[3]=2;
        dp[4]=4;
        dp[5]=6;
        dp[6]=9;
        for (int i = 7;i <= n;i ++) {
            dp[i] = (dp[i - 3] * 3) % 1000000007;
        }
        return (int)dp[n];
    }

面试题15. 二进制中1的个数

题目描述：
请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。

题解
因为，任何二进制数和1做取与运算，只有末尾为1的时候才返回1。所以，我们每次把最后一位和1做&运算，然后右移一位，计算返回1的个数即可。

    public int hammingWeight(int n) {
        int res = 0;
        while (n != 0) {
            res +=  n & 1;
            n >>>= 1;
        }
        return res;
    }

面试题16. 数值的整数次方

题目描述：
实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。

题解：
采用递归的思路求解.

    public double myPow(double x, long n) {
        if (n == 0)
            return 1;
        if (n == 1)
            return x;
        if (n > 0)
            return help(x , n);
        else
            return help(1/x , -n);
    }

    private double help (double a , long b) {
        if (b == 1)
            return a;
        if (b % 2 == 1) {
            return a * help(a , b -1 );
        }else {
            return help(a * a , b >> 1);
        }
    }

面试题17. 打印从1到最大的n位数

题目描述：
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

题解：
使用Math.pow函数，首先求出来最大值，然后定义一个数组按位相加即可。

    public int[] printNumbers(int n) {
        int nMax = (int)Math.pow(10 , n);
        int res[] = new int[nMax - 1];
        for (int i = 1;i < nMax; i++) {
            res[i - 1] = i;
        }
        return res;
    }

面试题18. 删除链表的节点

题目描述：
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
返回删除后的链表的头节点。

题解：
首先用一个指针p指向头节点，然后遍历链表，找到要删除节点的前一个节点，即可删除节点。

    public ListNode deleteNode(ListNode head, int val) {
        if (head == null) return head;
        if (head.val == val) return head.next;

        ListNode p = head;
        while (p.next != null && p.next.val != val) {
            p = p.next;
        }
        if (p.next != null)
            p.next = p.next.next;
        return head;
    }

面试题19. 正则表达式匹配

题目描述：
请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。

题解：
使用二维dp算法，定义一个boolean[][] dp = new boolean[m + 1][n + 1];，其中，dp[i][j]表示s的前i个串和p的前j个串匹配。

    public boolean isMatch(String s, String p) {
        if (s == null || p == null) return false;
        int m = s.length(), n = p.length();
        boolean[][] dp = new boolean[m + 1][n + 1];
        dp[0][0] = true;
        for (int i = 2; i <= n; i+= 2) {
            if (p.charAt(i - 1) == '*') {
                dp[0][i] = dp[0][i - 2];
            }
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                char sc = s.charAt(i - 1);
                char pc = p.charAt(j - 1);
                if (sc == pc || pc == '.') {
                    dp[i][j] = dp[i - 1][j - 1];
                } else if (pc == '*') {
                    if (dp[i][j - 2]) {
                        dp[i][j] = true;
                    } else if (sc == p.charAt(j - 2) || p.charAt(j - 2) == '.') {
                        dp[i][j] = dp[i - 1][j];
                    }
                }
            }
        }
        return dp[m][n];
    }

面试题20. 表示数值的字符串

题目描述：
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、“5e2”、"-123"、“3.1416”、“0123"及”-1E-16"都表示数值，但"12e"、“1a3.14”、“1.2.3”、"±5"及"12e+5.4"都不是。

题解：
对字符串进行逐位扫描，符合下面几种i情况才是字符串：

• 必须出现数字
• ±号必须位于开头或者e的后面
• e后面必须有数字
• . 和e只能出现一次
• .不能出现在e的后米娜

    public boolean isNumber(String s) {
        if (s == null) return false;

        char str[] = s.trim().toCharArray();

        boolean numSeen = false;
        boolean dotSeen = false;
        boolean eSeen = false;

        for (int i = 0;i < str.length; i++) {

            if (str[i] >= '0' && str[i] <= '9') {
                numSeen = true;
            }else if (str[i] == '.') {
                if (dotSeen || eSeen)
                    return false;
                dotSeen = true;
            }else if (str[i] == 'e' || str[i] == 'E'){
                if (!numSeen || eSeen)
                    return false;
                eSeen = true;
                numSeen = false;
            }else if (str[i] == '+' || str[i] == '-') {
                if (i != 0 && str[i - 1] != 'e' && str[i - 1] != 'E' ) {
                    return false;
                }
            }else {
                return false;
            }
        }
        return numSeen;

    }

面试题21. 调整数组顺序使奇数位于偶数前面

题目描述：
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

题解
使用快排的思想，定义一个左指针从链表左边搜索偶数，定义一个右指针从链表右边搜索奇数，然后逐个扫描即可。

    public int[] exchange(int[] nums) {

        if (nums == null || nums.length == 0) return nums;
        int left = 0 , right = nums.length - 1;

        while (left < right) {
            while ((left < right) && (nums[left] %2 != 0)) {
                left++;
            }
            while ((left < right) && (nums[right] %2 == 0)) {
                right--;
            }
            if (left < right) {
                swap(nums , left , right);
            }
        }
        return nums;
    }

    private void swap(int nums[] , int left , int right) {
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
    }

面试题22. 链表中倒数第k个节点

题目描述：
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

题解：
利用快慢链表法，先定义一个节点运动到第k个元素位置，然后再定义个节点指向p。然后把两个节点一起逐位向后移，抵达链表末尾即可。

    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode p  = head , q = head;
        while (k--!=0) {
            p = p.next;
        }
        while (p != null) {
            p = p.next;
            q = q.next;
        }
        return q;
    }

面试题24. 反转链表

题目描述：
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

题解：
定义一个头节点，把原链表元素逐个插入链表。

    public ListNode reverseList(ListNode head) {
        ListNode p = new ListNode(1);
        while (head != null) {
            ListNode q = head.next;
            head.next = p.next;
            p.next = head;
            head = q;
        }
        return p.next;
    }

面试题25. 合并两个排序的链表

题目描述：
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

题解：
定义一个新的头节点，把两个链表逐个合并。当一条链表到末尾，把另一条链表直接添加到尾部。

    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) return l2;
        if (l2 == null) return l1;

        ListNode head;
        if (l1.val > l2.val) {
            head = l2;
            l2 = l2.next;
        }else {
            head = l1;
            l1 = l1.next;
        }
        head.next = null;
        ListNode r = head;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                ListNode p = l1.next;
                r.next = l1;
                l1.next = null;
                l1 = p;
            }else {
                ListNode p = l2.next;
                r.next = l2;
                l2.next = null;
                l2 = p;
            }
            r = r.next;
        }

        if (l1 == null) {
            r.next = l2;
        }

        if (l2 == null)
            r.next = l1;
        return head;
    }

面试题26. 树的子结构

题目描述：

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

题解：
使用递归的思想

    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if (A == null || B == null)
            return false;
        return dfs(A,B) || dfs(A.left , B) || dfs(A.right , B);
    }

    private boolean dfs(TreeNode A, TreeNode B) {
        if (B == null)
            return true;
        if (A == null)
            return false;
        if (A.val != B.val)
            return false;
        return dfs(A.left , B.left) && dfs(A.right , B.right);
    }

面试题27. 树的子结构

题目描述：

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

题解：
采用递归的思想，在每个节点处调换它的左子树和右子树的指针。

    public TreeNode mirrorTree(TreeNode root) {
        if (root == null)
            return root;
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        mirrorTree(root.left);
        mirrorTree(root.right);
        return root;
    }

面试题28. 对称的二叉树

题目描述：
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
题解：

    public boolean isSymmetric(TreeNode root) {
        if (root == null)
            return true;
        return dfs(root , root);
    }

    private boolean dfs(TreeNode root1 , TreeNode root2) {
        if (root1 == null && root2 == null)
            return true;
        if (root1 == null || root2 == null)
            return false;
        if (root1.val != root2.val)
            return false;
        return dfs(root1.left , root2.right) && dfs(root1.right , root2.left);
    }

面试题29. 顺时针打印矩阵

题目描述：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

题解：

    public int[] spiralOrder(int[][] matrix) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return new int[]{};
        }

        int row1 = 0, row2 = matrix.length - 1 , col1 = 0 , col2 = matrix[0].length - 1,index = 0;
        int res[] = new int[matrix.length * matrix[0].length];
        while (row1 <= row2  && col1 <= col2) {
            for (int i = col1;i <= col2; i++) {
                res[index++] = matrix[row1][i];
            }
            for (int i = row1 + 1;i <= row2; i++) {
                res[index++] = matrix[i][col2];
            }
            if (row1 < row2 && col1 < col2) {
                for (int i = col2 - 1; i >= col1; i--)
                    res[index++] = matrix[row2][i];
                for (int i = row2 - 1;i >= row1 + 1; i--)
                    res[index++] = matrix[i][col1];
            }

            row1++;row2--;col1++;col2--;
        }

        return res;
    }

面试题30 . 顺时针打印矩阵

题目描述：

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

题解：

class MinStack {

    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }

    public void push(int x) {
        stack.push(x);
        if (minStack.size() == 0 || minStack.peek() >= x) {
            minStack.push(x);
        }
    }

    public void pop() {
        int x = stack.pop();
        if (minStack.size() != 0 && minStack.peek() == x) {
            minStack.pop();
        }
    }

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

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

}

面试题31. 栈的压入、弹出序列

题目描述：
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

题解：

class Solution {
    public boolean validateStackSequences(int[] pushed, int[] popped) {
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for (int i = 0;i < pushed.length; i++) {
            stack.push(pushed[i]);
            while (stack.size() != 0 && j < popped.length && popped[j] == stack.peek()) {
                j++;
                stack.pop();
            }
        }
        return stack.size() == 0;

    }
}

面试题32 - I. 从上到下打印二叉树

题目描述：
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

题解： 经典的广度优先搜索算法

public int[] levelOrder(TreeNode root) {
    if (root == null)
        return new int[]{};
    Queue<TreeNode> queue = new LinkedList<>();
    List<Integer> list = new ArrayList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        list.add(node.val );
        if (node.left != null)
            queue.offer(node.left);
        if (node.right != null)
            queue.offer(node.right);
    }
    int res[] = new int[list.size()];
    for (int i = 0;i < res.length; i++) {
        res[i] = list.get(i);
    }
    return res;
}

面试题32 - II. 从上到下打印二叉树 II

题目描述： 从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

题解：

    public List<List<Integer>> levelOrder(TreeNode root) {
       if (root == null)
           return new ArrayList();
       Queue<TreeNode> queue = new LinkedList<>();
       List<List<Integer>> list = new ArrayList<>();
       queue.offer(root);
       while (!queue.isEmpty()) {
           List<Integer> tmp = new ArrayList<>();
           int size = queue.size();
           for (int i = 0;i < size; i++) {
               TreeNode node = queue.poll();
               tmp.add(node.val);
               if (node.left != null)
                   queue.offer(node.left);
               if (node.right != null)
                   queue.offer(node.right);
           }
           list.add(tmp);

       }
       return list;
   }

面试题32 - III. 从上到下打印二叉树 III

题目描述： 请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

题解：

    public List<List<Integer>> levelOrder(TreeNode root) {
       if (root == null)
           return new ArrayList();
       Queue<TreeNode> queue = new LinkedList<>();
       List<List<Integer>> list = new ArrayList<>();
       int t = 0;
       queue.offer(root);
       while (!queue.isEmpty()) {
           List<Integer> tmp = new ArrayList<>();
           int size = queue.size();
           for (int i = 0;i < size; i++) {
               TreeNode node = queue.poll();
               tmp.add(node.val);
               if (node.left != null)
                   queue.offer(node.left);
               if (node.right != null)
                   queue.offer(node.right);
           }
           if (t++ % 2 != 0)
               Collections.reverse(tmp);
           list.add(tmp);

       }
       return list;
   }

所有代码已上传至本人Github，欢迎大家star和follow。