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

Question

给定一个数组首先增加然后在某个点减少然后再次增加？ 查找给定数 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)中的线性搜索来完成， 我们能不能做得比这少。 （更高效）

Answer 1

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

l = range(n)

我们随机在其中粘贴-1：

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

判断列表中是否有-1 的唯一方法是查看每个元素，直到找到或没有。列表的结构最终毫无帮助。

Answer 2

线性搜索与非线性数组一样好

Answer 3

优化算法： -

1. 如果找到，则对数组中的键使用二进制搜索，然后返回 true。
2. 如果找不到，请使用线性搜索

时间复杂度：-

不成功的搜索：这里我们将同时进行线性搜索和二分搜索，因此对于大输入的 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);
    } 
}

结果：

运行代码并等待 6-7 秒，您将看到在特殊类型的随机数组上进行随机成功搜索，因为您的问题需要线性搜索大约 30% 次，其余的可以使用 @987654322 中的二进制搜索完成@

Answer 4

可以在 O(logN) 时间复杂度内完成

1. 在数组中查找最大元素（称为此枢轴）。这是伪代码

   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;
   }
   

2. 在枢轴元素上划分数组并运行两个二项式搜索左（增加）和右（减少）

   findElem(int key, int pivot){
     int index = binSearchInc(start, pivot-1);
     if(index>=0)
       return index;
     else 
       return binSearchDec(pivot+1, end);
   }
   

这两个步骤都需要 O(logN) 时间来执行。