Arrays 检查数组中是否存在先增加后减少再增加的数字

给定一个数组，先增加，然后在某一点上减少，然后再增加？ 查找数组中是否存在给定的数字N

例1：

Array = 7,8,3,4,5,6 
number = 7 

答案应该是正确的

例2：

Array = 3,4,6,7,8,5,9,10,11  
number = 10

答案应该是正确的。 所有数字都是唯一的

可通过

O（N）

中的线性搜索完成，

---

我们能不能少做一点。（更有效）

线性搜索与非线性数组的搜索效果一样好

一般来说，没有。假设我们在Python中有以下内容：

l = range(n)

我们在里面随机粘贴一个

-1

：

if random.random() < 0.5:
    l[random.randrange(len(l))] = -1

if random.random（）<0.5：
l[random.randrange（len（l））]=-1

---

判断列表中是否有

-1

的唯一方法是查看每个元素，直到找到它为止。列表的结构最终毫无帮助。

优化算法：-

对数组中的键使用二进制搜索，如果找到，则返回true

如果未找到，则使用线性搜索

时间复杂性：-

不成功的搜索：在这里，我们将同时进行线性搜索和二进制搜索，因此对大输入进行O（N）

成功搜索：在某种程度上，我们的优化工作就是在这里进行的。在二进制搜索中，平均有1/2的几率最终在数组的右侧进行搜索。因此，平均搜索速度至少提高了2倍

优化算法的Java代码及其结果：-

public class UniqueSearch {
    static int linearCount = 0;
    public static boolean binSearch(int[] arr,int key,int high,int low) {


        while(high>=low) {
            int mid = (low+high)/2;
            if(arr[mid]==key) 
                return(true);
            if(arr[mid]<key) {
                low = mid+1;
            }
            else {
                high = mid-1;
            }
        }
        return(false);
    }

    public static boolean linearSearch(int arr[],int key) {
        //System.out.println("linearSearch");
        linearCount++;
        for(int i=0;i<arr.length;i++) {
            if(key==arr[i]) {
                return(true);
            }
        }
        return(false);
    }


    public static boolean optSearch2(int arr[],int key) {

        boolean flag = binSearch(arr, key, arr.length-1,0);
        if(!flag) {
            return(linearSearch(arr, key));
        }
        return(flag);
    }

    public static void main(String[] args) {

        int n = 100000;
        int[] arr = new int[n];
        int error = 0;
        Random r = new Random();
        long start = System.currentTimeMillis();
        int totalCount = 0;
        for(int i=0;i<1000;i++) {
            error = r.nextInt(arr.length-1);
            for(int k=0;k<error;k++) {
                arr[k] = 2*k+1;
            }
            for(int k=error;k<arr.length;k++) {
                arr[k] = 2*(k-error);
            }
            for(int j=0;j<1000;j++) {
                int x = r.nextInt(arr.length); 
                totalCount++;
                    boolean flag = optSearch2(arr,arr[x]);
                    if(!flag) {
                        System.out.println("error");
                    }

            }
        }
        System.out.println("linearSearch Percentage: "+linearCount*100/totalCount);
        System.out.println(System.currentTimeMillis()-start);
    } 
}

公共类唯一搜索{
静态整数线性计数=0；
公共静态布尔binSearch（int[]arr，int-key，int-high，int-low）{
而（高>=低）{
int mid=（低+高）/2；
if（arr[mid]==键）
返回（真）；
如果（arr[mid]可以在O（logN）时间复杂度下完成

查找数组中的最大元素（称为pivot）

public static int getMax(int start, int end){

if(start==end)
    return start;
if(start>end)
    return -1;

int mid = start + (end-start)/2;
// check if maxima
if(arr[mid-1]<arr[mid] && arr[mid]>arr[mid+1])
    return mid;

// check slope
if(arr[mid-1]<arr[mid] && arr[mid]<arr[mid+1]){
    //increasing slope
    return getMax(mid+1, end);
}
if(arr[mid-1]>arr[mid] && arr[mid]>arr[mid+1]){
    return getMax(start, mid-1);
}

return -1;
}


这两个步骤都需要O（logN）时间来执行。
可能重复-一般来说，线性搜索与非线性数组的搜索一样好。关于修改的三元搜索，运行两到三次如何？也许您可以得到时间复杂度
O（logN）
不，对于未排序的数组搜索（存在性查找）hes O（N）困难。我不认为我们可以简单地将其视为未排序的数组，因为该数组已经具有结构。例如，我们可以在线性时间内对该数组进行排序。但是user2357112的示例表明，该结构最终无法帮助我们搜索。问题在于（如user2357112的示例所示）递减段可能非常小，需要线性时间来定位。因此，你不能真正利用这一点发挥自己的优势。你如何在算法2中使用二进制搜索？@Teepeemm在算法2中，你可以以1/4的概率在数组的右侧部分结束搜索，因此成功搜索的概率约为3/4*n/2如果数组的递减部分较大，那么我们可以进行二进制搜索。如果递增部分的大小大致相同，并且其中一个包含所需的数字。但最坏的情况必须是
O（n）
根据给定的示例，我不知道如何使用该设置打败线性搜索。@Teepeemm我不是说你不能打败O（N），但是你可以将线性搜索的概率降低到50%，二进制搜索的概率降低到50%，以获得成功的搜索
findElem(int key, int pivot){
  int index = binSearchInc(start, pivot-1);
  if(index>=0)
    return index;
  else 
    return binSearchDec(pivot+1, end);
}