二〇一九剑指BAT，Java后端研发面试题解析，连解题思路都告诉你

BAT做为中国三大最大互联网公司，是每一个程序员求之不得的工做环境，比如高中生高考的目的是清华北大复旦同样，因此每一个年轻程序员都应该尝试进入BAT工做。

第一题：搜索二位矩阵

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具备如下特性：

• 每行的元素从左到右升序排列。
• 每列的元素从上到下升序排列。

示例：

现有矩阵 matrix 以下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

• 给定 target = 5，返回 true。
• 给定 target = 20，返回 false。

解题思路

二维数组是有规律的：右上角的数字是一列中最小的、一行中最大的，经过这个数字和 target 进行对比，能够将一行或者一列做为候选区域排出，那么 target 可能存在的范围缩小，最终得出结果。

public Boolean searchMatrix(int[][] matrix, int target) {
    if (matrix.length == 0) {
        return false;
    }
    for (int i = 0, j = matrix[0].length - 1; i < matrix.length && j >= 0; ) {
        if (matrix[i][j] > target) {
            j--;
        } else if (matrix[i][j] < target) {
            i++;
        } else {
            return true;
        }
    }
    return false;
}

第二题：替换空格

请实现一个函数，将一个字符串中的每一个空格替换成“%20”。例如，当字符串为We Are Happy.则通过替换以后的字符串为 We%20Are%20Happy。

解题思路

1. 经过字符串中空格的个数，计算新字符串长度
2. 两个指针进行字符串拷贝，当遇到‘ ’时替换为 %20

public String replaceSpace(StringBuffer str) {
    char[] chars = str.toString().toCharArray();
    StringBuilder res = new StringBuilder();
    for (char c : chars) {
        if (c == ' ') res.append("%20"); else res.append(c);
    }
    return res.toString();
}

第三题：从头至尾打印链表

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

解题思路

1. 栈

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    LinkedList<Integer> stack = new LinkedList<>();
    while (listNode != null) {
        stack.addLast(listNode.val);
        listNode = listNode.next;
    }
    ArrayList<Integer> res = new ArrayList<>();
    while (!stack.isEmpty()) {
        res.add(stack.pollLast());
    }
    return res;
}

1. 递归：当链表过长时，会致使栈溢出

public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
    ArrayList<Integer> res = new ArrayList<>();
    print(res,listNode);
    return res;
}
private void print(ArrayList<Integer> res, ListNode listNode) {
    if (listNode == null) return;
    print(res, listNode.next);
    res.add(listNode.val);
}

第四题：重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

解题思路

1. 经过前序遍历找到 root 节点
2. 那么在 中序遍历中 root 节点的左侧则是左子树，右侧是右子树
3. 依次类推，递归生成节点的左子树和右子树
4. 构建过程由下往上

public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
    Map<Integer, Integer> preIndex = new HashMap<>();
    for (int i = 0; i < pre.length; i++) {
        preIndex.put(pre[i], i);
    }
    return buildTree(preIndex, in, 0, in.length - 1);
}
private TreeNode buildTree(Map<Integer, Integer> preIndex, int[] in, int start, int end) {
    if (start == end) {
        return new TreeNode(in[start]);
    }
    int indexOfRoot = start;
    for (int i = start; i <= end; i++) {
        if (preIndex.get(in[i]) < preIndex.get(in[indexOfRoot])) {
            indexOfRoot = i;
        }
    }
    TreeNode root = new TreeNode(in[indexOfRoot]);
    if (start <= indexOfRoot - 1) root.left = buildTree(preIndex, in, start, indexOfRoot - 1);
    if (indexOfRoot + 1 <= end) root.right = buildTree(preIndex, in, indexOfRoot + 1, end);
    return root;
}

第五题：用两个栈实现一个队列

用两个栈来实现一个队列，完成队列的 Push 和 Pop 操做。 队列中的元素为int类型。

解题思路

1. 用 stack1 做为 push 队列，将元素 push 到 stack1
2. 用 stack2 做为 pop 队列，当 stack2 为空时则将 stack1 的数据 push 到 stack2，不然直接 pop stack2

至关于将两个 stack 拼接：-> stack1 <::> stack2 ->

Stack<Integer> pushStack = new Stack<>();
Stack<Integer> popStack = new Stack<>();
public void push(int node) {
    pushStack.push(node);
}
public int pop() {
    if (popStack.isEmpty()) {
        while (!pushStack.isEmpty()) {
            popStack.push(pushStack.pop());
        }
    }
    if (popStack.isEmpty()) return -1; else return popStack.pop();
}

第六题：旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，咱们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的全部元素都大于0，若数组大小为0，请返回0。

解题思路

1. 旋转以后的数组存在两个上升序列，最小元素在两个上升序列的中间
2. 用两个指针在两个序列中找到最大和最小的值，这样 end 指向的数则为最小

public int minNumberInRotateArray(int[] array) {
    if (array.length == 0) {
        return 0;
    }
    int start = 0, end = array.length - 1;
    while (end - start != 1) {
        int mid = (start + end) / 2;
        if (array[mid] >= array[start]) {
            start = mid;
        }
        if (array[mid] <= array[end]) {
            end = mid;
        }
    }
    return array[end];
}

第七题：斐波纳切数列

你们都知道斐波那契数列，如今要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39

解题思路

1. 递归计算很慢，是最简单的算法

public int Fibonacci(int n) {
    if (n == 0) {
        return 0;
    }
    if (n == 1) {
        return 1;
    }
    int l = 1, ll = 0;
    for (int i = 2; i <= n; i++) {
        int t = ll + l;
        ll = l;
        l = t;
    }
    return l;
}

第八题：二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

解题思路

1. 负数是补码表示
2. >>> 为无符号右移，>>为有符号右移，当 n 为负数是会增长多余的1

public int NumberOf1(int n) {
    int mask = 0x01;
    int res = 0;
    int t = n;
    while (t != 0) {
        if ((t & mask) == 1) {
            res++;
        }
        t = t >>> 1;
    }
    return res;
}

第九题：数值的整数次方

给定一个 double 类型的浮点数 base 和 int 类型的整数 exponent 。求 base 的 exponent 次方。

解题思路

1. 当 n 为偶数时，$$a^n = a^{n/2} * a^{n/2}$$
2. 当 n 为奇数时，$$a^n = a^{n/2} * a^{n/2} * a$$
3. 能够利用相似斐波纳切的方式，利用递归来进行求解

public double Power(double base, int exponent) {
    if (base == 0) {
        return 0;
    }
    if (base == 1) {
        return 1;
    }
    int t_exponent = Math.abs(exponent);
    double t = PositivePower(base, t_exponent);
    return exponent > 0 ? t : 1 / t;
}
private double PositivePower(double base, int exponent) {
    if (exponent == 0) {
        return 1;
    }
    if (exponent == 1) {
        return base;
    }
    double t = PositivePower(base, exponent >> 1);
    t *= t;
    if ((exponent & 0x01) == 1) {
        t *= base;
    }
    return t;
}

第十题：打印最大的n位数

输入n，打印出 1 到最大的 n 位十进制数。好比输入3，则打印出一、二、3 直到最大的 3 位数 999。

解题思路

1. n 可能很大，致使输出的数字超过 int 或者 long

public void PrintN(int n) {
    if (n <= 0) {
        return;
    }
    String res = "0";
    while (true) {
        Boolean all9 = true;
        res = Plus(res, 1);
        System.out.println(res);
        for (int i = 0; i < res.length(); i++) {
            if (res.charAt(i) != '9') {
                all9 = false;
                break;
            }
        }
        if (all9 && res.length() == n) {
            break;
        }
    }
}
private String Plus(String t, int i) {
    char[] chars = t.toCharArray();
    StringBuilder res = new StringBuilder();
    chars[chars.length - 1] += i;
    Boolean flag = false;
    for (int j = chars.length - 1; j >= 0; j--) {
        int a = chars[j];
        if (flag) {
            a++;
            flag = false;
        }
        if (a > '9') {
            flag = true;
            a = a - '9' + '0' - 1;
        }
        res.append((char) a);
    }
    if (flag) {
        res.append('1');
    }
    return res.reverse().toString();
}

第十一题：在O(1)的时间复杂度下删除节点

给定单向链表的头指针以及待删除的指针，定义一个函数在 O(1) 的时间复杂度下删除

解题思路

1. 待删除节点非尾节点，将后一个节点的值复制到当前节点，而后删除后一个节点
2. 待删除节点为尾节点，从头节点开始，找到待删除节点的前一个节点进行删除

public void O1DeleteNode(ListNode head, ListNode needDelete) {
    if (needDelete.next != null) {
        ListNode next = needDelete.next.next;
        needDelete.val = needDelete.next.val;
        needDelete.next = next;
    } else {
        ListNode cursor = head;
        while (cursor != null) {
            if (cursor.next == needDelete) break;
            cursor = cursor.next;
        }
        if (cursor == null) return;
        cursor.next = needDelete.next;
    }
}

第十二题：调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得全部的奇数位于数组的前半部分，全部的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

解题思路

1. 须要保证排序的稳定性
2. 采用冒泡算法进行排序

public void reOrderArray(int[] array) {
    if (array.length <= 1) {
        return;
    }
    for (int i = array.length - 1; i >= 0; i--) {
        for (int j = i; j < array.length - 1; j++) {
            if (array[j] % 2 == 0 && array[j + 1] % 2 == 1) swap(array, j, j + 1);
        }
    }
}
private void swap(int[] array, int a, int b) {
    int t = array[a];
    array[a] = array[b];
    array[b] = t;
}

第十三题：链表中倒数第k个结点

输入一个链表，输出该链表中倒数第k个结点。

解题思路

1. 两个指针，快指针先走 k 步，而后慢指针在向前移动，当快指针遍历结束，慢指针指向倒数第 k 个节点
2. 须要考虑倒数 k 个节点不存在的状况

public ListNode FindKthToTail(ListNode head, int k) {
    if (head == null) {
        return null;
    }
    ListNode cursor = head;
    ListNode cursorK = head;
    int i = 0;
    while (cursorK != null) {
        cursorK = cursorK.next;
        if (i >= k) {
            cursor = cursor.next;
        }
        i++;
    }
    if (i < k) {
        return null;
    }
    return cursor;
}

第十五题：反转链表

输入一个链表，反转链表后，输出新链表的表头。

解题思路

1. 三个指针

public ListNode ReverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode pre = head, cur = head.next, next;
    pre.next = null;
    while (cur != null) {
        next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}

写在最后

面试题还有不少，可是本文章限于篇幅，只分享15到一线互联网面试真题；关于本人所设计到的面试题，本人都已经整理成一份完整的PDF面试题集合，现免费分享给各位有须要的Java工程师朋友，点击下方传送门便可免费领取哟

传送门

• 雄心是成功路上的指南，
• 信心是永不放弃的呼唤，
• 热心是成功者的胸怀，
• 耐心是驱赶困难的利剑，
• 责任心是迈向成功的必然。
• 愿五心伴您度过每一天!
• 衷心祝你们面试一路顺风，马到成功！