基礎部分
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