系列汇总：《刷题系列汇总》
——————《剑指offeer》———————
1. 旋转数组的最小数字
- 题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 - 优秀思路：【二分查找】利用中间点和右端点的大小关系判断最小元素的位置：
- ① array[mid] < array[last]：最小值在左边，例如 5 6 1 2 3 4
- ② array[mid] > array[last]：最大值在右边，例如 5 6 7 8 1 2
- ③ array[mid] = array[last]：说不准，故逐渐缩小右端范围
- 还有一种特殊情况：array[first] < array[last]，说明是递增数列
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array == null || array.length == 0) return 0;
int first = 0;
int last = array.length-1;
while(last > first){
int mid = (first+last) >> 1;
if(array[first] < array[last]){ // 说明为递增序列
return array[first];
}else if(array[mid] < array[last]){ // 说明最小值在左边
last = mid;
}else if(array[mid] > array[last]){ // 说明最小值在右边
first = mid+1;
}else{ // array[mid] == array[last] 时，从尾端逐渐缩小范围
last--;
}
}
return array[first];
}
}
2. 数字在升序数组中出现的次数
- 题目描述：统计一个数字在升序数组中出现的次数。
- 我的思路1：【二分查找】① 二分查找确定该数位置；② 前后查找其他该数
public class Solution {
public int GetNumberOfK(int [] array , int k) {
if(array == null || array.length == 0) return 0;
int start = 0;
int end = array.length-1;
if(k > array[end] || k < array[0]) return 0;
// 1、二分查找找到该元素的位置
int mid = 0;
while(end > start){
mid = (start + end) >> 1;
if(array[mid] == k) break;
if(array[mid] > k) end = mid-1;
if(array[mid] < k) start = mid + 1;
}
// 2、前后寻找该元素的数量
if(array[mid] != k) return 0;
int count = 1;
int tempMid = mid;
while(mid < array.length-1 && array[++mid] == k){
count++;
}
while(tempMid > 0 && array[--tempMid] == k){
count++;
}
return count;
}
}
- 我的思路2：【递归二分查找】
public class Solution {
int count = 0;
public int GetNumberOfK(int [] array , int k) {
if(array == null || array.length == 0) return 0;
int end = array.length-1;
if(k > array[end] || k < array[0]) return 0;
dfs(array,k,0,end);
return count;
}
void dfs(int[] array,int k,int start,int end){
if(start > end) return;
int mid = (start + end) >> 1;
if(array[mid] == k){
count++;
dfs(array,k,start,mid-1);
dfs(array,k,mid+1,end);
}else if(array[mid] > k){
dfs(array,k,start,mid-1);
}else{
dfs(array,k,mid+1,end);
}
}
}
- 优秀思路：无
——————《LeectCode》———————
1. 寻找两个正序数组的中位数（留）
-
题目描述：给定两个大小分别为
m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的 中位数 。
-
优秀思路：
2. 最长递增子序列（很妙，需重写）
- 题目描述：给你一个整数数组
nums，找到其中最长严格递增子序列的长度。子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如[3,6,2,7]是数组[0,3,1,6,2,2,7]的子序列。 - 优秀思路1：【动态规划】给每个元素一个初始的LIS长度1，然后从第2个元素开始，每次比较前面所有元素与其的大小值，如果x小于它，则其LIS长度值 = x的LIS长度值+1——《教程》
- 我的实现（22%）：
class Solution {
public int lengthOfLIS(int[] nums) {
int len = nums.length;
int res = 0;
int[] numLIS = new int[len];
for(int i = 1;i < len;i++){
for(int j = 0;j < i;j++){
if(nums[i] > nums[j]){
numLIS[i] = Math.max(numLIS[i],numLIS[j]+1);
res = Math.max(numLIS[i],res); // 这句没必要比较这么多次，放在本层循环外
}
}
}
return res+1;
}
}
- 我的实现改进（根据官方思路，75%）：
class Solution {
public int lengthOfLIS(int[] nums) {
int len = nums.length;
if(nums == null || len == 0) return 0;
if(len == 1) return 1;
int res = 0;
int[] numLIS = new int[len];
for(int i = 1;i < len;i++){
for(int j = 0;j < i;j++){
if(nums[i] > nums[j]){
numLIS[i] = Math.max(numLIS[i],numLIS[j]+1);
}
}
res = Math.max(numLIS[i],res);
}
return res+1;
}
}
- 优秀思路2：【】很具小巧思。新建数组 cell，用于保存最长上升子序列。对原序列进行遍历，将每位元素二分插入 cell 中。如果 cell 中元素都比它小，将它插到最后否则，用它覆盖掉比它大的元素中最小的那个。总之，思想就是让 cell 中存储比较小的元素。这样，cell 未必是真实的最长上升子序列，但长度是对的。
举例：
对于【5 6 1 2 3 4】
① cell = 【5】res++
② cell = 【5 6 】res++
③ cell = 【1 6】1 替换 5
④ cell = 【1 2】2 替换 6
⑤ cell = 【1 2 3】res++
⑥ cell = 【1 2 3 4】res++
class Solution {
public int lengthOfLIS(int[] nums) {
int[] cell = new int[nums.length]; // 保存当前子序列
int res = 0;
for(int num : nums) {
int i = 0, j = res;
// 二分查找：寻找当前值num在cell中的位置
while(i < j) {
int m = (i + j) / 2;
if(cell[m] < num) i = m + 1;
else j = m;
}
cell[i] = num; // 替换i处的值为num
if(res == j) res++; // 如果num比cell所有值都大，则终止时 i = res.length;
}
return res;
}
}
3. x 的平方根
- 题目描述：实现
int sqrt(int x)函数。计算并返回x的平方根，其中x是非负整数。由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 - 我的思路（100%）：【二分查找】注意用除法不同乘法，可以有效防止越界
class Solution {
public int mySqrt(int x) {
if(x == 0) return 0;
int left = 1;
int right = x;
while(left <= right){
int half = (left+right) >> 1;
if(x/half < half){
right = half;
}else if(x/(half+1) < half+1){
return half;
}else{
left = half;
}
}
return left;
}
}
4. 搜索二维矩阵
- 题目描述：编写一个高效的算法来判断
m x n矩阵中，是否存在一个目标值。该矩阵具有如下特性：每行中的整数从左到右按升序排列。每行的第一个整数大于前一行的最后一个整数。
- 我的思路（100%）：【普通查找】从中间行开头开始搜索，设立vis矩阵记录访问状态，一旦发现重复访问则说明不存在该元素。
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int row = matrix.length;
int col = matrix[0].length;
if(row == 0 || col == 0 || target > matrix[row-1][col-1] || target < matrix[0][0]) return false;
// 中间行开头开始搜索
int i = row >> 1;
int j = 0;
boolean[][] vis = new boolean[row][col];
while(i >= 0 && i < row && j < col){
if(vis[i][j]) return false;
else{
vis[i][j] = true;
if(matrix[i][j] == target) return true;
else if(matrix[i][j] > target){// 上移
i--;
}else{
if(matrix[i][col-1] < target) i++; // 下移：当前行最后一个值小于target
else{
j++; // 右移：target位于当前行之间
}
}
}
}
return false;
}
}
- 优秀思路1：【坐标轴法】从左下角开始搜索，当前值小于target则右移，反之则上移
- 优秀思路2：【两次二分查找】第一次寻找其所在行值，第二次寻找其所在列值
5. 搜索旋转排序数组
- 题目描述：整数数组
nums按升序排列，数组中的值 互不相同 。在传递给函数之前，nums在预先未知的某个下标k（0 <= k < nums.length）上进行了 旋转，使数组变为[nums[k], nums[k+1], ...,nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从0开始 计数）。例如，[0,1,2,4,5,6,7]在下标3处经旋转后可能变为[4,5,6,7,0,1,2]。给你 旋转后 的数组nums和一个整数target，如果nums中存在这个目标值target，则返回它的下标，否则返回-1。 - 我的思路（不如下面思路，100%）：【两次二分查找】① 先通过二分查找判断旋转部分起始点（最小值）；② 根据不同情况，判断对应区间内是否存在该值。
- ① 递增序列：[0,len-1]
- ② target < nums[0]：[min,len-1]
- ③ target > nums[0]：[0.min-1]
class Solution {
public int search(int[] nums, int target) {
int len = nums.length;
if(nums == null || len == 0) return -1;
int first = 0;
int last = nums.length-1;
// 找到最小值位置
if(nums[first] < nums[last]) return search(nums,target,0,last);
while(last > first){
int mid = (first+last) >> 1;
if(nums[mid] < nums[last]){ // 说明最小值在左边
last = mid;
}else{ // 说明最小值在右边
first = mid+1;
}
}
int res = -1;
if(target == nums[first]) return first;
else if(target < nums[first] || (first-1 >=0 && target > nums[first-1])) return -1;
else{
if(target >= nums[0]) res = search(nums,target,0,first-1);
else res = search(nums,target,first,len-1);
}
return res;
}
// 二分查找判断 target 在指定区间内是否群在
int search(int[] nums, int target,int start,int end){
int res = -1;
while(end >= start){
int mid = (start+end) >> 1;
if(nums[mid] == target){
return mid;
}else if(nums[mid] < target){
start = mid+1;
}else{
end = mid-1;
}
}
return res;
}
}
- 优秀思路：【单词二分查找】并不用像我那样找到最小点，每次找中点，根据不同情况改变左右界即可，核心在于要认识到，对于旋转序列来说，分成两部分后，一定有一部分是有序的！
- 1）
[0,mid]区间递增- ①
target在其中：right = mid - 1 - ②
target不在其中：left = mid + 1
- ①
- 2）
[0,mid]区间非递增，由于旋转序列的特点，则说明[mid,len-1]递增- ③
target在[mid,len-1]区间内：l = mid + 1; - ④
target不在[mid,len-1]区间内：r = mid - 1;
- ③
- 1）
class Solution {
public int search(int[] nums, int target) {
int len = nums.length;
if (len == 0) return -1;
if (len == 1) return nums[0] == target ? 0 : -1;
int l = 0, r = len - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (nums[mid] == target) {
return mid;
}
if (nums[0] <= nums[mid]) { // [0,mid]区间递增
if (nums[0] <= target && target < nums[mid]) {
r = mid - 1;
} else {
l = mid + 1;
}
} else {
if (nums[mid] < target && target <= nums[len - 1]) {
l = mid + 1;
} else {
r = mid - 1;
}
}
}
return -1;
}
}
6. 二分查找
- 题目描述：给定一个
n个元素有序的（升序）整型数组nums和一个目标值target，写一个函数搜索nums中的target，如果目标值存在返回下标，否则返回-1。 - 我的思路（优秀，100%）：
class Solution {
public int search(int[] nums, int target) {
int len = nums.length;
if(len == 0 || target < nums[0] || target > nums[len-1]) return -1;
int left = 0;
int right = len - 1;
while(right >= left){
int mid = (left + right) >> 1;
if(target == nums[mid]) return mid;
else if(target > nums[mid]) left = mid + 1;
else right = mid - 1;
}
return -1;
}
}
7. 搜索旋转排序数组 II（在5的基础上，元素可能重复）
- 题目描述：已知存在一个按非降序排列的整数数组
nums，数组中的值不必互不相同。在传递给函数之前，nums在预先未知的某个下标k（0 <= k < nums.length）上进行了 旋转 ，使数组变为[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从0开始 计数）。例如，[0,1,2,4,4,4,5,6,6,7]在下标5处经旋转后可能变为[4,5,6,6,7,0,1,2,4,4]。给你 旋转后 的数组nums和一个整数target，请你编写一个函数来判断给定的目标值是否存在于数组中。如果nums中存在这个目标值target，则返回true，否则返回false。 - 优秀思路：需认识到两点：① 对于旋转序列来说，分成两部分后，一定有一部分是有序的！② 若可能含有重复元素的话，则序列尾元素可能≤头元素。核心就是对于②中两种情况的处理
nums[l] == nums[mid] == nums[r]：不确定在哪边，故缩短两端范围nums[l] == nums[mid] && nums[mid] > nums[r]：可以确定在右边
class Solution {
public boolean search(int[] nums, int target) {
int len = nums.length;
if (len == 0) return false;
if (nums[0] == target || nums[len-1] == target) return true;
int l = 0, r = len - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (nums[mid] == target) {
return true;
}
if (nums[l] == nums[mid] && nums[mid] == nums[r]){ // target在哪边都有可能，故缩小范围
r--;
l++;
} else if (nums[l] <= nums[mid]) { // [0,mid]区间递增
if (nums[l] <= target && target < nums[mid]) {
r = mid - 1;
} else {
l = mid + 1;
}
} else {
if (nums[mid] < target && target <= nums[len - 1]) {
l = mid + 1;
} else {
r = mid - 1;
}
}
}
return false;
}
}
8. 俄罗斯套娃信封问题（动态规划待补充）
- 题目描述：给你一个二维整数数组
envelopes，其中envelopes[i] = [wi, hi]，表示第i个信封的宽度和高度。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。请计算 最多能有多少个 信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。注意：不允许旋转信封。 - 一般思路：【动态规划】
- 优秀思路：【二分查找+动态规划】
9. 在排序数组中查找元素的第一个和最后一个位置
- 题目描述：给定一个按照升序排列的整数数组
nums，和一个目标值target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。 - 我的思路（100%）：【二分查找+线性查找】找到该值后再进行前后搜索
class Solution {
public int[] searchRange(int[] nums, int target) {
int len = nums.length;
if(len == 0 || target < nums[0] || target > nums[len-1]) return new int[]{-1,-1};
int left = 0;
int right = len - 1;
// 找到出现target的位置
int mid = -1;
int flag = 0;
while(right >= left){
mid = (left + right) >> 1;
if(target == nums[mid]){
flag = 1;
break;
}
else if(target > nums[mid]) left = mid + 1;
else right = mid - 1;
}
if(flag == 0) return new int[]{-1,-1};
// 前后寻找起点和终点
int start = mid,end = mid;
if(nums[0] == target) start = 0;
else{
while(start > 0 && nums[start] == target) start--;
start++;
}
if(nums[len-1] == target) end = len-1;
else{
while(end < len-1 && nums[end] == target) end++;
end--;
}
return new int[]{start,end};
}
}
- 优秀思路：【二分查找】通过二分查找分别找到第一个出现的target位置和最后一个出现的target位置，注意两个地方：
- ① 二分查找要写成找一个出现位置的形式
- ② 求第二部分的时候很妙，直接将target+1求位置，位置-1即为target最后出现的位置
class Solution {
public int[] searchRange(int[] nums, int target) {
int l = search(nums,target); // 找 target 第一个出现的地方
int r = search(nums,target+1); // 找 大于target 的第一个值出现的地方（即使该值不存在也没关系）
// 确认是否真的是target值
if(l == nums.length || nums[l] != target)
return new int[]{-1,-1};
return new int[]{l,r-1};
}
//找 target 第一个出现的地方
public int search(int[] nums,int target){
int l = 0,r = nums.length-1;
while(l < r){
int mid = (r+l) >> 1;
if(nums[mid] >= target) r = mid; // 等于的时候仍改变右边界，向左边逼近，以找到第一个出现的地方
else l = mid+1;
}
return l;
}
}
10. 鸡蛋掉落【动态规划，待补充】
- 题目描述：给你
k枚相同的鸡蛋，并可以使用一栋从第1层到第n层共有n层楼的建筑。已知存在楼层f，满足0 <= f <= n，任何从 高于f的楼层落下的鸡蛋都会碎，从f楼层或比它低的楼层落下的鸡蛋都不会破。每次操作，你可以取一枚没有碎的鸡蛋并把它从任一楼层x扔下（满足1 <= x <= n）。如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。请你计算并返回要确定f确切的值 的 最小操作次数 是多少？ - 优秀思路：
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
