版權所有,轉載請註明出處,謝謝!
http://blog.csdn.net/walkinginthewind/article/details/8937978
二分查找,最基本的算法之一,也是面試中常被考察的重點,因爲基本的算法最能反映出一個人的基礎是否紮實。本文對二分查找相關題目做一個總結。
題目列表:
1. 給定一個有序(非降序)數組A,求任意一個i使得A[i]等於target,不存在則返回-1
2. 給定一個有序(非降序)數組A,可含有重複元素,求最小的i使得A[i]等於target,不存在則返回-1
3. 給定一個有序(非降序)數組A,可含有重複元素,求最大的i使得A[i]等於target,不存在則返回-1
4. 給定一個有序(非降序)數組A,可含有重複元素,求最大的i使得A[i]小於target,不存在則返回-1
5. 給定一個有序(非降序)數組A,可含有重複元素,求最小的i使得A[i]大於target,不存在則返回-1
6. 給定一個有序(非降序)數組A,可含有重複元素,求target在數組中出現的次數。
7. 給定一個有序(非降序)數組A,若target在數組中出現,返回位置,若不存在,返回它應該插入的位置。
8. 給定一個有序(非降序)數組A,可含有重複元素,求絕對值最小的元素的位置
9. 給定一個有序(非降序)數組A和一個有序(非降序)數組B,可含有重複元素,求兩個數組合並結果中的第k(k>=0)個數字。
10. 一個有序(升序)數組,沒有重複元素,在某一個位置發生了旋轉後,求target在變化後的數組中出現的位置,不存在則返回-1.
11. 一個有序(升序)數組,沒有重複元素,在某一個位置發生了旋轉後,求最小值所在位置
12. 一個有序(升序)數組,沒有重複元素,在某一個位置發生了旋轉後,求第k(k > 0)小元素
1. 給定一個有序(非降序)數組A,求任意一個i使得A[i]等於target,不存在則返回-1
這個是最原始的二分查找題目,利用數組的有序特性,拆半查找,使得查找時間複雜度爲O(logN)。請參考實現代碼與註釋。
- int search(int A[], int n, int target)
- {
- int low = 0, high = n-1;
- while(low <= high)
- {
- // 注意:若使用(low+high)/2求中間位置容易溢出
- int mid = low+((high-low)>>1);
- if(A[mid] == target)
- return mid;
- else if(A[mid] < target)
- low = mid+1;
- else // A[mid] > target
- high = mid-1;
- }
- return -1;
- }
int search(int A[], int n, int target)
{
int low = 0, high = n-1;
while(low <= high)
{
// 注意:若使用(low+high)/2求中間位置容易溢出
int mid = low+((high-low)>>1);
if(A[mid] == target)
return mid;
else if(A[mid] < target)
low = mid+1;
else // A[mid] > target
high = mid-1;
}
return -1;
}
2. 給定一個有序(非降序)數組A,可含有重複元素,求最小的i使得A[i]等於target,不存在則返回-1此題也就是求target在數組中第一次出現的位置。這裏可能會有人想先直接用原始的二分查找,如果不存在直接返回-1,如果存在,然後再順序找到這個等於target值區間的最左位置,這樣的話,最壞情況下的複雜度就是O(n)了,沒有完全發揮出二分查找的優勢。這裏的解法具體過程請參考實現代碼與註釋。
- int searchFirstPos(int A[], int n, int target)
- {
- if(n <= 0) return -1;
- int low = 0, high = n-1;
- while(low < high)
- {
- int mid = low+((high-low)>>1);
- if(A[mid] < target)
- low = mid+1;
- else // A[mid] >= target
- high = mid;
- }
- /*
- 循環過程中,當low大於0時,A[low-1]是小於target的,因爲A[mid] < target時,
- low=mid+1;當high小於n-1時,A[high]是大於等於target的,因爲A[mid] >= target時,
- high = mid;循環結束時,low 等於 high,所以,如果A[low](A[high])等於target,
- 那麼low(high)就是target出現的最小位置,否則target在數組中不存在。
- */
- if(A[low] != target)
- return -1;
- else
- return low;
- }
int searchFirstPos(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] < target)
low = mid+1;
else // A[mid] >= target
high = mid;
}
/*
循環過程中,當low大於0時,A[low-1]是小於target的,因爲A[mid] < target時,
low=mid+1;當high小於n-1時,A[high]是大於等於target的,因爲A[mid] >= target時,
high = mid;循環結束時,low 等於 high,所以,如果A[low](A[high])等於target,
那麼low(high)就是target出現的最小位置,否則target在數組中不存在。
*/
if(A[low] != target)
return -1;
else
return low;
}
3. 給定一個有序(非降序)數組A,可含有重複元素,求最大的i使得A[i]等於target,不存在則返回-1
此題也就是求target在數組中最後一次出現的位置。與上一題基本一樣,但是有個地方要注意,具體請參考實現代碼與註釋。
- int searchLastPos(int A[], int n, int target)
- {
- if(n <= 0) return -1;
- int low = 0, high = n-1;
- while(low < high)
- {
- /*
- 這裏中間位置的計算就不能用low+((high-low)>>1)了,因爲當low+1等於high
- 且A[low] <= target時,會死循環;所以這裏要使用low+((high-low+1)>>1),
- 這樣能夠保證循環會正常結束。
- */
- int mid = low+((high-low+1)>>1);
- if(A[mid] > target)
- high = mid-1;
- else // A[mid] <= target
- low = mid;
- }
- /*
- 循環過程中,當high小於n-1時,A[high+1]是大於target的,因爲A[mid] > target時,
- high=mid-1;當low大於0時,A[low]是小於等於target的,因爲A[mid] <= target時,
- low = mid;循環結束時,low 等於 high,所以,如果A[high](A[low])等於target,
- 那麼high(low)就是target出現的最大位置,否則target在數組中不存在。
- */
- if(A[high] != target)
- return -1;
- else
- return high;
- }
int searchLastPos(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
/*
這裏中間位置的計算就不能用low+((high-low)>>1)了,因爲當low+1等於high
且A[low] <= target時,會死循環;所以這裏要使用low+((high-low+1)>>1),
這樣能夠保證循環會正常結束。
*/
int mid = low+((high-low+1)>>1);
if(A[mid] > target)
high = mid-1;
else // A[mid] <= target
low = mid;
}
/*
循環過程中,當high小於n-1時,A[high+1]是大於target的,因爲A[mid] > target時,
high=mid-1;當low大於0時,A[low]是小於等於target的,因爲A[mid] <= target時,
low = mid;循環結束時,low 等於 high,所以,如果A[high](A[low])等於target,
那麼high(low)就是target出現的最大位置,否則target在數組中不存在。
*/
if(A[high] != target)
return -1;
else
return high;
}
4. 給定一個有序(非降序)數組A,可含有重複元素,求最大的i使得A[i]小於target,不存在則返回-1。
也就是求小於target的最大元素的位置。請參考實現代碼與註釋。
- int searchLastPosLessThan(int A[], int n, int target)
- {
- if(n <= 0) return -1;
- int low = 0, high = n-1;
- while(low < high)
- {
- int mid = low+((high-low+1)>>1); // 注意,不要導致死循環
- if(A[mid] < target)
- low = mid;
- else // A[mid] >= target
- high = mid-1;
- }
- /*
- 循環過程中,當low大於0時,A[low]是小於target的,因爲A[mid] < target時,
- low=mid;當high小於n-1時,A[high+1]是大於等於target的,因爲A[mid] >= target時,
- high = mid-1;循環結束時,low 等於 high,所以,如果A[low](A[high])小於target,
- 那麼low(high)就是要找的位置,否則不存在這樣的位置(A[0] >= target時)。
- */
- return A[low] < target ? low : -1;
- }
int searchLastPosLessThan(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low+1)>>1); // 注意,不要導致死循環
if(A[mid] < target)
low = mid;
else // A[mid] >= target
high = mid-1;
}
/*
循環過程中,當low大於0時,A[low]是小於target的,因爲A[mid] < target時,
low=mid;當high小於n-1時,A[high+1]是大於等於target的,因爲A[mid] >= target時,
high = mid-1;循環結束時,low 等於 high,所以,如果A[low](A[high])小於target,
那麼low(high)就是要找的位置,否則不存在這樣的位置(A[0] >= target時)。
*/
return A[low] < target ? low : -1;
}
5. 給定一個有序(非降序)數組A,可含有重複元素,求最小的i使得A[i]大於target,不存在則返回-1。也就是求大於target的最小元素的位置。請參考實現代碼與註釋。
- int searchFirstPosGreaterThan(int A[], int n, int target)
- {
- if(n <= 0) return -1;
- int low = 0, high = n-1;
- while(low < high)
- {
- int mid = low+((high-low)>>1);
- if(A[mid] > target)
- high = mid;
- else // A[mid] <= target
- low = mid+1;
- }
- /*
- 循環過程中,當low大於0時,A[low-1]是小於等於target的,因爲A[mid] <= target時,
- low=mid+1;當high小於n-1時,A[high]是大於target的,因爲A[mid] > target時,
- high = mid;循環結束時,low 等於 high,所以,如果A[high](A[low])大於target,
- 那麼high(low)就是要找的位置,否則不存在這樣的位置(A[n-1] <= target時)。
- */
- return A[high] > target ? high : -1;
- }
int searchFirstPosGreaterThan(int A[], int n, int target)
{
if(n <= 0) return -1;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] > target)
high = mid;
else // A[mid] <= target
low = mid+1;
}
/*
循環過程中,當low大於0時,A[low-1]是小於等於target的,因爲A[mid] <= target時,
low=mid+1;當high小於n-1時,A[high]是大於target的,因爲A[mid] > target時,
high = mid;循環結束時,low 等於 high,所以,如果A[high](A[low])大於target,
那麼high(low)就是要找的位置,否則不存在這樣的位置(A[n-1] <= target時)。
*/
return A[high] > target ? high : -1;
}
6. 給定一個有序(非降序)數組A,可含有重複元素,求target在數組中出現的次數
求出第一次出現位置和最後一次出現位置。由於前面都已實現,這裏不多解釋。請參考實現代碼與註釋
- int count(int A[], int n, int target)
- {
- int firstPos = searchFirstPos(A, n, target); // 第一次出現位置
- if(firstPos == -1)
- return 0;
- int lastPos = searchLastPos(A, n, target); // 最後一次出現位置
- return lastPos-firstPos+1; // 出現次數
- }
int count(int A[], int n, int target)
{
int firstPos = searchFirstPos(A, n, target); // 第一次出現位置
if(firstPos == -1)
return 0;
int lastPos = searchLastPos(A, n, target); // 最後一次出現位置
return lastPos-firstPos+1; // 出現次數
}
此題描述或者改爲求目標值在數組中的索引範圍。
7. 給定一個有序(非降序)數組A,若target在數組中出現,返回位置,若不存在,返回它應該插入的位置
如 [1,3,5,6], 5 → 2
[1,3,5,6], 2 → 1
[1,3,5,6], 7 → 4
[1,3,5,6], 0 → 0
- int searchInsert(int A[], int n, int target) {
- // 如果比最大值還大,那插入位置就是位置n
- if(A[n-1] < target)
- return n;
- int low = 0, high = n-1;
- while(low < high)
- {
- int mid = low+((high-low)>>1);
- if(A[mid] >= target)
- high = mid;
- else // A[mid] < target
- low = mid+1;
- }
- /*
- 循環過程中,當low大於0時,A[low-1]是小於target的,因爲A[mid] < target時,
- low=mid+1;當high小於n-1時,A[high]是大於等於target的,因爲A[mid] >= target時,
- high = mid;循環結束時,low 等於 high,所以,如果A[low](A[high])等於target,
- 那麼low(high)就是target出現的位置,否則low就是target在數組中應該插入的位置。
- */
- return high;
- }
int searchInsert(int A[], int n, int target) {
// 如果比最大值還大,那插入位置就是位置n
if(A[n-1] < target)
return n;
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] >= target)
high = mid;
else // A[mid] < target
low = mid+1;
}
/*
循環過程中,當low大於0時,A[low-1]是小於target的,因爲A[mid] < target時,
low=mid+1;當high小於n-1時,A[high]是大於等於target的,因爲A[mid] >= target時,
high = mid;循環結束時,low 等於 high,所以,如果A[low](A[high])等於target,
那麼low(high)就是target出現的位置,否則low就是target在數組中應該插入的位置。
*/
return high;
}
8. 給定一個有序(非降序)數組A,可含有重複元素,求絕對值最小的元素的位置
找第一個大於等於0的位置,然後和前一個元素的絕對值比較,返回絕對值較小的元素的位置。請參考實現代碼與註釋
- int searchMinAbs(int A[], int n)
- {
- int low = 0, high = n-1;
- while(low < high)
- {
- int mid = low+((high-low)>>1);
- if(A[mid] < 0)
- low = mid+1;
- else // A[mid] >= 0
- high = mid;
- }
- /* 循環結束時,如果low != n-1,A[low] >= 0,如果low>0,A[low-1] < 0 */
- if(low > 0 && abs(A[low-1]) < abs(A[low]))
- return low-1;
- else
- return low;
- }
int searchMinAbs(int A[], int n)
{
int low = 0, high = n-1;
while(low < high)
{
int mid = low+((high-low)>>1);
if(A[mid] < 0)
low = mid+1;
else // A[mid] >= 0
high = mid;
}
/* 循環結束時,如果low != n-1,A[low] >= 0,如果low>0,A[low-1] < 0 */
if(low > 0 && abs(A[low-1]) < abs(A[low]))
return low-1;
else
return low;
}
9. 給定一個有序(非降序)數組A和一個有序(非降序)數組B,可含有重複元素,求兩個數組合並結果中的第k(k>=0)個數字。
這個題目出現了兩個數組,有序的,不管怎樣我們就應該首先考慮二分查找是否可行。若使用順序查找,時間複雜度最低爲O(k),就是類似歸併排序中的歸併過程。使用用二分查找時間複雜度爲O(logM+logN)。二分查找的具體實現過程請參考實現代碼與註釋。
- int findKthIn2SortedArrays(int A[], int m, int B[], int n, int k)
- {
- if(m <= 0) // 數組A中沒有元素,直接在B中找第k個元素
- return B[k];
- if(n <= 0) // 數組B中沒有元素,直接在A中找第k個元素
- return A[k];
- int i = (m-1)>>1; // 數組A的中間位置
- int j = (n-1)>>1; // 數組B的中間位置
- if(A[i] <= B[j]) // 數組A的中間元素小於等於數組B的中間元素
- {
- /*
- 設x爲數組A和數組B中小於B[j]的元素數目,則i+1+j+1小於等於x,
- 因爲A[i+1]到A[m-1]中還可能存在小於等於B[j]的元素;
- 如果k小於i+1+j+1,那麼要查找的第k個元素肯定小於等於B[j],
- 因爲x大於等於i+1+j+1;既然第k個元素小於等於B[j],那麼只
- 需要在A[0]~A[m-1]和B[0]~B[j]中查找第k個元素即可,遞歸調用下去。
- */
- if(k < i+1+j+1)
- {
- if(j > 0)
- return findKthIn2SortedArrays(A, m, B, j+1, k);
- else // j == 0時特殊處理,防止死循環
- {
- if(k == 0)
- return min(A[0], B[0]);
- if(k == m)
- return max(A[m-1], B[0]);
- return A[k] < B[0] ? A[k] : max(A[k-1], B[0]);
- }
- }
- /*
- 設y爲數組A和數組B中小於於等於A[i]的元素數目,則i+1+j+1大於等於y;
- 如果k大於等於i+1+j+1,那麼要查找到第k個元素肯定大於A[i],因爲
- i+1+j+1大於等於y;既然第k個元素大於A[i],那麼只需要在A[i+1]~A[m-1]
- 和B[0]~B[n-1]中查找第k-i-1個元素,遞歸調用下去。
- */
- else
- return findKthIn2SortedArrays(A+i+1, m-i-1, B, n, k-i-1);
- }
- // 如果數組A的中間元素大於數組B的中間元素,那麼交換數組A和B,重新調用即可
- else
- return findKthIn2SortedArrays(B, n, A, m, k);
- }
int findKthIn2SortedArrays(int A[], int m, int B[], int n, int k)
{
if(m <= 0) // 數組A中沒有元素,直接在B中找第k個元素
return B[k];
if(n <= 0) // 數組B中沒有元素,直接在A中找第k個元素
return A[k];
int i = (m-1)>>1; // 數組A的中間位置
int j = (n-1)>>1; // 數組B的中間位置
if(A[i] <= B[j]) // 數組A的中間元素小於等於數組B的中間元素
{
/*
設x爲數組A和數組B中小於B[j]的元素數目,則i+1+j+1小於等於x,
因爲A[i+1]到A[m-1]中還可能存在小於等於B[j]的元素;
如果k小於i+1+j+1,那麼要查找的第k個元素肯定小於等於B[j],
因爲x大於等於i+1+j+1;既然第k個元素小於等於B[j],那麼只
需要在A[0]~A[m-1]和B[0]~B[j]中查找第k個元素即可,遞歸調用下去。
*/
if(k < i+1+j+1)
{
if(j > 0)
return findKthIn2SortedArrays(A, m, B, j+1, k);
else // j == 0時特殊處理,防止死循環
{
if(k == 0)
return min(A[0], B[0]);
if(k == m)
return max(A[m-1], B[0]);
return A[k] < B[0] ? A[k] : max(A[k-1], B[0]);
}
}
/*
設y爲數組A和數組B中小於於等於A[i]的元素數目,則i+1+j+1大於等於y;
如果k大於等於i+1+j+1,那麼要查找到第k個元素肯定大於A[i],因爲
i+1+j+1大於等於y;既然第k個元素大於A[i],那麼只需要在A[i+1]~A[m-1]
和B[0]~B[n-1]中查找第k-i-1個元素,遞歸調用下去。
*/
else
return findKthIn2SortedArrays(A+i+1, m-i-1, B, n, k-i-1);
}
// 如果數組A的中間元素大於數組B的中間元素,那麼交換數組A和B,重新調用即可
else
return findKthIn2SortedArrays(B, n, A, m, k);
}
10. 一個有序(升序)數組,沒有重複元素,在某一個位置發生了旋轉後,求target在變化後的數組中出現的位置,不存在則返回-1
如 0
1 2 4 5 6 7
可能變成 4
5 6 7 0 1 2
- int searchInRotatedArray(int A[], int n, int target)
- {
- int low = 0, high = n-1;
- while(low <= high)
- {
- int mid = low+((high-low)>>1);
- if(A[mid] == target)
- return mid;
- if(A[mid] >= A[low])
- {
- // low ~ mid 是升序的
- if(target >= A[low] && target < A[mid])
- high = mid-1;
- else
- low = mid+1;
- }
- else
- {
- // mid ~ high 是升序的
- if(target > A[mid] && target <= A[high])
- low = mid+1;
- else
- high = mid-1;
- }
- }
- return -1;
- }
int searchInRotatedArray(int A[], int n, int target)
{
int low = 0, high = n-1;
while(low <= high)
{
int mid = low+((high-low)>>1);
if(A[mid] == target)
return mid;
if(A[mid] >= A[low])
{
// low ~ mid 是升序的
if(target >= A[low] && target < A[mid])
high = mid-1;
else
low = mid+1;
}
else
{
// mid ~ high 是升序的
if(target > A[mid] && target <= A[high])
low = mid+1;
else
high = mid-1;
}
}
return -1;
}
如果這樣的數組中存在重複元素,還能使用二分嗎?答案是不能。請看幾個例子
[1, 2, 2, 2, 2], [2, 1, 2, 2, 2], [2, 2, 1, 2, 2], [2, 2, 2, 1, 2], [2, 2, 2, 2, 1]這些都是有第一個數組旋轉一次變化來的,我們不能通過二分確定是否存在元素1.
11. 一個有序(升序)數組,沒有重複元素,在某一個位置發生了旋轉後,求最小值所在位置
如果中間元素小於左端元素,則最小值在左半區間內(包含中間元素);如果中間元素大於右端元素,則最小值在右半區間內(包含中間元素)。請參考實現代碼與註釋。
- int searchMinInRotatedArray(int A[], int n)
- {
- if(n == 1)
- return 0;
- int low = 0, high = n-1;
- while(low < high-1) // 保證mid != low且mid != high
- {
- int mid = low+((high-low)>>1);
- if(A[mid] < A[low]) // 最小值在low~mid
- high = mid;
- else // A[mid] > A[low], // 最小值在mid和high之間
- low = mid;
- }
- return A[low] < A[low+1] ? low : low+1;
- }
int searchMinInRotatedArray(int A[], int n)
{
if(n == 1)
return 0;
int low = 0, high = n-1;
while(low < high-1) // 保證mid != low且mid != high
{
int mid = low+((high-low)>>1);
if(A[mid] < A[low]) // 最小值在low~mid
high = mid;
else // A[mid] > A[low], // 最小值在mid和high之間
low = mid;
}
return A[low] < A[low+1] ? low : low+1;
}
12. 一個有序(升序)數組,沒有重複元素,在某一個位置發生了旋轉後,求第k(k > 0)小元素的位置我們可以利用上一題的解答,求出最小值所在位置後,便可以求出第k小元素。請參考實現代碼與註釋
- int searchKthInRotatedArray(int A[], int n, int k)
- {
- int posMin = searchMinInRotatedArray(A, n);
- return (posMin+k-1)%n;
- }
int searchKthInRotatedArray(int A[], int n, int k)
{
int posMin = searchMinInRotatedArray(A, n);
return (posMin+k-1)%n;
}