Java 线性搜索和反向线性搜索的执行时间不相同

我已经编写了实现线性搜索（从数组的开头开始）和反向线性搜索（从数组的结尾开始）的代码。现在，当我在1000个数字的样本上运行程序时，1000次（每次使用不同的键），这是累积结果

总时间LS:814632

总时间RLS:581558

我想知道为什么我们在执行时间上有如此明显的差异。我使用system.nanoTime（）来检查时间。我认为，考虑到1000的大分布（调用两个函数1000次），时间差应该不会太大，因为键可能会落在1000个索引中的任何一个

    public static void main(String[] args) throws AWTException, Exception {
            long val[][] = new long[1000][3];
             for(int i=0;i<1000;i++)
             {
               val[i]=   testMethod();
             }
            long ls=0;
            long rls=0;
            long bls=0;
             for(int i=0;i<1000;i++)
             {
                ls= ls+val[i][0];
                rls=rls+val[i][1];
                bls=bls+val[i][2];
             }

             System.out.println("Total Time LS :" + ls);
             System.out.println("Total time RLS : " + rls);
             System.out.println("Total time BLS : " + bls);
        }

    public static long[] testMethod()
    {   long[] val=new long[3];
        int[] arr= new int[1000];
        Random r = new Random();
        for(int i=0;i<1000;i++)
        {
            arr[i]=r.nextInt()%99999;
        }

        int i= Math.abs(r.nextInt()%1000);
        int key =arr[i] ;
     //   int key = arr[900];
    //    System.out.println(i);
        long sysTime1=System.nanoTime();
        int pos_LS= LS(arr,key);
        long sysTime2=System.nanoTime();
        long t=sysTime2-sysTime1;
        val[0]=t;
   //     System.out.println("LS Time : " + t);

         sysTime1=System.nanoTime();
        int pos_RLS=RLS(arr,key);
         sysTime2=System.nanoTime();
         t=sysTime2-sysTime1;
   //     System.out.println("RLS Time : " + t);
        val[1]=t;



        sysTime1=System.nanoTime();
       int pos_BLS=BLS(arr,key);
        sysTime2=System.nanoTime();
        t=sysTime2-sysTime1;
  //     System.out.println("BLS Time : " + t);
       val[2]=t;



        return val;
    }
    public static int LS(int[] arr, int key)
    {
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i]==key)
            {
                return i;
            }
        }
        return -1;
    }



    public static int RLS(int[] arr, int key)
    {   
        for(int i=arr.length-1;i>=0;i--)
        {  
            if(arr[i]==key)
            {   
                return i;
            }
        }
        return -1;
    }

    public static int BLS(int[] arr, int key)
    {
        int len=arr.length;
        for(int i=0;i<len/2;i++)
        {
            if(arr[i]==key || arr[len-1-i]==key)
            {
                if(arr[i]==key)
                {
                    return i;
                }
                else 
                {
                    return len-i-1;
                }

            }
        }
        return -1;

    }

publicstaticvoidmain（字符串[]args）抛出AWTException，异常{
long val[][]=新long[1000][3]；
对于（inti=0；i，在你的实验中有很多细节没有说出来

首先，如果每次都生成随机数据集，则无法得出任何结论。最好是生成一次庞大的数据集，并始终将其用于这些测试。在此之前，我们不能排除线性搜索可能会遇到敌对输入。请记住，O（f（n））符号仅表示，“它的性能不会比这更差”（在线性搜索的例子中，是线性函数）。它并没有声称在多次运行中性能的一致性（见脚注）

接下来，运行总计是什么意思？是否要添加每个搜索的执行时间？这不是一个很好的统计指标。最好绘制单个时间并检查运行时间分布的差异

（附录：我认为每一个做基准测试的程序员都应该阅读。Shaw建议采用标准偏差的另一种方法是查看百分位。与标准偏差一样，它将允许您排除可能会扭曲总数的异常值。）

脚注：多次运行的性能分析属于摊销分析。但是，与更常见的渐近分析（确定单次运行的性能）不同，它并不适用于所有算法。摊销算法和数据结构通常执行“摊销”的额外内部管理任务“对于其他操作的性能成本。
在您的实验中，有很多细节没有说出来

首先，如果每次都生成随机数据集，则无法得出任何结论。最好是生成一次庞大的数据集，并始终将其用于这些测试。在此之前，我们不能排除线性搜索可能会遇到敌对输入。请记住，O（f（n））符号仅表示，“它的性能不会比这更差”（在线性搜索的例子中，是线性函数）。它并没有声称在多次运行中性能的一致性（见脚注）

接下来，运行总计是什么意思？是否要添加每个搜索的执行时间？这不是一个很好的统计指标。最好绘制单个时间并检查运行时间分布的差异

（附录：我认为每一个做基准测试的程序员都应该阅读。Shaw建议采用标准偏差的另一种方法是查看百分位。与标准偏差一样，它将允许您排除可能会扭曲总数的异常值。）

脚注：多次运行的性能分析属于摊销分析。但是，与更常见的渐近分析（确定单次运行的性能）不同，它并不适用于所有算法。摊销算法和数据结构通常执行“摊销”的额外内部管理任务“对于其他操作的性能成本。
我猜，这与编译器以及它们如何实现这些数组有关。这些数组索引在地址空间中的位置、访问方式等

同样，这是一个猜测，我无法确定。另一点值得注意的是，虽然记录的时间一直较高，但它们从未高出一个数量级。从学术计算机科学家的运行时角度来看，这两个都是在O（n）中完成的这些时间反映了这一点。
我猜，这一切都与编译器以及它们如何实现这些数组有关。这些数组索引在地址空间中的位置、访问方式等等

同样，这是一个猜测，我无法确定。另一点值得注意的是，虽然记录的时间一直较高，但它们从未高出一个数量级。从学术计算机科学家的运行时角度来看，这两个都是在O（n）中完成的这些时间反映了这一点。
这完全取决于要搜索的
键

假设您拥有此数据
123456789

与反向线性搜索相比，使用线性搜索搜索
2
所需的时间更短

使用反向线性搜索进行
8
搜索比线性搜索花费的时间更少

如果您搜索
5
，则两者将提供相同的时间
这完全取决于要搜索的
键

假设您拥有此数据
123456789

与反向线性搜索相比，使用线性搜索搜索
2
所需的时间更短

使用反向线性搜索进行
8
搜索比线性搜索花费的时间更少

如果搜索
5
，则两者都将提供相同的时间
如果生成一个新数组，然后运行LS，然后运行RLS，然后生成一个新数组并重复，这取决于计算机上的缓存大小，您可能会体验到数组不在LS的缓存中，而在RLS的缓存中。要验证缓存是否影响您