本文精选《剑指Offer》中的经典题目，包括数组中重复的数字、二维数组中的查找、替换空格等，并提供多种解题思路及Java代码实现。
内容来源于自己的刷题笔记，对一些题目进行方法总结，用 java 语言实现。
1.剑指 Offer 03. 数组中重复的数字
-
题目描述：
找出数组中重复的数字。
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
示例1：
输入：[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3 -
解题思路：
-
Set 集合存储，循环查找有无重复。
-
原地置换，其实与前一种有互通之处，当扫描到下标为 i 的数字时，首先比较这个数字是否等于 i。如果是，相当于 Set 集合中这个固定属于 i 的位置已满，可以搜索下一个值；如果不等于，比较 num[i] 与 num[num[i]] 这两个数，相等，则为重复数字；不相等，则两者进行交换。
3 1 1 0 扫描到下标为0，不相等，比较 num[0] 与 num[num[0]] (3 与 0) 不相等，交换，继续扫描下标 0 1 1 3 此时继续扫描下标0，相等，扫描下标1 0 1 1 3 此时扫描下标1，相等，扫描下标2 0 1 1 3 此时扫描下标2，不相等，比较 num[2] 与 num[num[2]] (1 与 1) 相等，找出重复数字
-
-
代码实现：
/** * 采用集合的思想，将数组进行遍历，每次都与集合进行比较，如果集合包含该数，就输出，如果不包含就存入集合中 * @param nums * @return */ public int findRepeatNumber(int[] nums) { Set<Integer> set = new HashSet<>(); for (int i = 0;i < nums.length;i ++){ if (set.contains(nums[i])){ return nums[i]; } set.add(nums[i]); } return -1; } /** * 原地置换 * @param nums * @return */ public int findRepeatNumber1(int[] nums) { if (nums == null||nums.length <= 0){ return -1; } for (int i = 0;i < nums.length;i++){ if (nums[i] < 0|| nums[i] > nums.length - 1){ return -1; } } for (int i = 0;i < nums.length;i++){ while (nums[i] != i){ if (nums[i] == nums[nums[i]]){ return nums[i]; } int temp = nums[i]; nums[i] = nums[temp]; nums[temp] = temp; } } return -1; }
2.剑指 Offer 04. 二维数组中的查找
-
题目描述：
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 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。
-
解题思路：
- 暴力遍历：将所有的数都遍历，找出所有的值，但并不能利用好这个特殊的结构。
- 有规律的遍历，右上开始：行从0开始，列从最大值开始，先比较此时右上角的数，如果小于该数，这一列就可以舍弃，列数减一；如果大于该数，这一列就往下遍历，行数加一；这种特殊结构使得 target 一直是与右上角的数进行比较。
-
代码实现：
/** * 暴力解法：遍历比较 * @param matrix * @param target * @return */ public boolean findNumberIn2DArray(int[][] matrix, int target) { int rowLength = matrix.length; int colLength = 0; if (rowLength > 0) { colLength = matrix[0].length; } int N = rowLength*colLength; for (int i = 0;i < colLength;i ++){ for (int j = 0;j < rowLength;j ++){ if (target == matrix[j][i]) return true; } } return false; } /** * 行从0开始，列从最大值开始，先比较此时右上角的数，如果小于该数，这一列就可以舍弃，列数减一 * 如果大于该数，这一列就往下遍历，行数加一 * 使得target一直是与右上角的数进行比较 * @param matrix * @param target * @return */ public boolean findNumberIn2DArray1(int[][] matrix, int target) { int rowLength = matrix.length; int colLength = 0; if (rowLength > 0) { colLength = matrix[0].length; } int i = 0; while (i < rowLength && colLength > 0){ if (target == matrix[i][colLength-1]){ return true; }else if (target < matrix[i][colLength-1]){ colLength--; }else if (target > matrix[i][colLength-1]){ i++; } } return false; }
3.剑指 Offer 05. 替换空格
-
题目描述：
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例：
输入：s = “We are happy.”
输出：“We%20are%20happy.” -
解题思路：
- 辅助数组：由于 Java 的字符串是不可变的，定义一个长度三倍的数组，将字符串填充进去，定义一个变量 size 记录长度，最后 new String(arr,0,size)
- StringBuilder 遍历添加，添加逻辑与上面的一样
- 直接调用 API：s.replace(" “,”%20")
-
代码实现：
/** * 辅助数组 * @param s * @return */ public String replaceSpace(String s) { int length = s.length(); char[] Array = new char[length*3]; int size = 0; for (int i = 0;i < length;i++){ char c = s.charAt(i); if (c == ' '){ Array[size++] = '%'; Array[size++] = '2'; Array[size++] = '0'; }else { Array[size++] = s.charAt(i); } } String newStr = new String(Array,0,size); return newStr; } /** * StringBuilder：遍历添加 * @param s * @return */ public String replaceSpace1(String s){ StringBuilder res = new StringBuilder(); for(Character c : s.toCharArray()) { if(c == ' ') res.append("%20"); else res.append(c); } return res.toString(); } /** * 直接使用 API * @param s * @return */ public String replaceSpace2(String s){ return s.replace(" ","%20"); }
4.剑指 Offer 06. 从尾到头打印链表
-
题目描述：
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）
示例：
输入：head = [1,3,2]
输出：[2,3,1] -
思路：
- 辅助栈：由于栈的结构是先入后出，可以先通过遍历将链表的每个节点存入栈中，最后通过循环，将栈顶每个元素都存到数组中。
- 辅助数组倒序遍历：上一个方法不仅需要辅助栈，也需要数组，本方法只需要一个数组就可以完成要求。首先，通过循环得出数组长度，然后在将节点的值存入数组的时候，反着存入数组。
-
代码实现：
/** * 创建一个栈，用于存储链表的节点 * 创建一个指针，初始时指向链表的头节点 * 当指针指向的元素非空时，重复下列操作： * 将指针指向的节点压入栈内 * 将指针移到当前节点的下一个节点 * 获得栈的大小 size，创建一个数组 arr，其大小为 size * 创建下标并初始化 index = 0 * 重复 size 次下列操作： * 从栈内弹出一个节点，将该节点的值存到 arr[index] * 将 index 的值加 1 * 返回 arr * * @param head * @return */ public int[] reversePrint(ListNode head) { Stack<ListNode> stack = new Stack<>(); ListNode temp = head; while (temp != null){ stack.push(temp); temp = temp.next; } int size = stack.size(); int[] arr = new int[size]; for (int i = 0;i < size;i++){ arr[i] = stack.pop().val; } return arr; } /** * 思路二：（速度更快） * 对上面进行优化： * 不使用栈的结构进行存储，而是倒着遍历 * 于是需要先遍历第一遍，获得长度，才能构建数组 * @param head * @return */ public int[] reversePrint2(ListNode head) { ListNode temp = head; int size = 0; while (head != null){ size++; head = head.next; } int[] arr = new int[size]; while (temp != null){ arr[--size] = temp.val; temp = temp.next; } return arr; }
5.剑指 Offer 07. 重建二叉树
-
题目描述：
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出：
前序遍历 preorder = [3,9,20,15,7] 中序遍历 inorder = [9,3,15,20,7]返回如下的二叉树：
3 / \ 9 20 / \ 15 7 -
思路：
前序遍历的顺序是：[根节点|左子树|右子树]
中序遍历的顺序是：[左子树|根节点|右子数]
前序遍历可以得出根节点，然后在中序在找到根节点的位置，左边为左子树，右边为右子树（利用 map 结构存储中序的元素和下标的映射结构，方便查找）
在数组查找的过程中，不断构建节点接上，形成树的结构，这个时候需要用到递归。
- 递推参数：根节点在前序遍历的索引 root、子树在中序遍历的左边界 left、子树在中序遍历的右边界 right
- 终止条件：当 left > right，代表已经越过叶节点，返回 null
- 递推工作：
- 创建根节点 node：preorder[root]
- 划分左右子树：查找根节点在中序遍历 inorder 中的索引 i，使用哈希表存储值与索引的映射
- 创建左右子树：开启左右子树递归
-
代码实现：
/** * 二叉树的前序遍历顺序是：根节点、左子树、右子树，每个子树的遍历顺序同样满足前序遍历顺序。 * * 二叉树的中序遍历顺序是：左子树、根节点、右子树，每个子树的遍历顺序同样满足中序遍历顺序。 * * 前序遍历的第一个节点是根节点，只要找到根节点在中序遍历中的位置， * 在根节点之前被访问的节点都位于左子树，在根节点之后被访问的节点都位于右子树， * 由此可知左子树和右子树分别有多少个节点。 * * 由于树中的节点数量与遍历方式无关，通过中序遍历得知左子树和右子树的节点数量之后， * 可以根据节点数量得到前序遍历中的左子树和右子树的分界， * 因此可以进一步得到左子树和右子树各自的前序遍历和中序遍历， * 可以通过递归的方式，重建左子树和右子树，然后重建整个二叉树。 * * 使用一个 Map 存储中序遍历的每个元素及其对应的下标，目的是为了快速获得一个元素在中序遍历中的位置。 * 调用递归方法，对于前序遍历和中序遍历，下标范围都是从 0 到 n-1，其中 n 是二叉树节点个数。 * * 递归方法的基准情形有两个：判断前序遍历的下标范围的开始和结束， * 若开始大于结束，则当前的二叉树中没有节点，返回空值 null。 * 若开始等于结束，则当前的二叉树中恰好有一个节点，根据节点值创建该节点作为根节点并返回。 * 若开始小于结束，则当前的二叉树中有多个节点。 * * 在中序遍历中得到根节点的位置，从而得到左子树和右子树各自的下标范围和节点数量， * 知道节点数量后，在前序遍历中即可得到左子树和右子树各自的下标范围， * 然后递归重建左子树和右子树，并将左右子树的根节点分别作为当前根节点的左右子节点。 * * @param preorder * @param inorder * @return */ public TreeNode buildTree(int[] preorder, int[] inorder) { if (preorder == null || preorder.length == 0){ return null; } Map<Integer,Integer> map = new HashMap<>(); int length = preorder.length; for (int i = 0;i < length;i++){ map.put(inorder[i],i); } TreeNode root = buildTree(preorder,0,length - 1,inorder,0,length - 1,map); return root; } private TreeNode buildTree(int[] preorder,int preStart,int preEnd,int[] inorder,int inStart,int inEnd,Map<Integer,Integer> map){ if (preStart > preEnd){ return null; } int rootVal = preorder[preStart]; TreeNode root = new TreeNode(rootVal); if (preStart != preEnd) { int rootIndex = map.get(rootVal); //左右子树节点的数量 int leftNodes = rootIndex - inStart, rightNodes = inEnd - rootIndex; TreeNode leftSubtree = buildTree(preorder, preStart + 1, preStart + leftNodes, inorder, inStart, rootIndex - 1, map); TreeNode rightSubtree = buildTree(preorder, preEnd - rightNodes + 1, preEnd, inorder, rootIndex + 1, inEnd, map); root.left = leftSubtree; root.right = rightSubtree; } return root; }
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
