一,求平方根
实现 int sqrt(int x) 函数。
计算并返回 x 的平方根,其中 x 是非负整数。
由于返回类型是整数,结果只保留整数的部分,小数部分将被舍去。
示例 1:
输入: 4
输出: 2
示例 2:
输入: 8
输出: 2
说明: 8 的平方根是 2.82842…,
由于返回类型是整数,小数部分将被舍去。
解法一:二分查找法
class Solution {
public int mySqrt(int x) {
if (x < 2)
return x;
int num;
int pivot, left = 2, right = x / 2;
while (left <= right) {
pivot = left + (right - left) / 2;
num = x/pivot; //注意此处的处理
if (num < pivot) right = pivot - 1;
else if (num > pivot) left = pivot + 1;
else return pivot;
}
return right;
}
}
class Solution {
public int mySqrt(int x) {
if (x < 2) return x;
long num; //注意num是用的数据类型
int pivot, left = 2, right = x / 2;
while (left <= right) {
pivot = left + (right - left) / 2;
num = (long)pivot * pivot;
if (num > x) right = pivot - 1;
else if (num < x) left = pivot + 1;
else return pivot;
}
return right;
}
}
【注】:
除法没有四舍五入,小数取0.
基本数据类型的取值范围:
byte:-2^7 ~ 2^7-1,即-128 ~ 127。1字节。Byte。末尾加B
short:-2^15 ~ 2^15-1,即-32768 ~ 32767。2字节。Short。末尾加S
有符号int:-2^31 ~ 2^31-1,即-2147483648 ~ 2147483647。4字节。Integer。
无符号int:0~2^32-1。
long:-2^63 ~ 2^63-1,即-9223372036854774808 ~ 9223372036854774807。8字节。Long。末尾加L。(也可以不加L)
浮点型:
1、Float:比特数为32,4字节,有效数字为6-7,数值范围为 -3.4E+38 和 3.4E+38
2、Double:比特数为64,8字节有,效数字为15-16,数值范围为-1.7E-308~1.7E+308
可根据应用程序的需求将浮点变量声明为 float 或 double。这两种类型之间的主要差异在于它们可表示的基数、它们需要的存储以及它们的范围。
解法二:递归法
class Solution {
public int mySqrt(int x) {
if (x < 2) return x;
int left = mySqrt(x >> 2) << 1;
int right = left + 1;
return (long)right * right > x ? left : right;
}
}
二、大于给定元素的最小元素
题目描述:给定一个有序的字符数组 letters 和一个字符 target,要求找出 letters 中大于 target 的最小字符,如果找不到就返回第 1 个字符。
例:
Input:
letters = [“c”, “f”, “j”]
target = “d”
Output: “f”
Input:
letters = [“c”, “f”, “j”]
target = “k”
Output: “c”
public char nextGreatestLetter(char[] letters, char target) {
int left=0;
int right=letters.length - 1;
while(left<=right)
{
int mid=left+(right-left)/2;
if(letters[mid]<=target)
left=mid+1;
else
right=mid-1;
}
return left< letters.length ? letters[left] : letters[0];
}
三、第一个错误的版本
题目描述:给定一个元素 n 代表有 [1, 2, …, n] 版本,在第 x 位置开始出现错误版本,导致后面的版本都错误。可以调用 isBadVersion(int x) 知道某个版本是否错误,要求找到第一个错误的版本。
public int firstBadVersion(int n) {
int left=1;
int right=n;
while(left<=right)
{
int mid = left+(right-left)/2;
if(isBadVersion(mid))
right=mid-1;
else
left=mid+1;
}
return left;
}
四、旋转数组的最小数字
假设按照升序排序的数组在预先未知的某个点上进行了旋转。
( 例如,数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
请找出其中最小的元素。
你可以假设数组中不存在重复元素。
解法一:
直接遍历
class Solution {
public int findMin(int[] nums) {
for(int i=0;i<nums.length-1;i++)
{
if(nums[i]>nums[i+1]){
return nums[i+1];
}
}
return nums[0];
}
}
解法二:
二分法
public int findMin(int[] nums) {
int l = 0, h = nums.length - 1;
while (l < h) {
int m = l + (h - l) / 2;
if (nums[m] <= nums[h]) {
h = m;
} else {
l = m + 1;
}
}
return nums[l];
}
五、查找区间
给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
你的算法时间复杂度必须是 O(log n) 级别。
如果数组中不存在目标值,返回 [-1, -1]。
解法一:
双指针
public int[] searchRange(int[] nums, int target) {
int left=0;
int right=nums.length-1;
int arr[]={-1,-1};
while(left<=right)
{
if(nums[left]==target&&nums[right]==target)
{
arr[0]=left;
arr[1]=right;
break;
}
if(nums[left]!=target)
left++;
if(nums[right]!=target)
right--;
}
return arr;
}
解法二:
二分法,进行两次二分法,第一次查找最左边的,第二次查找最右边的
class Solution {
// returns leftmost (or rightmost) index at which `target` should be
// inserted in sorted array `nums` via binary search.
private int extremeInsertionIndex(int[] nums, int target, boolean left) {
int lo = 0;
int hi = nums.length;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (nums[mid] > target || (left && target == nums[mid])) {
hi = mid;
}
else {
lo = mid+1;
}
}
return lo;
}
public int[] searchRange(int[] nums, int target) {
int[] targetRange = {-1, -1};
int leftIdx = extremeInsertionIndex(nums, target, true);
// assert that `leftIdx` is within the array bounds and that `target`
// is actually in `nums`.
if (leftIdx == nums.length || nums[leftIdx] != target) {
return targetRange;
}
targetRange[0] = leftIdx;
targetRange[1] = extremeInsertionIndex(nums, target, false)-1;
return targetRange;
}
}
六、数组中的单一元素
给定一个只包含整数的有序数组,每个元素都会出现两次,唯有一个数只会出现一次,找出这个数。
解法一:二分法
奇数长度的数组首尾元素索引都为偶数,因此我们可以将 lo 和 hi 设置为数组首尾。
我们需要确保 mid 是偶数,如果为奇数,则将其减 1。
然后,我们检查 mid 的元素是否与其后面的索引相同。
如果相同,则我们知道 mid 不是单个元素。且单个元素在 mid 之后。则我们将 lo 设置为 mid + 2。
如果不是,则我们知道单个元素位于 mid,或者在 mid 之前。我们将 hi 设置为 mid。
一旦 lo == hi,则当前搜索空间为 1 个元素,那么该元素为单个元素,我们将返回它。
class Solution {
public int singleNonDuplicate(int[] nums) {
int lo = 0;
int hi = nums.length - 1;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (mid % 2 == 1) mid--;
if (nums[mid] == nums[mid + 1]) {
lo = mid + 2;
} else {
hi = mid;
}
}
return nums[lo];
}
}
解法二:异或
class Solution {
public int singleNonDuplicate(int[] nums) {
int first=nums[0];
for (int i = 1; i < nums.length; i++) {
first=first^nums[i];
}
return first;
}
}
小结
遇到有序的数组,优先想到二分查找法,遇到无序的数组,优先想到双指针。