循環ソートされた配列内の要素の検索
O(log n)以下の複雑さで循環ソートされた配列内の特定の要素を検索したいと思います。
例：_13_で_{5,9,13,1,3}_を検索します。
私のアイデアは、循環配列を通常の並べ替えられた配列に変換してから、結果の配列に対してバイナリ検索を行うことでしたが、私の問題は、最悪の場合O(n)を使用するという愚かなアルゴリズムでした：
_for(i = 1; i < a.length; i++){
if (a[i] < a[i-1]){
minIndex = i; break;
}
}
_次に、i番目の要素の対応するインデックスは次の関係から決定されます。
_(i + minInex - 1) % a.length
_私の変換（循環から通常へ）アルゴリズムはO（n）を取る可能性があることは明らかなので、より良いものが必要です。
Ire_and_cursesのアイデアによると、Javaでのソリューションは次のとおりです。
_public int circularArraySearch(int[] a, int low, int high, int x){
//instead of using the division op. (which surprisingly fails on big numbers)
//we will use the unsigned right shift to get the average
int mid = (low + high) >>> 1;
if(a[mid] == x){
return mid;
}
//a variable to indicate which half is sorted
//1 for left, 2 for right
int sortedHalf = 0;
if(a[low] <= a[mid]){
//the left half is sorted
sortedHalf = 1;
if(x <= a[mid] && x >= a[low]){
//the element is in this half
return binarySearch(a, low, mid, x);
}
}
if(a[mid] <= a[high]){
//the right half is sorted
sortedHalf = 2;
if(x >= a[mid] && x<= a[high] ){
return binarySearch(a, mid, high, x);
}
}
// repeat the process on the unsorted half
if(sortedHalf == 1){
//left is sorted, repeat the process on the right one
return circularArraySearch(a, mid, high, x);
}else{
//right is sorted, repeat the process on the left
return circularArraySearch(a, low, mid, x);
}
}
_うまくいけばこれはうまくいくでしょう。
これを行うには、ピボット値とその隣接値の特殊なケースを除いて、配列が並べ替えられているという事実を利用します。
- 配列の中央の値を見つけますa。
a[0] < a[mid]の場合、配列の前半のすべての値がソートされます。a[mid] < a[last]の場合、配列の後半のすべての値が並べ替えられます。- ソートされた半分を取得し、値がその中にあるかどうかを確認します（その半分の最大idxと比較してください）。
- もしそうなら、その半分を二分探索するだけです。
- そうでない場合は、ソートされていない半分になっている必要があります。その半分を取り、このプロセスを繰り返し、その半分のどの半分をソートするかなどを決定します。
あまりエレガントではありませんが、頭の中で十分です。バイナリ検索を使用して、回転した配列のピボットを見つけ、ピボットのオフセットを補正して、再度バイナリ検索を実行してください。 2つの完全な検索を実行するのは愚かなことですが、O（log n）+ O（log n）== O（log n）であるため、条件を満たします。シンプルで愚かな（tm）にしてください！
これはJavaで機能する例です。これはソートされた配列なので、これを利用してバイナリ検索を実行しますが、ピボットの位置に対応するために少し変更する必要があります。
メソッドは次のようになります。
private static int circularBinSearch ( int key, int low, int high )
{
if (low > high)
{
return -1; // not found
}
int mid = (low + high) / 2;
steps++;
if (A[mid] == key)
{
return mid;
}
else if (key < A[mid])
{
return ((A[low] <= A[mid]) && (A[low] > key)) ?
circularBinSearch(key, mid + 1, high) :
circularBinSearch(key, low, mid - 1);
}
else // key > A[mid]
{
return ((A[mid] <= A[high]) && (key > A[high])) ?
circularBinSearch(key, low, mid - 1) :
circularBinSearch(key, mid + 1, high);
}
}
心配事を和らげるために、アルゴリズムを検証する素敵な小さなクラスを次に示します。
public class CircularSortedArray
{
public static final int[] A = {23, 27, 29, 31, 37, 43, 49, 56, 64, 78,
91, 99, 1, 4, 11, 14, 15, 17, 19};
static int steps;
// ---- Private methods ------------------------------------------
private static int circularBinSearch ( int key, int low, int high )
{
... copy from above ...
}
private static void find ( int key )
{
steps = 0;
int index = circularBinSearch(key, 0, A.length-1);
System.out.printf("key %4d found at index %2d in %d steps\n",
key, index, steps);
}
// ---- Static main -----------------------------------------------
public static void main ( String[] args )
{
System.out.println("A = " + Arrays.toString(A));
find(44); // should not be found
find(230);
find(-123);
for (int key: A) // should be found at pos 0..18
{
find(key);
}
}
}
それはあなたに出力を与えます：
A = [23, 27, 29, 31, 37, 43, 49, 56, 64, 78, 91, 99, 1, 4, 11, 14, 15, 17, 19]
key 44 found at index -1 in 4 steps
key 230 found at index -1 in 4 steps
key -123 found at index -1 in 5 steps
key 23 found at index 0 in 4 steps
key 27 found at index 1 in 3 steps
key 29 found at index 2 in 4 steps
key 31 found at index 3 in 5 steps
key 37 found at index 4 in 2 steps
key 43 found at index 5 in 4 steps
key 49 found at index 6 in 3 steps
key 56 found at index 7 in 4 steps
key 64 found at index 8 in 5 steps
key 78 found at index 9 in 1 steps
key 91 found at index 10 in 4 steps
key 99 found at index 11 in 3 steps
key 1 found at index 12 in 4 steps
key 4 found at index 13 in 5 steps
key 11 found at index 14 in 2 steps
key 14 found at index 15 in 4 steps
key 15 found at index 16 in 3 steps
key 17 found at index 17 in 4 steps
key 19 found at index 18 in 5 steps
検索の低、中、高のインデックスの値には、l、m、hの3つの値があります。あなたがそうだと思うなら、あなたはそれぞれの可能性を探し続けるでしょう：
// normal binary search
l < t < m - search(t,l,m)
m < t < h - search(t,m,h)
// search over a boundary
l > m, t < m - search(t,l,m)
l > m, t > l - search(t,l,m)
m > h, t > m - search(t,m,h)
m > h, t < h - search(t,m,h)
目標値がどこにあるかを検討し、その半分のスペースを検索することが問題です。最大でスペースの半分にラップオーバーがあり、ターゲット値がその半分にあるかどうかを簡単に判断できます。
これは一種のメタ質問です-バイナリ検索は、それがどのように提示されるかという用語だと思いますか-2点間の値を見つけるか、より一般的には抽象的な検索空間の繰り返し分割として考えますか？.
Rubyの簡単な方法
def CircularArraySearch(a, x)
low = 0
high = (a.size) -1
while low <= high
mid = (low+high)/2
if a[mid] == x
return mid
end
if a[mid] <= a[high]
if (x > a[mid]) && (x <= a[high])
low = mid + 1
elsif high = mid -1
end
else
if (a[low] <= x) && (x < a[mid])
high = mid -1
else
low = mid +1
end
end
end
return -1
end
a = [12, 14, 18, 2, 3, 6, 8, 9]
x = gets.to_i
p CircularArraySearch(a, x)
私はあなたがこのコードを使用してオフセットを見つけることができると思います：
public static int findOffset(int [] arr){
return findOffset(arr,0,arr.length-1);
}
private static int findOffset(int[] arr, int start, int end) {
if(arr[start]<arr[end]){
return -1;
}
if(end-start==1){
return end;
}
int mid = start + ((end-start)/2);
if(arr[mid]<arr[start]){
return findOffset(arr,start,mid);
}else return findOffset(arr,mid,end);
}
これがJavaScriptの解決策です。いくつかの異なるアレイでテストしたところ、動作しているようです。基本的に、ire_and_cursesで説明されているのと同じメソッドを使用します。
function search(array, query, left, right) {
if (left > right) {
return -1;
}
var midpoint = Math.floor((left + right) / 2);
var val = array[midpoint];
if(val == query) {
return midpoint;
}
// Look in left half if it is sorted and value is in that
// range, or if right side is sorted and it isn't in that range.
if((array[left] < array[midpoint] && query >= array[left] && query <= array[midpoint])
|| (array[midpoint] < array[right]
&& !(query >= array[midpoint] && query <= array[right]))) {
return search(array, query, left, midpoint - 1);
} else {
return search(array, query, midpoint + 1, right);
}
}
public static int _search(int[] buff, int query){
int s = 0;
int e = buff.length;
int m = 0;
while(e-s>1){
m = (s+e)/2;
if(buff[offset(m)] == query){
return offset(m);
} else if(query < buff[offset(m)]){
e = m;
} else{
s = m;
}
}
if(buff[offset(end)]==query) return end;
if(buff[offset(start)]==query) return start;
return -1;
}
public static int offset(int j){
return (dip+j) % N;
}
少し変更を加えた単純な二分探索。
回転配列のインデックス=（i +ピボット）％サイズ
ピボットはインデックスi + 1であり、a [i]> a [i +1]です。
#include <stdio.h>
#define size 5
#define k 3
#define value 13
int binary_search(int l,int h,int arr[]){
int mid=(l+h)/2;
if(arr[(mid+k)%size]==value)
return (mid+k)%size;
if(arr[(mid+k)%size]<value)
binary_search(mid+1,h,arr);
else
binary_search(l,mid,arr);
}
int main() {
int arr[]={5,9,13,1,3};
printf("found at: %d\n", binary_search(0,4,arr));
return 0;
}
通常のソートされた配列であるかのように、単純なバイナリ検索を使用するだけです。唯一のトリックは、配列インデックスをローテーションする必要があることです。
(index + start-index) mod array-size
ここで、start-indexは、循環配列の最初の要素のオフセットです。
このコーをチェックして、
def findkey():
key = 3
A=[10,11,12,13,14,1,2,3]
l=0
h=len(A)-1
while True:
mid = l + (h-l)/2
if A[mid] == key:
return mid
if A[l] == key:
return l
if A[h] == key:
return h
if A[l] < A[mid]:
if key < A[mid] and key > A[l]:
h = mid - 1
else:
l = mid + 1
Elif A[mid] < A[h]:
if key > A[mid] and key < A[h]:
l = mid + 1
else:
h = mid - 1
if __name__ == '__main__':
print findkey()
二分探索に関連するアイデアがあります。右側の配列インデックス境界のインデックスをバックアップし続けるだけで、左側のインデックス境界はステップサイズに格納されます。
step = n
pos = n
while( step > 0 ):
test_idx = pos - step #back up your current position
if arr[test_idx-1] < arr[pos-1]:
pos = test_idx
if (pos == 1) break
step /= 2 #floor integer division
return arr[pos]
（pos == 1）のことを避けるために、循環的にバックアップし（負の数になり）、（pos-1）modnを取ることができます。
以下は、バイナリ検索を使用したCでの実装です。
int rotated_sorted_array_search(int arr[], int low, int high, int target)
{
while(low<=high)
{
int mid = (low+high)/2;
if(target == arr[mid])
return mid;
if(arr[low] <= arr[mid])
{
if(arr[low]<=target && target < arr[mid])
{
high = mid-1;
}
else
low = mid+1;
}
else
{
if(arr[mid]< target && target <=arr[high])
{
low = mid+1;
}
else
high = mid-1;
}
}
return -1;
}
承認された回答が最適ですが、同様のよりクリーンなアルゴリズムを使用することもできます。
- バイナリ検索を実行して、ピボット要素（配列が回転している場所）を見つけます。
O(logn) - ピボットの左半分は降順でソートされます。ここでキーの後方バイナリ検索を実行します。
O(logn) - ピボットの右半分は昇順でソートされます。この半分でキーの前方バイナリ検索を実行します。
O(logn) - 手順2および3で見つかったキーインデックスを返します。
合計時間計算量：O(logn)
考えは大歓迎です。
バイナリ検索を使用して最小要素の場所を見つけ、それをO（Log n）に減らすことができます。
あなたは場所を見つけることができます（これは単なるアルゴリズムのスケッチであり、不正確ですが、そこからアイデアを得ることができます）：
1。私<-1
2。 j <-n
3。 i <j
3.1。 k <-（j-i）/ 2
3.2。 arr [k] <arr [i]の場合、j <-k3.3。そうでなければi <-k
最小の要素の場所を見つけたら、その配列を2つのソートされた配列として扱うことができます。