2021-11-12

二分法查找

好处:

二分法查找比较的次数少

查找的速度快

缺点：需要有序

与力扣704题相结合

public class DichotomySearch {

  public static void main(String[] args) {

  int[] arr = new int[] { -1,0,3,5,9,12 };
   System.out.println(search(arr, -1));
  System.out.println(search(arr, 0));

   System.out.println(search(arr, 3));

   System.out.println(search(arr, 5));
    System.out.println(search(arr, 9));

 	System.out.println(search(arr, 12));

 

  }

 

  public static int search(int[] arr, int key) {

    int start = 0;

    int end = arr.length - 1;
    while (start <= end) {

      int middle = (start + end) / 2;

      if (key < arr[middle]) {
       end = middle - 1;
      } else if (key > arr[middle]) {

       start = middle + 1;

      } else {

        return middle;

      }

    }

    return -1;

  }

}

搜索插入位置

使用 借助indexOf和sort实现

public class SearchInsertSolution {

  public static void main(String[] args) {

    int[] nums={1,3,5,6};

    int target=7;

    System.out.println(new SearchInsertSolution().searchInsert(nums, target));

  }

  public int searchInsert(int[] nums, int target) {

   if (nums==null){
      return -1;
   }

    if (nums.length<=0){
      return -1;

    }
   ArrayList<Integer> list = new ArrayList<>();

   for (int i = 0; i < nums.length; i++) {

      list.add(nums[i]);

      if (target==nums[i]){

       return i;

      }

    }

    list.add(target);

    Collections.sort(list); // 进行排序

    return list.indexOf(target);

  }

}

寻找峰值

class Solution {

  public int findPeakElement(int[] nums) {

    int l = 0, r = nums.length - 1;

    while( l < r)

    {
      int mid = ( l + r )/2;

     if(nums[mid] > nums[mid + 1]) r = mid;

      else l = mid + 1;

    }

    return r;

  }

}

搜索二维矩阵

由于每行的第一个元素大于前一行的最后一个元素，且每行元素是升序的，所以每行的第一个元素大于前一行的第一个元素，因此矩阵第一列的元素是升序的。

我们可以对矩阵的第一列的元素二分查找，找到最后一个不大于目标值的元素，然后在该元素所在行中二分查找目标值是否存在。

代码

class Solution {

  public boolean searchMatrix(int[][] matrix, int target) {
    int rowIndex = binarySearchFirstColumn(matrix, target);

    if (rowIndex < 0) {

      return false;

    }

    return binarySearchRow(matrix[rowIndex], target);

  }

 

  public int binarySearchFirstColumn(int[][] matrix, int target) {

    int low = -1, high = matrix.length - 1;

    while (low < high) {

     int mid = (high - low + 1) / 2 + low;

      if (matrix[mid][0] <= target) {

        low = mid;

      } else {

        high = mid - 1;

      }

   }

    return low;

  }

 

  public boolean binarySearchRow(int[] row, int target) {

   int low = 0, high = row.length - 1;

    while (low <= high) {

      int mid = (high - low) / 2 + low;

     if (row[mid] == target) {

        return true;

      } else if (row[mid] > target) {

        high = mid - 1;

      } else {

        low = mid + 1;

      }
   }

    return false;

  }

}