基础部分
69. x 的平方根
简单
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842...,
由于返回类型是整数，小数部分将被舍去。
class Solution {
public static int mySqrt(int x) {
if (x >= 2147395600) return 46340; //乘积不能超过int
int l = 0, r = x > 46340 ? 46340 : x;
int mid = l + (r-l)/2;
while (true){
int a = mid * mid;
if (a == x || a < x && a + mid + mid + 1 > x) break;
else if (a < x) l = mid + 1;
else r = mid - 1;
mid = l + (r-l)/2;
}
return mid;
}
}
744. 寻找比目标字母大的最小字母
简单
给你一个排序后的字符列表 letters ，列表中只包含小写英文字母。另给出一个目标字母 target，请你寻找在这一有序列表里比目标字母大的最小字母。
在比较时，字母是依序循环出现的。举个例子：
- 如果目标字母
target = 'z'并且字符列表为letters = ['a', 'b']，则答案返回'a'
示例：
输入:
letters = ["c", "f", "j"]
target = "a"
输出: "c"
输入:
letters = ["c", "f", "j"]
target = "c"
输出: "f"
输入:
letters = ["c", "f", "j"]
target = "d"
输出: "f"
输入:
letters = ["c", "f", "j"]
target = "g"
输出: "j"
输入:
letters = ["c", "f", "j"]
target = "j"
输出: "c"
输入:
letters = ["c", "f", "j"]
target = "k"
输出: "c"
提示：
letters长度范围在[2, 10000]区间内。letters仅由小写字母组成，最少包含两个不同的字母。- 目标字母
target是一个小写字母。
class Solution {
public char nextGreatestLetter(char[] letters, char target) {
int l = 0;
int r = letters.length - 1;
while (l <= r){
int mid = (l+r)/2;
if (letters[r] < target) break;
if (letters[mid] > target) r = mid - 1;
else l = mid + 1;
}
return r+1 < letters.length ? letters[r+1] : letters[0];
}
}
540. 有序数组中的单一元素
中等
给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。
示例 1:
输入: [1,1,2,3,3,4,4,8,8]
输出: 2
示例 2:
输入: [3,3,7,7,10,11,11]
输出: 10
注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。
class Solution {
public int singleNonDuplicate(int[] nums) {
int l = 0, r = nums.length - 1;
int mid = (l+r)/2;
while (l <= r){
if (mid > 0 && nums[mid] == nums[mid-1]){
if ((r-mid)%2 == 0) r = mid - 2;
else l = mid + 1;
}else if (mid < nums.length-1 && nums[mid] == nums[mid+1]){
if ((r-mid)%2 == 0) l = mid + 2;
else r = mid - 1;
}else break;
mid = (l+r)/2;
}
return nums[mid];
}
}
278. 第一个错误的版本
简单
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例:
给定 n = 5，并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
public class Solution extends VersionControl {
public int firstBadVersion(int n) {
int l = 1, r = n;
int mid = l + (r-l)/2;
while (l < r){
if (isBadVersion(mid)) r = mid-1;
else l = mid+1;
mid = l + (r-l)/2; //(l+r)/2容易超过int最大值
}
return isBadVersion(mid) ? mid : mid+1;
}
}
153. 寻找旋转排序数组中的最小值
中等
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。
示例 1:
输入: [3,4,5,1,2]
输出: 1
示例 2:
输入: [4,5,6,7,0,1,2]
输出: 0
class Solution {
public int findMin(int[] nums) {
int l = 0, r = nums.length-1;
int mid = l + (r-l)/2;
while (l < r){
if (nums[mid] > nums[r]) l = mid + 1;
else if (nums[mid] < nums[l])
r = mid; //mid有可能是答案，所以不能 mid-1
else if (nums[mid] == nums[r]) r--;
else return nums[l]; //l->r是升序的
mid = l + (r-l)/2;
}
return nums[mid];
}
}
34. 在排序数组中查找元素的第一个和最后一个位置
中等
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值，返回 [-1, -1]。
示例 1:
输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:
输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]
class Solution {
public int[] searchRange(int[] nums, int target) {
if (nums.length == 0) return new int[]{-1,-1};
int l = 0, r = nums.length - 1;
int mid = l + (r-l)/2;
while (l < r){
if (nums[mid] == target) break;
else if (nums[mid] > target) r = mid - 1;
else l = mid + 1;
mid = l + (r-l)/2;
}
if (nums[mid] != target) return new int[]{-1,-1};
l = 0;
r = mid;
int i = l + (r-l)/2;
while (l < r){
if (nums[i] == target) r = i - 1;
else l = i + 1;
i = l + (r-l)/2;
}
i = nums[i] == target ? i : i+1;
l = mid;
r = nums.length - 1;
int j = l + (r-l)/2;
while (l < r){
if (nums[j] == target) l = j + 1;
else r = j - 1;
j = l + (r-l)/2;
}
j = nums[j] == target ? j : j-1;
return new int[]{i,j};
}
}
频率排序
668,410,1044,887,4,300,483,658,354,911,644,862,793,718,378,1095,33,497