Java 从二进制搜索到三元搜索

因为三元搜索不如二元搜索方便，因为每次调用三元搜索都需要进行两次对抗，而二元搜索只需要一次：因此三元搜索需要2log3（n）和二进制log2（n）。这是众所周知的事实

我有个主意

有一种称为三元搜索的算法，它允许在数组上查找函数f的最大值，前提是该最大值是唯一的一个。下面是Java代码：

    public static <T> int ternarySearch(T[] array, Function<T,Double> f){
        int l = 0, r = array.length,
                m1 = l + (r-l)/3,
                m2 = r - (r-l)/3,
                valutation;
        while( m1 != m2 )
            {
            valutation = f.apply(array[m1]).compareTo(f.apply(array[m2]));
            switch(valutation)
                {
                case -1:    {   r = m1;                 m1 = l + (r-l)/3;   m2 = r - (r-l)/3;   break;  }
                case  0:    {   l = m1;     r = m2;     m1 = l + (r-l)/3;   m2 = r - (r-l)/3;   break;  }
                case  1:    {   l = m2;                 m1 = l + (r-l)/3;   m2 = r - (r-l)/3;   break;  }
                }
            }       
        return m1;
    }

公共静态内部搜索（T[]数组，函数f）{
int l=0，r=array.length，
m1=l+（r-l）/3，
m2=r-（r-l）/3，
估价；
而（m1！=m2）
{
VALUATION=f.apply（数组[m1]）。与f.apply（数组[m2]）相比；
开关（价值）
{
案例1:{r=m1；m1=l+（r-l）/3；m2=r-（r-l）/3；break；}
案例0:{l=m1；r=m2；m1=l+（r-l）/3；m2=r-（r-l）/3；break；}
案例1：{l=m2；m1=l+（r-l）/3；m2=r-（r-l）/3；break；}
}
}       
返回m1；
}

如果我们可以找到一个函数，它只有一个choosen

键

和如果方法

compareTo（）

的代价是数字之间只有一个对峙，调用

ternarySearch（array，f）

只需要log3（n）：比二进制搜索少

现在，我的问题是：

我们如何选择这样的函数

f

方法

compareTo（）

是否只需要一个数字

我的想法对吗

答复:

只需使用身份函数

f（x）=x

来简化事情-试图找到最适合这些值的函数将大大降低此搜索的适用性；标识函数和不递减值（排序）数组是很好的起点

不，成本2（见下文）

我不这么认为，原因如下：

这里有几个要点：

• 三元搜索有可能过滤掉更多的数字（2/3而不是1/2），但只有1/3的时间（以及2/3的时间过滤掉1/3的空间），而且它确实需要比二元搜索多1次比较，即使使用

  整数。compareTo（）

  
  请检查
• 按照您的思路，我们应该使用N来实现N元搜索，其性能优于二进制搜索，并且随着Ns的增长，其回报率会逐渐降低，因为比较的数量也会N
• 请看下面的几个答案