Question

我有一个被排序的数组，它被旋转了n次，n是未知的。现在我想在O（nlog n）中使用二进制搜索来搜索一个元素。我实现了下面的代码，它工作正常。但我认为条件if（（end-start）== 1）可以通过做一些修改来跳过，任何人都可以建议吗？

Eg of array 1 2 3 4 5 
            2 3 4 5 1 //rotated once

代码：

public static int srch(int a[],int start,int end,int key){
    if(start>end)
        return -1;

    if((end-start)==1 ){
        if(key==a[start])
            return start;
        else if(key==a[end])
            return end;
        else
            return -1;
    }
    int mid = (start+end)/2;

    if(a[mid]== key){
        return mid;
    }
    else{
        if(a[start] < a[mid] ){
            //first half is sorted
            if(key>a[mid]|| key <a[start]){
                start= mid+1;
            }else{
                end =mid-1;
            }
        }else{
            //second half is sorted

            if(key>a[mid]){
                start= mid+1;
            }else{
                end =mid-1;
            }
        }
        return srch(a, start, end, key);
    }
}

任何更好/更简单/更有效的解决方案？

Answer 1

对于数组{4,5,1,2,3}和key = 4，您的解决方案失败。我认为第二部分的修改将解决问题

else{
            //second half is sorted

            if(key>a[mid] && key<=a[end]){// modified condition
                start= mid+1;
            }else{
                end =mid-1;
            }

但我认为条件 if（（end-start）== 1）可以跳过进行一些修改，可以任何一个建议？

我认为根本不需要这种情况。你可以建议一个测试用例，你的修改后的代码就会失败。

public static int srch(int a[],int start,int end,int key){
    if(start>end)
        return -1;

     int mid = (start+end)/2;

    if(a[mid]== key){
        return mid;
    }
    else{
        if(a[start] < a[mid] ){
            //first half is sorted
            if(key>a[mid]|| key <a[start]){
                start= mid+1;
            }else{
                end =mid-1;
            }
        }else{
            //second half is sorted

            if(key>a[mid] && key<=a[high]){
                start= mid+1;
            }else{
                end =mid-1;
            }
        }
        return srch(a, start, end, key);
    }
}

Answer 2

您的解决方案在O（log n）中运行，因此无法提供更高效的解决方案。也许你的部分代码可以被优化，但这不会影响O的运行时间。正如你所说，代码工作并返回正确的值，因此我认为这是你的面试问题的正确答案。 / p>

Answer 3

我没有彻底检查你的代码是否正确，但你的解决方案是O（log n）。你无法通过算法获得更好的解决方案。

搜索数组中旋转了N次的元素

3 个答案: