Java 一种结合线性搜索和二进制搜索的搜索算法

正如标题所说，我想做一个结合linearSearch和binarySearch的搜索算法。如果数组中的元素少于20个，我希望使用linearSearch或二进制搜索

-应该对数组进行排序

-该数组属于可比较类型的元素

-算法应该返回找到元素的索引，否则应该返回-1

我的代码，但我有点卡住了。。我走对了吗

public class SearchAlgorithm<T extends Comparable<T>> {

public int linearSearch(T[] Array, T find){
    int temp = 0; 
    for(int i = 0; i < Array.length; i++){
        if(Array[i] == find){
            temp = i;
        }
        else{
            temp = -1;
        }
    }
    return temp;

}
public int binarySearch(T[] Array, T find){
    int lowIdx = 0;
    int highIdx = Array.length-1;
    int middleIdx = 0;

    while(lowIdx <= highIdx){
        middleIdx = (highIdx + lowIdx)/2;
        int comp = find.compareTo(Array[middleIdx]);

        if(comp < 0)
            lowIdx = middleIdx + 1;

        else if(comp > 0)
            highIdx = middleIdx -1;

        else{
            lowIdx = highIdx+1;
            return middleIdx;
        }
    }
    return -1;
}
public void combinedSearch(T[] Arr, T find){
    long startTime = System.currentTimeMillis();
    if(Arr.length < 20){
        linearSearch(Arr,find);
    }
    else{
        binarySearch(Arr,find);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("combinedSearch took: "+(endTime-startTime)+ "ms");
}
public static void main(String[] args){
    int[] a = {1,2,3,4,5};
    binarySearch(a,4);
}

公共类搜索算法{
public int linearSearch（T[]数组，T find）{
内部温度=0；
for（int i=0；i

}

用于线性搜索

if(Array[i] == find){
        temp = i;
    }
    else{
        temp = -1;
    }

每次不匹配时，将其设置为-1。应该是这样的：

int temp = -1; 
for(int i = 0; i < Array.length; i++){
    if(Array[i] == find){
        temp = i;
        return temp;
    }
}
return temp;

int-temp=-1；
for（int i=0；i

同样对于二进制搜索，您应该反转比较。若你们找到的数字小于中间值，那个么它在左半部分，依此类推

if(comp > 0)
        lowIdx = middleIdx + 1;

    else if(comp < 0)
        highIdx = middleIdx -1;

if（comp>0）
低IDX=中IDX+1；
否则如果（组件<0）
highIdx=middleIdx-1；

在计时方法返回任何有意义的结果之前，至少需要一百万个元素！那么这种搜索算法的时间复杂度是多少？这不是取决于数组中元素的数量吗？如果它少于20个元素，它只有O（N），因为如果它超过20个元素，它选择线性搜索和O（logn）？否。渐近符号仅适用于无界N（N任意大）。“低于20个元素”是不相关的，因为这是有界的。尽管该算法存在时间复杂度和渐近行为方面的（重大）问题，但不必要地引入了泛型。编写的代码甚至不会编译（从静态上下文调用的非静态方法，

int[]

不能在需要

t[]

的地方提供…）关于优化的说明。几年前，我在.NET中做了一些测试（我完全理解它不同于Java），发现当整数列表包含少于10个元素时，顺序搜索整数列表比二进制搜索要快。随着比较成本的增加，顺序搜索的利润率下降。当比较10个仅在最后一个字符中存在差异的字符串时，顺序搜索在大约5个元素处输给了二进制搜索。我的观点是，如果你这样做是为了教育，那太好了。但是作为一种优化，它不是很有效。