文章目录
69 x的平方根
题目描述
二分查找前提：
套二分查找模板：
这里的判断条件是找mid的平方是否大于x,若小于等于则左边界移到mid+1,大于则右边界缩回到mid-1;最后返回right;
class Solution {
public int mySqrt(int x) {
if(x==0||x==1){
return x;
}
int left=1;
int right=x;
while(left<=right){//这里是否取等看题目要求，题目这里要取整并往下取，所以这里要小于等于
int mid=left+(right-left)/2;
if(( long)mid*mid>x){
right=mid-1;
}
else {
left=mid+1;
}
}
return right;
}
}
33搜索旋转排序树
题目描述
思路
1.暴力法
直接忽视题目要求，采用线性扫描
class Solution {
public int search(int[] nums, int target) {
for(int i=0;i<nums.length;i++){
if(nums[i]==target){
return i;
}
}
return -1;
}
}
2.二分查找
class Solution {
public int search(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] == target) {
return mid;
} else if (nums[mid] < nums[right]) { // 如果中间的数小于右边的数，则右边是有序的;反之，左边是有序的
if (nums[mid] < target && target <= nums[right]) { // target在右侧有序的区间
left = mid + 1;
} else { // 在左侧无序区间
right = mid - 1;
}
} else { // 左边是有序的
if (nums[left] <= target && target < nums[mid]) {//在左边有序区间
right = mid - 1;
} else {//在右边无序区间
left = mid + 1;
}
}
}
return -1;
}
}
面试题10.03搜索旋转数组
public int search(int[] arr, int target) {
int left = 0, right = arr.length - 1;
if(right==-1){
return -1;
}
while (left < right) {
int mid = (left + right) / 2;
if (arr[mid]>arr[left]) {//左边有序，
if(target>=arr[left]&&target<=arr[mid]){//若目标值在左边有序区间
right=mid;
}
else{//在右边则左边界移到mid+1
left=mid+1;
}
} else if (arr[mid] < arr[left]) { // 如果中间的数小于左边的数，则右边是有序的
if (target>=arr[left]||target<=arr[mid]) { // target在左侧无序的区间
right=mid;
} else { // 在右侧有序区间
left=mid+1 ;
}
} else { //arr[left]==arr[mid]，说明有重复值
if (arr[left] != target) { // 如果左值不等于目标，说明还没找到，需逐一清理重复值。
left++;
} else { // 如果左值等于目标，说明已经找到最左边的目标值
right = left; // 将右边界移动到left，循环结束
}
}
}
return (arr[left]==target)?left:-1;
}
}
153寻找排序数组中最小的值
题目描述
思路
1.暴力法
直接线性遍历，年历一次找到最小值，再将最小值与下一个值遍历，最后返回
class Solution {
public int findMin(int[] nums) {
int min=Integer.MAX_VALUE;
for(int i=0;i<nums.length;i++){
min=Math.min(min,nums[i]);
}
return min;
}
}
2.二分查找
class Solution {
public int findMin(int[] nums) {
int left = 0, right = nums.length - 1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[mid]>nums[right]){//说明最小的数在右区间，则左边界移动
left=mid+1;
}
else{//说明最小的数在左区间，则右边界移动
right=mid;
}
}
return nums[left];//找最小值，应该找左边界下标，因为为升序排列
}
}
154寻找排序数组中最小的值II
class Solution {
public int minArray(int[] numbers) {
int left=0,right=numbers.length-1;
while(left<right){
int mid=left+(right-left)/2;
if(numbers[mid]>numbers[right]){//右边有序
left=mid+1;
}
else if(numbers[mid]<numbers[right]){
right=mid;
}
else{
right--;//相等时右边界往左缩小一个
}
}
return numbers[left];
}
}
852山脉数组的峰顶索引
题目描述
class Solution {
public int peakIndexInMountainArray(int[] A) {
int left=0,right=A.length-1;
while(left<right){
int mid=left+(right-left)/2;
if(A[mid]>A[right]){//如果中间元素大于右边界元素，说明峰顶元素在右边界的左边，索引右边界往左移动一步
right--;
}
else{//如果中间元素小于等于右边界的元素，说明峰顶在中间元素左边，则left移到mid+1位置
left=mid+1;
}
}
return left;
}
}
367有效的完全平方根
题目描述
思路
二分查找，套模板
class Solution {
public boolean isPerfectSquare(int num) {
if(num==1){
return true;
}
int left=1;
int right=num;
while(left<right){
int mid=left+(right-left)/2;
if((long)mid*mid>num){
right=mid-1;
}
else if((long)mid*mid<num){
left=mid+1;
}
else{
return true;
}
}
return left*left==num;
}
}
374猜数字大小
题目描述
public class Solution extends GuessGame {
public int guessNumber(int n) {
int left=1,right=n;
while(left<right){
int mid=left+(right-left)/2;
if(guess(mid)==-1){//说明mid大于该数，右边界移到mid-1处
right=mid-1;
}
else if(guess(mid)==1){//说明mid小于该数，左边界移到mid+1处
left=mid+1;
}
else{//mid刚好等于该数，直接返回
return mid;
}
}
return left;
}
}
35搜索插入位置
题目描述
思路
套二分查找模板
class Solution {
public int searchInsert(int[] nums, int target) {
if(nums==null||target<nums[0]){
return 0;
}
if(nums[nums.length-1]<target){
return nums.length;
}
int left=0,right=nums.length-1;
while(left<=right){
int mid=left+(right-left)/2;
if(target>nums[mid]){
left=mid+1;
}
else if(target<nums[mid]){
right=mid-1;
}
else{
return mid;
}
}
return left;
}
}
162寻找峰值
题目描述
class Solution {
public int findPeakElement(int[] nums) {
int left=0,right=nums.length-1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[mid]>nums[right]){
right--;
}
else{
left=mid+1;
}
}
return left;
}
}
744寻找比目标字母大的最小字母
题目描述
思路
二分查找
class Solution {
public char nextGreatestLetter(char[] letters, char target) {
if(target>=letters[letters.length-1]){//做个判断，大于等于最后一个，则返回数组第一个元素，这里是升序数组
return letters[0];
}
int left=0,right=letters.length-1;
while(left<=right){
int mid=left+(right-left)/2;
if(target<letters[mid]){
right=mid-1;
}
else {
left=mid+1;
}
}
return letters[left];
}
}
167两数之和-输入有序数组
题目描述
思路
1.暴力法：
两个指针，遍历，相加等于目标值存入数组，时间复杂度高
class Solution {
public int[] twoSum(int[] numbers, int target) {
int [] res=new int[2];
for(int i=0;i<numbers.length;i++){
for(int j=i+1;j<numbers.length;j++){
if(numbers[i]+numbers[j]==target){
res[0]=i+1;
res[1]=j+1;
}
}
}
return res;
}
}
2.二分查找
先用二分法缩小查找范围,缩小范围原理为拆分成的两个数中的较大者不应该大于target-min(numbers)。比如numbers=[2,7,11,23],target=10,只需在[2,7]范围查找即可,因为11>10-2=8，若一个数大于10-2=8，则构造出的数总大于target=10;再比如,numbers=[-2,7,12,23],target=10,只需在[-2,7,12]范围查找即可,因为23>10-(-2)=12。然后再利用双指针在缩小的范围内遍历一次数组获得结果!时间复杂度介于O(lgn)到O(n)之间
class Solution {
public int[] twoSum(int[] numbers, int target) {
if(numbers == null || numbers.length < 2 || target < numbers[0] + numbers[1] || target > numbers[numbers.length - 2] + numbers[numbers.length - 1]){
return null;
}
/*缩小查找范围,找到缩小范围的结束边界*/
int mid = 0;
if(target - numbers[0] >= numbers[numbers.length - 1]){
mid = numbers.length - 1;
}else{
int i = 0,j = numbers.length - 1,temp = target - numbers[0];
while(i <= j){
mid = (i + j) / 2;
if(numbers[mid] > temp){
j = mid - 1;
} else if(numbers[mid] < temp){
i = mid + 1;
} else break;
}
/*二分结束时mid可能指向第一个大于temp的数,也可能指向第一个小于temp的数*/
if(numbers[mid] > temp){
mid -= 1;
}
}
/*在缩小的范围内用双指针遍历一次数组获得结果*/
for(int i = 0, j = mid; i < j;){
if(numbers[i] + numbers[j] > target){
--j;
} else if(numbers[i] + numbers[j] < target){
++i;
} else{
return new int[]{i + 1, j + 1};
}
}
return null;
}
}
704二分查找
思路
class Solution {
public int search(int[] nums, int target) {
if(target>nums[nums.length-1]||target<nums[0]){
return -1;
}
int left=0,right=nums.length-1;
while(left<=right){
int mid=left+(right-left)/2;
if(target>nums[mid]){
left=mid+1;
}
else if(target<nums[mid]){
right=mid-1;
}
else{
return mid;//target==nums[mid]找到目标值返回
}
}
return -1;//不存在于数组中，返回-1
}
}
剑指Offer53
题目描述
思路
1.暴力法
class Solution {
public int search(int[] nums, int target) {
int count=0;
for(int i=0;i<nums.length;i++){
if(target==nums[i]){
count++;
}
}
return count;
}
}
2.二分查找
找到左边界和右边界
class Solution {
public int search(int[] nums, int target) {
int i = 0 , j = nums.length-1;
//找右边界，注意
while(i<=j){
int mid = i + (j-i)/2;
if(nums[mid] <= target){
i = mid+1;
}else{ //nums[mid] > target,nums[mid]严格大于target,nums[mid]及其右边都不可能是右边界
j = mid-1;
}
}
int right = i;//注意,右边界是从左边开始找的
i = 0 ; j = nums.length-1; //还原i,j
//找左边界,注意
while(i<=j){
int mid = i + (j-i)/2;
if(nums[mid] >= target){
j = mid-1;
}else{ //nums[mid] < target,nums[mid]严格小于target,nums[mid]及其左边都不可能是左边界
i = mid+1;
}
}
int left = j;//注意,左边界是从右边开始找的
return right-left-1;
}
}
287寻找重复数
题目描述
思路
1.暴力法
class Solution {
public int findDuplicate(int[] nums) {
int res=0;
for(int i=0;i<nums.length-1;i++){
for(int j=i+1;j<nums.length;j++){
if(nums[i]==nums[j]){
res=nums[j];
}
}
}
return res;
}
}
class Solution {
public int findDuplicate(int[] nums) {
int n = nums.length;
int l = 1, r = n - 1, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (nums[i] <= mid) {//找出小于mid的数的个数
cnt++;
}
}
if (cnt <= mid) {//若小于等于mid说明mid之前没有重复
l = mid + 1;
} else {//若大于说明mid前面有重复，重复数为mid
r = mid - 1;
ans = mid;
}
}
return ans;
}
}
剑指Offer53II 0-n-1中缺失的数字
题目描述
class Solution {
public int missingNumber(int[] nums) {
int l=0,r=nums.length-1;
while(l<=r){
int mid=l+(r-l)/2;
if(nums[mid]==mid){///如果mid位置的值与mid相等，说明mid之前的数都没有丢失，丢失的在mid后
l=mid+1;
}
else{如果mid位置的值大于mid，说明丢失的数字在mid之前
r=mid-1;
}
}
return l;
}
}
74搜索二维矩阵
题目描述
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix.length == 0) {
return false;
}
if (matrix[0].length == 0) {
return false;
}
if (matrix[0][0] == target) {
return true;
}
int m = matrix.length;
int n = matrix[0].length;
if (matrix[m - 1][n - 1] < target) {
return false;
} else if (matrix[m - 1][n - 1] == target) {
return true;
}
int start = 0;
int end = m * n - 1;
while (start <= end) {
int mid = (start + end) / 2;
//一维映射到二维在第几行
int x = mid / n;
//一维映射到二维在第几列
int y = mid % n;
if (matrix[x][y] == target) {
return true;
} else if (matrix[x][y] > target) {
end = mid - 1;
} else {
start = mid + 1;
}
}
return false;
}
}
1469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
