二分搜索基础
一、二分搜索模板
简单模板代码：
public static int binarySearch(int[] array, int target) { if (array == null || array.length == 0) { return -1; } int start = 0; int end = array.length - 1; int middle; // 相邻 start = end - 1 或者 start = end while (start + 1 < end) { // (1) middle = start + (end - start) / 2; // (2) if (array[middle] == target) { return middle; } else if (array[middle] < target) { //target在右边 start = middle; } else { end = middle; } } if (array[start] == target) { // (3) return start; } else if (array[end] == target) { // (4) return end; } else { return -1; } }
说明:
(1) (start+end)/2 在start+end的值较大的时候有可能会超出范围, 因此这里使用start+(end-start)/2
(2) 为什么使用start+1<end? 为了防止死循环:
循环终止条件为:start+1>=end, 即相邻或者相交的情况
(3) (4) : 在相邻或者相交的情况下都终止, 再判断可以简单防止死循环
二、二分查找区间
问题描述: http://www.lintcode.com/en/problem/search-for-a-range/
即给定一个有序的数组和target value, 寻找target value的起始和结束位置, 不存在就返回(-1,-1);
思路: 二分搜索的扩展.
(1) 分二次查找
(2) 结束条件都是相邻或者相交
(3) 找左边界就是start->end
(4) 找右边界就是end->start
public class BinarySearch { public static void main(String[] args) { int[] array = new int[]{1, 2, 3, 4, 4 ,4, 4, 5}; System.out.println(Arrays.toString(binarySearch(array, 4))); } public static int[] binarySearch(int[] array, int target) { if (array == null || array.length == 0) { return new int[]{-1, -1}; } int start = 0; int end = array.length - 1; // left是左边的, right是右边的 int middle, left, right; // 相邻 start = end - 1 或者 start = end while (start + 1 < end) { middle = start + (end - start) / 2; if (array[middle] == target) { end = middle; } else if (array[middle] < target) { //target在右边 start = middle; } else { end = middle; } } if (array[start] == target) { left = start; } else if (array[end] == target) { left = end; } else { return new int[]{-1, -1}; } start = 0; end = array.length - 1; middle = 0; while (start + 1 < end) { middle = start + (end - start) / 2; if (array[middle] == target) { start = middle; } else if (array[middle] < target) { //target在右边 start = middle; } else { end = middle; } } if (array[end] == target) { right = end; } else if (array[start] == target) { right = start; } else { return new int[]{-1, -1}; } return new int[]{left, right}; } }
三、二分查找插入位置
问题描述：
http://www.lintcode.com/en/problem/search-insert-position/
(1) 给一个有序的数组
(2) 寻找插入位置
二分查找的精髓: 每次去掉一半, 最后剩下的情况就是start=end或者start+1=end, 而无论哪种都可以当做start+1=end考虑;
public static int searchInsert(int[] A, int target) { if (A == null || A.length == 0) { return 0; } int start = 0, end = A.length - 1; while (start + 1 < end) { int mid = start + (end - start) / 2; if (A[mid] == target) { return mid; } else if (A[mid] < target) { start = mid; } else { end = mid; } } if (A[start] >= target) { return start; } else if (A[end] >= target) { return end; } else { return end + 1; } }
四、循环数组二分查找
问题描述:
http://www.lintcode.com/en/problem/search-in-rotated-sorted-array/
Suppose a sorted array is rotated at some pivot unknown to you beforehand.
(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
You are given a target value to search. If found in the array return its index, otherwise return -1.
You may assume no duplicate exists in the array.
循环数组的二分查询，画图2个象限，简单的分类讨论感觉用代码实现也很麻烦.
这里说一下思路:
(1) 首先判断mid在第一部分和第二部分
(2) 将问题细化, 这里只考虑第一部分:
如果A[start] < A[end], 则是一般情况
否则 start, mid ,end将数组分为了3个区间, A[mid]<=target<=A[end]则说明target在mid和end中间, 否则是start,mid中.
(3) 第二部分类似
(4) 问题解决
public static int search(int[] A, int target) { if (A == null || A.length == 0) { return -1; } int start = 0, end = A.length - 1; int mid; while (start + 1 < end) { mid = start + (end - start) / 2; if (A[mid] == target) return mid; // 分为2大类: 在哪边？ if (A[mid] > A[start]) { if (A[end] >= A[start]) { //.. if (A[mid] > target) { end = mid; } else { start = mid; } } else { if (target >= A[start] && target <= A[mid]) { end = mid; } else { start = mid; } } } else { if (A[start] <= A[end]) { if (A[mid] > target) { end = mid; } else { start = mid; } } else { if (target >= A[mid] && target <=A[end]){ start = mid; }else { end = mid; } } } } if (A[start] == target) { return start; } else if (A[end] == target) { return end; } else { return -1; } }
五、矩阵二分搜索
问题描述, 非常简单, 一个矩阵m*n 可以用数组表示:
(1) 没一行都有序
(2) 第n+1行比第n行的都大
例如:
[ [1, 3, 5, 7], [10, 11, 16, 20], [23, 30, 34, 50] ]
非常简单, 看成是一个数组就可以..
public boolean searchMatrix(int[][] matrix, int target) { if (matrix == null || matrix.length == 0) { return false; } if (matrix[0] == null || matrix[0].length == 0) { return false; } int row = matrix.length, column = matrix[0].length; int start = 0, end = row * column - 1; while (start + 1 < end) { int mid = start + (end - start) / 2; int number = matrix[mid / column][mid % column]; if (number == target) { return true; } else if (number < target) { start = mid; } else { end = mid; } } if (matrix[start / column][start % column] == target) { return true; } else if (matrix[end / column][end % column] == target) { return true; } return false; }
下面考虑更为复杂的情况:
(1) 每一行都是有序的
(2) 每一列都是有序的要怎么做?
这里说明一下思路:
从左下方开始判断, 如果target < matirx[i][j], 说明第i列的数都没用, i++
如果target > matirx[i][j], 说明第j列的数都没有用, j++.
六、合并有序数组
合并有序数组非常简单, 但是假设这样的情况: A中有足够的位置去合并, 不能创建新的数组要怎么办 ?
A = [1, 2, 3, empty, empty], B = [4, 5]
After merge, A will be filled as [1, 2, 3, 4, 5]
思路非常简单, 看empty在哪边? 这里从后面开始扩展就可以~
代码如下: 这里也是创建了新数组C, 然后把A拷贝进去模拟A中有足够的位置：
public static void main(String[] args) { merge( new int[]{1, 3, 4}, new int[]{2, 3, 5, 8, 9} ); } public static void merge(int[] A, int B[]) { int[] C = new int[A.length + B.length]; System.arraycopy(A, 0, C, 0, A.length); int a = A.length - 1; int b = B.length - 1; int i = a + b + 1; while (i >= 0 && a >= 0 && b >= 0) { if (A[a] > B[b]) { C[i] = A[a]; a--; } else { C[i] = B[b]; b--; } i--; } if (b < 0) { //a 剩下 System.arraycopy(A, 0, C, 0, a + 1); } else if (a < 0) { System.arraycopy(B, 0, C, 0, b + 1); } System.out.println(Arrays.toString(C)); }
七、2个有序数组寻找kth问题
(1) 2个有序数组
(2) 寻找2个数组加起来第k个
(3) 要求是算法复杂度是log(m+n)
思路是什么：要log的时间复杂度，每次必须抛弃一半:
只要每次比较 A[k/2]和B[k/2]就可以, 如果A[k/2]<B[k/2]就可以抛弃A中的k/2个元素...
代码如下(没有经过充分测试)：
public static void main(String[] args) { int[] A = {1, 2, 3, 4, 5, 6}; int[] B = {2, 3, 4, 5}; System.out.println(findMedianSortedArrays(A, B)); } public static double findMedianSortedArrays(int A[], int B[]) { int len = A.length + B.length; if (len % 2 == 1) { return findKth(A, 0, B, 0, len / 2 + 1); } return ( findKth(A, 0, B, 0, len / 2) + findKth(A, 0, B, 0, len / 2 + 1) ) / 2.0; } /** * @param A 数组A * @param A_start 数组A起始位置 * @param B 数组B * @param B_start 数组B起始位置 * @param k 寻找第K个数 * @return */ public static int findKth(int[] A, int A_start, int[] B, int B_start, int k) { if (A_start > A.length - 1) { return B[B_start + k - 1]; } if (B_start > B.length - 1) { return A[A_start + k - 1]; } // if (k == 1) { return Math.min(A[A_start], B[B_start]); } // 要考虑k/2超出边界的情况 int a_new_start = A_start + k / 2 - 1; int b_new_start = B_start + k / 2 - 1; int a_length, b_length; if (a_new_start > A.length - 1) { a_new_start = A.length - 1; } a_length = a_new_start - A_start + 1; if (b_new_start > B.length - 1) { b_new_start = B.length - 1; } b_length = b_new_start - B_start + 1; if (A[a_new_start] < B[b_new_start]) { //A这边小一点, 全面的全部被抛弃 return findKth(A, a_new_start + 1, B, B_start, k - a_length); } else { return findKth(A, A_start, B, b_new_start + 1, k - b_length); } }
