[leetcode] 剑指offer题解（1-10）
在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。
如： 输入：[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3
// 题解一: 原地交换 利用题目中的关键信息——数组元素的索引和值是一对多的关系。
class Solution {
public int findRepeatNumber (int[] nums) {
int i = 0;
// 遍历数组nums，设索引初始值为i=0:
while (i < nums.length) {
// 若 nums[i] = i： 说明此数字已在对应索引位置，无需交换，因此跳过；
if (nums[i] == i) {
i++;
continue;
}
// 若 nums[nums[i]] = nums[i]： 代表索引nums[i]处和索引i处的元素值都为nums[i]，即找到一组重复值，返回此值nums[i]；
if (nums[i] == nums[nums[i]]) return nums[i];
// 交换索引为i和nums[i]的元素值，将此数字交换至对应索引位置。
int tmp = nums[i];
nums[i] = nums[tmp];
nums[tmp] = tmp;
}
return -1;
}
}
// 题解二： 利用辅助的哈希表
class Solution {
public int findRepeatNumber(int[] nums) {
// hashSet不允许有重复的值
Set<Integer> dic = new HashSet<>();
for(int num : nums) {
if(dic.contains(num)) return num;
dic.add(num);
}
return -1;
}
}
// 题解三： 暴力求解
class Solution {
public int findRepeatNumber(int[] nums) {
for (int i = 0; i <nums.length; i++) {
for (int j = i+1 ; j < nums.length; j++) {
// 如果有值相同就返回
if (nums[i] == nums[j]) return nums[i];
}
}
return 0;
}
}
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
如：[
[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]
]
// 二叉搜索
class Solution {
public boolean findNumberIn2DArray(int[][] matrix, int target) {
int i = matrix.length - 1, j = 0;
// 从矩阵 matrix 左下角元素（索引设为 (i, j)）开始遍历，并与目标值对比
while(i >= 0 && j < matrix[0].length)
{
// 当 matrix[i][j] > target 时，执行 i-- ，即消去第 i 行元素；
if(matrix[i][j] > target) i--;
// 当 matrix[i][j] < target 时，执行 j++ ，即消去第 j 列元素；
else if(matrix[i][j] < target) j++;
// 当 matrix[i][j] = target 时，返回 true ，代表找到目标值。
else return true;
}
return false;
}
}
// 暴力求解
class Solution {
public boolean findNumberIn2DArray(int[][] matrix, int target) {
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
if (matrix[i][j] == target) return true;
}
}
return false;
}
}
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
// 遍历添加
class Solution {
public String replaceSpace(String s) {
StringBuilder res = new StringBuilder();
for(Character c : s.toCharArray())
{
// 当 c 为空格时：向 res 后添加字符串 "%20" ；
if(c == ' ') res.append("%20");
// 当 c 不为空格时：向 res 后添加字符 c ；
else res.append(c);
}
return res.toString();
}
}
// 利用char数组
class Solution {
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++] = c;
}
}
String newStr = new String(array, 0, size);
return newStr;
}
}
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
如： 输入：head = [1,3,2]
输出：[2,3,1]
// 利用栈
class Solution {
public int[] reversePrint(ListNode head) {
Stack<Integer> stack = new Stack<>();
int n = 0;
while (head != null) {
stack.add(head.val);
head = head.next;
n++;
}
int[] ans = new int[n];
for (int i = 0; i < n; i++) {
ans[i] = stack.pop();
}
return ans;
}
}
// 头插法
class Solution {
public int[] reversePrint(ListNode head) {
ListNode ans = new ListNode(-1);
int n = 0, i = 0;
while (head != null) {
++n;
ListNode memo = head.next;
head.next = ans.next;
ans.next = head;
head = memo;
}
int[] aw = new int[n];
while (ans.next != null) {
aw[i++] = ans.next.val;
ans = ans.next;
}
return aw;
}
}
输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。(假设输入的前序遍历和中序遍历的结果中都不含重复的数字。)
class Solution {
//利用原理,先序遍历的第一个节点就是根。在中序遍历中通过根 区分哪些是左子树的，哪些是右子树的
//左右子树，递归
HashMap<Integer, Integer> map = new HashMap<>();//标记中序遍历
int[] preorder;//保留的先序遍历
public TreeNode buildTree(int[] preorder, int[] inorder) {
// 保留先序遍历
this.preorder = preorder;
// 使用hashmap标记中序遍历
for (int i = 0; i < preorder.length; i++) {
map.put(inorder[i], i);
}
// 递归
return recursive(0,0,inorder.length-1);
}
class Solution {
private Map<Integer, Integer> indexMap;
public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right,
int inorder_left, int inorder_right) {
if (preorder_left > preorder_right) {
return null;
}
// 前序遍历中的第一个节点就是根节点
int preorder_root = preorder_left;
// 在中序遍历中定位根节点
int inorder_root = indexMap.get(preorder[preorder_root]);
// 先把根节点建立出来
TreeNode root = new TreeNode(preorder[preorder_root]);
// 得到左子树中的节点数目
int size_left_subtree = inorder_root - inorder_left;
// 递归地构造左子树，并连接到根节点
// 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
root.left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree,
inorder_left, inorder_root - 1);
// 递归地构造右子树，并连接到根节点
// 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right,
inorder_root + 1, inorder_right);
return root;
}
public TreeNode buildTree(int[] preorder, int[] inorder) {
int n = preorder.length;
// 构造哈希映射，帮助我们快速定位根节点
indexMap = new HashMap<Integer, Integer>();
for (int i = 0; i < n; i++) {
indexMap.put(inorder[i], i);
}
return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
}
}
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
class CQueue {
LinkedList<Integer> A, B;
public CQueue() {
A = new LinkedList<Integer>();
B = new LinkedList<Integer>();
}
public void appendTail(int value) {
A.addLast(value);
}
public int deleteHead() {
if(!B.isEmpty()) return B.removeLast();
if(A.isEmpty()) return -1;
while(!A.isEmpty())
B.addLast(A.removeLast());
return B.removeLast();
}
}
10_1. 剑指 Offer 10- I. 斐波那契数列
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
// 动态规划
class Solution {
public int fib(int n) {
if (n < 2) return n;
int a = 0, b = 1, c = 1;
for (int i = 3; i <= n; i++) {
a = b;
b = c;
c = a + b;
c %= (1e9+7);
}
return c;
}
}
// 矩阵快速幂
class Solution {
static final int MOD = 1000000007;
public int fib(int n) {
if (n < 2) {
return n;
}
int[][] q = {{1, 1}, {1, 0}};
int[][] res = pow(q, n - 1);
return res[0][0];
}
public int[][] pow(int[][] a, int n) {
int[][] ret = {{1, 0}, {0, 1}};
while (n > 0) {
if ((n & 1) == 1) {
ret = multiply(ret, a);
}
n >>= 1;
a = multiply(a, a);
}
return ret;
}
public int[][] multiply(int[][] a, int[][] b) {
int[][] c = new int[2][2];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
c[i][j] = (int) (((long) a[i][0] * b[0][j] + (long) a[i][1] * b[1][j]) % MOD);
}
}
return c;
}
}
10_2. 剑指 Offer 10- II. 青蛙跳台阶问题
一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
// 动态规划
class Solution {
public int numWays(int n) {
if (n == 0 || n == 1) return 1;
int a=1, b=1, c=2;
for (int i = 3; i <= n; i++) {
a = b;
b = c;
c = (a + b);
c %= (1e9+7);
}
return c;
}
}
1572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
