Algorithm 优化搜索-有人能帮助计算这个算法的复杂性吗

当我看到二进制搜索算法时。我有一种感觉，搜索点可以通过不总是看中间点来优化。例如，如果我们在字典中查找一个单词而不查看菜单，我们不会总是转到中间页进行比较。如果这个词以“A”开头，我们会期望它在接近开头的地方出现。如果它以“Z”开头，我们肯定会尝试在结尾的页面

但是，始终使用当前目标阵列的密度将导致一些重大问题，如果阵列的密度发生急剧变化，这将导致算法在某些情况下以接近O（n）的复杂度结束。因此，我根据之前的搜索计算了密度，并且总是从较小的分割计算密度。并始终从上一个搜索点计算搜索点。在这方面，它减轻了密度变化的影响

所以我写了这段代码试图生成一个优化的搜索。我还没有测试它（甚至还没有编译）。但我想这解释了算法：

public int OptimizedSearch(int a[], int target) {
        return OptimizedSearch(a, target, 0, a.size(), 0, true);
    }

    public int OptimizedSearch(int a[], int target, int start, int end, double density, boolean fromStart) {
        // Since density is different from the density in current target array, the search point calculated from density will
        // always start from last search point. fromStart records whether the last search point happens at start or end of
        // current array
        if (0 == density) { //Initial density
            density = (a[end] - a[start]) / (end - start);
        }

        int searchPoint;    
        if (fromStart) {
            searchPoint = start + ((target - a[start]) / density).intValue();
        }
        else {
            searchPoint = end - ((a[end] - target) / density).intValue();
        }

        if (a[searchPoint] == target) {
            return searchPoint;
        }
        else if (target < a[searchPoint]) {
            double currentDensity;
            if (end - searchPoint > searchPoint - start) {
                currentDensity = (a[searchPoint] - a[start]) / (searchPoint - start);
            }
            else {
                currentDensity = (a[end] - a[searchPoint]) / (end - searchPoint); 
            } //Density is always calculated from the smaller part since it will be more accurate. 
            return OptimizedSearch(a, target, start, searchPoint - 1, currentDensity, false);
        }
        else {
            double currentDensity;
            if (end - searchPoint > searchPoint - start) {
                currentDensity = (a[searchPoint] - a[start]) / (searchPoint - start);
            }
            else {
                currentDensity = (a[end] - a[searchPoint]) / (end - searchPoint); 
            } //Density is always calculated from the smaller part since it will be more accurate. 
            return OptimizedSearch(a, target, searchPoint + 1, end, currentDensity, true);
        }
    }

public int-OptimizedSearch（int a[]，int-target）{
返回OptimizedSearch（a，target，0，a.size（），0，true）；
}
公共整数优化搜索（整数a[]，整数目标，整数开始，整数结束，双密度，布尔起始）{
//由于密度与当前目标阵列中的密度不同，因此根据密度计算的搜索点将
//始终从最后一个搜索点开始。fromStart记录最后一个搜索点是发生在搜索的开始还是结束
//电流阵列
如果（0==密度）{//初始密度
密度=（a[结束]-a[开始]/（结束-开始）；
}
国际搜索点；
如果（从开始）{
searchPoint=start+（（target-a[start]）/density）.intValue（）；
}
否则{
searchPoint=end-（（a[end]-target）/density.intValue（）；
}
if（a[搜索点]==目标）{
返回搜索点；
}
否则，如果（目标搜索点-开始）{
电流密度=（a[searchPoint]-a[start]）/（searchPoint-start）；
}
否则{
电流密度=（a[结束]-a[搜索点]/（结束-搜索点）；
}//密度总是从较小的部分计算，因为它更精确。
返回OptimizedSearch（a，目标，开始，搜索点-1，currentDensity，false）；
}
否则{
双电流密度；
如果（结束-搜索点>搜索点-开始）{
电流密度=（a[searchPoint]-a[start]）/（searchPoint-start）；
}
否则{
电流密度=（a[结束]-a[搜索点]/（结束-搜索点）；
}//密度总是从较小的部分计算，因为它更精确。
返回优化搜索（a，目标，搜索点+1，结束，currentDensity，true）；
}
}

但我真的发现很难计算复杂性。我觉得它应该低于log（N），但我不能证明它。有人能帮忙吗？

这是元素分布的一个实现，如果元素分布的近似值足够好，它就有复杂度log（log（n））。然而，要证明这一点绝非易事。

由于决策模型的下限，在最坏的情况下，它肯定是ω（logn）。