前言
金三銀四，又是一個跳槽的季節。在面試的過程中，有時候難免會碰到一些算法題目。今天，爲大家整理了二分查找常見的算法題。
主要包括以下三點
旋轉數組中的最小數字
在旋轉數組中查找某個數
排序數組中某個數的出現次數
旋轉數組的最小數字
題目：把一個數組最開始的若干個元素搬到數組的末尾，我們稱之爲數組的旋轉。輸入一個遞增排序的數組的一個旋轉，輸出旋轉數組的最小元素。例如數組{3，4，5，1，2}爲{1，2，3，4，5}的一個旋轉，該數組的最小值爲1.
實現數組的旋轉見左旋轉字符串。
解題思路
和二分查找法一樣，用兩個指針分別指向數組的第一個元素和最後一個元素。
我們注意到旋轉之後的數組實際上可以劃分爲兩個排序的子數組，而且前面的子數組的元素都大於或者等於後面子數組的元素。我們還可以注意到最小的元素剛好是這兩個子數組的分界線。我們試着用二元查找法的思路在尋找這個最小的元素。
首先我們用兩個指針，分別指向數組的第一個元素和最後一個元素。按照題目旋轉的規則，第一個元素應該是大於或者等於最後一個元素的（這其實不完全對，還有特例。後面再討論特例）。
接着我們得到處在數組中間的元素。如果該中間元素位於前面的遞增子數組，那麼它應該大於或者等於第一個指針指向的元素。此時數組中最小的元素應該位於該中間 元素的後面。我們可以把第一指針指向該中間元素，這樣可以縮小尋找的範圍。同樣，如果中間元素位於後面的遞增子數組，那麼它應該小於或者等於第二個指針指 向的元素。此時該數組中最小的元素應該位於該中間元素的前面。我們可以把第二個指針指向該中間元素，這樣同樣可以縮小尋找的範圍。我們接着再用更新之後的 兩個指針，去得到和比較新的中間元素，循環下去。
按照上述的思路，我們的第一個指針總是指向前面遞增數組的元素，而第二個指針總是指向後面遞增數組的元素。最後第一個指針將指向前面子數組的最後一個元素， 而第二個指針會指向後面子數組的第一個元素。也就是它們最終會指向兩個相鄰的元素，而第二個指針指向的剛好是最小的元素。這就是循環結束的條件。
核心實現代碼：
1int Min(int *numbers , int length)
2{
3 if(numbers == NULL || length <= 0)
4 return;
5
6 int index1 = 0;
7 int index2 = length - 1;
8 int indexMid = index1;
9 while(numbers[index1] >= numbers[index2])
10 {
11 if(index2 - index1 == 1)
12 {
13 indexMid = index2;
14 break;
15 }
16
17 indexMid = (index1 + index2) / 2;
18 //如果下標爲index1、index2和indexMid指向的三個數字相等，則只能順序查找
19 if(numbers[index1] == numbers[index2] && numbers[indexMid] == numbers[index1])
20 return MinInOrder(numbers , index1 , index2);
21
22 if(numbers[indexMid] >= numbers[index1])
23 index1 = indexMid;
24 else if(numbers[indexMid] <= numbers[index2])
25 index2 = indexMid;
26 }
27 return numbers[indexMid];
28}
29
30//順序查找
31int MinInOrder(int *numbers , int index1 , int index2)
32{
33 int result = numbers[index1];
34 for(int i = index1 + 1 ; i <= index2 ; ++i)
35 {
36 if(result > numbers[i])
37 result = numbers[i];
38 }
39 return result;
40}
注意：當兩個指針指向的數字及他們中間的數字三者相同的時候，我們無法判斷中間的數字是位於前面的字數組還是後面的子數組中，也就無法移動兩個指針來縮小查找的範圍。此時，我們不得不採用順序查找的方法。
2 旋轉數組中查找某個數字
要求：一個沒有重複元素的旋轉數組（它對應的原數組是有序的），求給定元素在旋轉數組內的下標（不存在的返回-1）。
例如
有序數組爲｛0，1，2，4，5，6，7｝，它的一個旋轉數組爲｛4，5，6，7，0，1，2｝。
元素6在旋轉數組內，返回2
元素3不在旋轉數組內，返回-1
分析
1 遍歷一遍，可以輕鬆搞定，時間複雜度爲O(n)，因爲是有序數組旋轉得到，這樣做肯定不是最優解。有序，本能反映用二分查找，舉個例子看看特點
2 可以看出中間位置兩段起碼有一個是有序的（不是左邊，就是右邊），那麼就可以在有序的範圍內使用二分查找；如果不再有序範圍內，就到另一半去找。
參考代碼
1int search(int A[], int n, int target) {
2 int beg = 0;
3 int end = n - 1;
4 while (beg <= end)
5 {
6 int mid = beg + (end - beg) / 2;
7 if(A[mid] == target)
8 return mid;
9 if(A[beg] <= A[mid])
10 {
11 if(A[beg] <= target && target < A[mid])
12 end = mid - 1;
13 else
14 beg = mid + 1;
15 }
16 else
17 {
18 if(A[mid] < target && target <= A[end])
19 beg = mid + 1;
20 else
21 end = mid - 1;
22 }
23 }
24 return -1;
25 }
關於Android面試的題庫，我花了一個多月的時間整理出來的學習資料，希望能幫助那些想學習Android開發，卻又不知道怎麼開始學習的同學。幫助再金三銀四季還沒有找到合適工作的同學，如果你依然在編程的世界裏迷茫，不知道自己的未來規劃，可以加入Android高級架構羣：點擊鏈接加入羣聊【騰訊@Android高級架構】（包括java基礎與原理，自定義控件、NDK、架構設計、混合式開發(Flutter，Weex)、性能優化、完整商業項目開發等系統的高級技術）
擴展
邊的有求是沒有重複的元素，現在稍微擴展下，可以有重複的元素，其他的要求不變。
思路：大致思路與原來相同，這是需要比較A[beg] 與 A[mid]的關係
1A[beg] < A[mid] ————左邊有序
2A[beg] > A[mid] ————右邊有序
3A[beg] = A[mid] ————++beg
1boolean search(int A[], int n, int target) {
2 int beg = 0;
3 int end = n - 1;
4 while (beg <= end)
5 {
6 int mid = beg + (end - beg) / 2;
7 if(A[mid] == target)
8 return true;
9 if(A[beg] < A[mid])
10 {
11 if(A[beg] <= target && target < A[mid])
12 end = mid - 1;
13 else
14 beg = mid + 1;
15 }
16 else 0if(A[beg] > A[mid])
17 {
18 if(A[mid] < target && target <= A[end])
19 beg = mid + 1;
20 else
21 end = mid - 1;
22 }
23 else
24 ++beg;
25 }
26 return false;
27 }
3 數字在排序數組中的出現次數
1//二分查找，二分查找key第一次出現的位置，二分查找最後一次出現的key
2
3//返回兩者相減+1或者找到第一次出現的位置，向後查找
4int binarySearchFirstPos(int * iArr, int l, int h, int key)
5
6{
7
8 while(l <= h )
9
10 {
11
12 int mid = (l + h) / 2;
13
14 if(iArr[mid] < key)
15
16 l = mid +1;
17
18 elseif(iArr[mid] > key)
19
20 h = mid - 1;
21
22 else
23
24 {
25
26 if(mid == l || iArr[mid - 1] != key)
27
28 return mid;
29
30 else
31
32 h = mid - 1;
33
34 }
35
36 }
37
38 return -1;
39
40}
41
42int binarySearchLastPos(int * iArr, int l, int h, int key)
43
44{
45
46 while(l <= h)
47
48 {
49
50 int mid = (l + h) / 2;
51
52 if(iArr[mid] < key)
53
54 l = mid + 1;
55
56 elseif(iArr[mid] > key)
57
58 h = mid - 1;
59
60 else
61
62 {
63
64 if(mid == h || iArr[mid + 1] != key)
65
66 return mid;
67
68 else
69
70 l = mid + 1;
71
72 }
73
74 }
75
76 return -1;
77
78}
79
80int numOfKey(int * iArr, int length, int key)
81
82{
83
84 int firstPos = binarySearchFirstPos(iArr, 0, length - 1, key);
85
86 int lastPos = binarySearchLastPos(iArr, 0, length - 1, key);
87
88 cout << firstPos << "\t" << lastPos << endl;;
89
90 if(firstPos == -1)
91
92 return0;
93
94 elsereturn lastPos - firstPos + 1;
95
96}