首页目录 点击查看
第一题
- 难度：中等
- 题目： 33. 搜索旋转排序数组
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
你可以假设数组中不存在重复的元素。
你的算法时间复杂度必须是 O(log n) 级别。
示例
输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1
解题思路
- 这道题，要求是要达到O(log n)级别，所以，只能采用二分法来处理，二分法也就是把原有数组一分为二，如果有一侧满足，就抛弃另一侧，知道中间得数等于target.
我的答案
var search = function (nums, target) {
let left = 0;
let right = nums.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2)
if (nums[mid] === target) {
return mid
}
if (nums[left] <= nums[mid]) {
if (nums[left] <= target && target <= nums[mid]) {
right = mid - 1
} else {
left = mid + 1
}
}
if (nums[mid] <= nums[right]) {
if (nums[mid] <= target && target <= nums[right]) {
left = mid + 1
} else {
right = mid - 1
}
}
}
return -1
};
-
时间复杂度：O(log n)
image.png - 下面这个答案是不符合条件的，o(n）级别，也贴出来，性能几乎差不多
var search = function (nums, target) {
for (let i = 0; i <= nums.length - 1; i++) {
if (nums[i] === target) {
return i
}
}
return -1
};
-
时间复杂度：O(n)
image.png
第二题
- 难度：中
- 题目：81. 搜索旋转排序数组 II
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。
编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。
示例
输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true
输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false
解题思路
- 这道题和上一道题的思路几乎一致，只是要注意，中间会有重复的，所以需要对重复项做处理，我这里有两种方法，一种是new set去重，但是复杂度明显就增加了，还有另外一个是对重复项跳过。
我的答案
- new Set去重，会增加时间复杂度，不符合
var search = function (nums, target) {
nums = Array.from(new Set(nums))
let left = 0;
let right = nums.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2)
if (nums[mid] === target) {
return true
}
if (nums[left] <= nums[mid]) {
if (nums[left] <= target && target <= nums[mid]) {
right = mid - 1
} else {
left = mid + 1
}
}
if (nums[mid] <= nums[right]) {
if (nums[mid] <= target && target <= nums[right]) {
left = mid + 1
} else {
right = mid - 1
}
}
}
return false
};
性能确实一般般
image.png
var search = function (nums, target) {
let left = 0;
let right = nums.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2)
if (nums[mid] === target) {
return true
}
if (nums[left] == nums[mid]) {
left++
continue
}
if (nums[left] <= nums[mid]) {
if (nums[left] <= target && target <= nums[mid]) {
right = mid - 1
} else {
left = mid + 1
}
}
if (nums[mid] <= nums[right]) {
if (nums[mid] <= target && target <= nums[right]) {
left = mid + 1
} else {
right = mid - 1
}
}
}
return false
};
-
时间复杂度：O(N)
image.png
没有增加时间复杂度，同时速度提升非常明显
第三题
- 难度：中等
- 题目：153. 寻找旋转排序数组中的最小值
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。
示例
输入: [3,4,5,1,2]
输出: 1
输入: [4,5,6,7,0,1,2]
输出: 0
解题思路
- 用二分法查找，需要始终将目标值（这里是最小值）套住，并不断收缩左边界或右边界。
左、中、右三个位置的值相比较，有以下几种情况：
- 左值 < 中值, 中值 < 右值 ：没有旋转，最小值在最左边，可以收缩右边界
右
中
左
- 左值 > 中值, 中值 < 右值 ：有旋转，最小值在左半边，可以收缩右边界
左
右
中
- 左值 < 中值, 中值 > 右值 ：有旋转，最小值在右半边，可以收缩左边界
中
左
右
分析前面三种可能的情况，会发现情况1、2是一类，情况3是另一类。
如果中值 < 右值，则最小值在左半边，可以收缩右边界。
如果中值 > 右值，则最小值在右半边，可以收缩左边界。
我的答案
var findMin = function (nums) {
let left = 0;
let right = nums.length - 1;
while (left < right) {
let mid = Math.floor((left + right) / 2);
if (nums[mid] > nums[right]) {
left = mid + 1
} else {
right = mid
}
}
return nums[left]
};
image.png
第四题
- 难度：中等
- 题目：34. 在排序数组中查找元素的第一个和最后一个位置
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。
示例
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
解题思路
- 这道题和33题类似，只是这里需要注意的是，如何找出最小角标的相同的数字，和最大角标的相同的数字，就需要在mid===target时多做一层判断。
我的答案
var searchRange = function (nums, target) {
if (!nums.length) { return [-1, -1] }
let start = 0;
let end = 0
let left = 0;
let right = nums.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2);
if (nums[mid] === target) {
start = mid;
end = mid;
while (start > left && nums[start] === nums[start - 1]) start--;
while (end < right && nums[end] === nums[end + 1]) end++;
return [start, end]
} else if (nums[mid] > target) {
right = mid - 1
} else if (nums[mid] < target) {
left = mid + 1
}
}
return [-1, -1]
};
-
时间复杂度：O(logN)
image.png
第五题
- 难度：中等
- 题目：74. 搜索二维矩阵
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性： - 每行中的整数从左到右按升序排列。
- 每行的第一个整数大于前一行的最后一个整数。
示例
输入:
matrix = [
[1, 3, 5, 7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
target = 3
输出: true
输入:
matrix = [
[1, 3, 5, 7],
[10, 11, 16, 20],
[23, 30, 34, 50]
]
target = 13
输出: false
解题思路
- 这道题我的想法是使用双重二分法，第一层找出target所在的数组，第二层找出target所在的位置。
我的答案
var searchMatrix = function (matrix, target) {
let left = 0;
let right = matrix.length - 1;
while (left <= right) {
let mid = Math.floor((left + right) / 2)
let len = matrix[mid].length
if (matrix[mid][0] <= target && target <= matrix[mid][len - 1]) {
let start = 0;
let end = len - 1;
while (start <= end) {
let iMid = Math.floor((start + end) / 2);
if (matrix[mid][iMid] === target) {
return true
} else if (target < matrix[mid][iMid]) {
end = iMid - 1
} else {
start = iMid + 1
}
}
return false
} else if (target > matrix[mid][len - 1]) {
left = mid + 1
} else {
right = mid - 1
}
}
return false
};
-
时间复杂度：O(logN)
image.png