点击关注咱们获取更多面试编程题css
剑指 Offer 面试题11-15java
剑指 Offer 上面的编程题目愈来愈受大厂面试官喜好，熟练地掌握里面的题目是很是有必要的，尤为是那些想进大厂的程序员。程序员
11面试
面试题11-旋转数组中的最小数字算法
把一个数组最开始的若干个元素搬到数组的末尾，咱们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1编程
输入：[3,4,5,1,2]输出：1
解答状况json
寻找旋转数组的最小元素即为寻找 右排序数组 的首个元素 nums[x] ，称 x 为 旋转点 。swift
1 暴力解法-循环遍历数组
逐个遍历取最小值，显然解决这道题有点不合适微信
2 二分法查找
看下二分查找的标准代码
public int search(int[] nums, int target) { int left = 0, right = nums.length - 1; while (left <= right) { int mid = left + (right - left) / 2; if (nums[mid] == target) return mid; if (target < nums[mid]) right = mid - 1; else left = mid + 1; } return -1;}
对比二分查找，咱们能够写出以下代码
public int minArray(int[] numbers) { int left = 0, right = numbers.length - 1; while (left < right) { //找出left和right中间值的索引 int mid = left + (right - left) / 2; if (numbers[mid] > numbers[right]) { //若是中间值大于最右边的值，说明旋转以后最小的 //数字确定在mid的右边，好比[3, 4, 5, 6, 7, 1, 2] left = mid + 1; } else if (numbers[mid] < numbers[right]) { //若是中间值小于最右边的值，说明旋转以后最小的 //数字确定在mid的前面，好比[6, 7, 1, 2, 3, 4, 5], //注意这里mid是不能减1的，好比[3，1，3]，咱们这里只是 //证实了numbers[mid]比numbers[right]小，但有可能 //numbers[mid]是最小的，因此咱们不能把它给排除掉 right = mid; } else { //若是中间值等于最后一个元素的值，咱们是无法肯定最小值是 // 在mid的前面仍是后面，但咱们能够缩小查找范围，让right // 减1，由于即便right指向的是最小值，但由于他的值和mid // 指向的同样，咱们这里并无排除mid，因此结果是不会有影响的。 //好比[3，1，3，3，3，3，3]和[3，3，3，3，3，1，3],中间的值 //等于最右边的值，但咱们无法肯定最小值是在左边仍是右边 right--; } } return numbers[left];}
12
面试题12-矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串全部字符的路径。路径能够从矩阵中的任意一格开始，每一步能够在矩阵中向左、右、上、下移动一格。若是一条路径通过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。
例如，给出
[["a","b","c","e"], ["s","f","c","s"], ["a","d","e","e"]]
但矩阵中不包含字符串“abfb”的路径，由于字符串的第一个字符b占据了矩阵中的第一行第二个格子以后，路径不能再次进入这个格子。
解答状况
本问题是典型的矩阵搜索问题，可以使用 深度优先搜索（DFS）+ 剪枝 解决。
算法原理：
深度优先搜索：能够理解为暴力法遍历矩阵中全部字符串可能性。DFS 经过递归，先朝一个方向搜到底，再回溯至上个节点，沿另外一个方向搜索，以此类推。
剪枝：在搜索中，遇到 这条路不可能和目标字符串匹配成功 的状况（例如：此矩阵元素和目标字符不一样、此元素已被访问），则应当即返回，称之为 可行性剪枝 。
算法剖析：
递归参数：当前元素在矩阵 board 中的行列索引 i 和 j ，当前目标字符在 word 中的索引 k 。
终止条件：
返回 false ：① 行或列索引越界 或 ② 当前矩阵元素与目标字符不一样 或 ③ 当前矩阵元素已访问过 （③ 可合并至 ② ） 。
返回 true ：字符串 word 已所有匹配，即 k = len(word) - 1 。
递推工做：
标记当前矩阵元素：将 board[i][j] 值暂存于变量 tmp ，并修改成字符 '/' ，表明此元素已访问过，防止以后搜索时重复访问。
搜索下一单元格：朝当前元素的 上、下、左、右 四个方向开启下层递归，使用 或 链接 （表明只需一条可行路径） ，并记录结果至 res 。
还原当前矩阵元素：将 tmp 暂存值还原至 board[i][j] 元素。
回溯返回值：返回 res ，表明是否搜索到目标字符串
图解中，从每一个节点 DFS 的顺序为：下、上、右、左。
-
时间复杂度 O(3^K*MN)：最差状况下，须要遍历矩阵中长度为 K 字符串的全部方案，时间复杂度为 O(3^K)；矩阵中共有 MN 个起点，时间复杂度为 O(MN) 。
-
方案数计算：设字符串长度为 K ，搜索中每一个字符有上、下、左、右四个方向能够选择，舍弃回头（上个字符）的方向，剩下 33 种选择，所以方案数的复杂度为 O(3^K)。
-
空间复杂度 O(K) ：搜索过程当中的递归深度不超过 K ，所以系统因函数调用累计使用的栈空间占用 O(K) （由于函数返回后，系统调用的栈空间会释放）。最坏状况下 K = MN ，递归深度为 MN ，此时系统栈使用 O(MN) 的额外空间。
class Solution { public boolean exist(char[][] board, String word) { char[] words = word.toCharArray(); for(int i = 0; i < board.length; i++) { for(int j = 0; j < board[0].length; j++) { if(dfs(board, words, i, j, 0)) return true; } } return false; } boolean dfs(char[][] board, char[] word, int i, int j, int k) { if(i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != word[k]) return false; if(k == word.length - 1) return true; char tmp = board[i][j]; board[i][j] = '/'; boolean res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) || dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i , j - 1, k + 1); board[i][j] = tmp; return res; }}
13
面试题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。请问该机器人可以到达多少个格子？
解答状况
代码以下：
class Solution { int m, n, k; boolean[][] visited; public int movingCount(int m, int n, int k) { this.m = m; this.n = n; this.k = k; this.visited = new boolean[m][n]; return dfs(0, 0, 0, 0); } public int dfs(int i, int j, int si, int sj) { if(i >= m || j >= n || k < si + sj || visited[i][j]) return 0; visited[i][j] = true; return 1 + dfs(i + 1, j, (i + 1) % 10 != 0 ? si + 1 : si - 8, sj) + dfs(i, j + 1, si, (j + 1) % 10 != 0 ? sj + 1 : sj - 8); }}
代码以下：
class Solution { public int movingCount(int m, int n, int k) { boolean[][] visited = new boolean[m][n]; int res = 0; Queue<int[]> queue= new LinkedList<int[]>(); queue.add(new int[] { 0, 0, 0, 0 }); while(queue.size() > 0) { int[] x = queue.poll(); int i = x[0], j = x[1], si = x[2], sj = x[3]; if(i >= m || j >= n || k < si + sj || visited[i][j]) continue; visited[i][j] = true; res ++; queue.add(new int[] { i + 1, j, (i + 1) % 10 != 0 ? si + 1 : si - 8, sj }); queue.add(new int[] { i, j + 1, si, (j + 1) % 10 != 0 ? sj + 1 : sj - 8 }); } return res; }}
14
面试题14 剪绳子
用两个栈实现一个队列。队列的声明以下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操做返回 -1 )
解答状况
第1种解法以下：
代码以下：
class Solution { public int cuttingRope(int n) { if(n <= 3) return n - 1; int a = n / 3, b = n % 3; if(b == 0) return (int)Math.pow(3, a); if(b == 1) return (int)Math.pow(3, a - 1) * 4; return (int)Math.pow(3, a) * 2; }}
第2种解法以下：
代码以下：
class Solution { public int cuttingRope(int n) { int[] dp = new int[n + 1]; for (int i = 2; i <= n; i++) { for (int j = 1; j < i; j++) { dp[i]= Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j])); } } return dp[n]; }}
第3种解法以下：函数级值
class Solution { public int cuttingRope(int n) { if (n <= 3) { return n - 1; } int quotient = n / 3; int remainder = n % 3; if (remainder == 0) { return (int) Math.pow(3, quotient); } else if (remainder == 1) { return (int) Math.pow(3, quotient - 1) * 4; } else { return (int) Math.pow(3, quotient) * 2; } }}
15
面试题15 二进制中1的个数
请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。所以，若是输入 9，则该函数输出 2。
输入：00000000000000000000000000001011 输出：3 解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。 |
解答状况
代码以下：
public class Solution { public int hammingWeight(int n) { int res = 0; while(n != 0) { res += n & 1; n >>>= 1; } return res; }}
代码以下：
public class Solution { public int hammingWeight(int n) { int res = 0; while(n != 0) { res++; n &= n - 1; } return res; }}
END
本文分享自微信公众号 - Java学习进阶手册（javastudyup）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。