Java 使用合并排序与自定义排序对arraylist进行排序

我正在编写一个程序，它必须能够对多达10亿个随机

正方形进行排序。我在下面编写了一个小示例程序，它创建了一个随机的
ArrayList
，其中包含
Squares
，然后用两种不同的方法对其进行排序

当我在寻找一种有效的排序方法时，我发现使用
合并排序
是最有效/最快速的。然而，当比较我编写的合并排序和自定义排序（不知道这种排序是否有名称）时，我发现我编写的排序更有效

我从程序中得到的输出是

比较器排序的时间（纳秒）：2346757466

合并排序的时间（纳秒）：24156585699

标准排序更快

那么，为什么我编写的排序比合并排序快得多呢？

是否可以对所使用的排序进行改进，以实现更快、更高效的排序

import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Objects;

public class SortSquares {
    public void run() {
        ArrayList<Square> list = new ArrayList<Square>();
        SecureRandom rand = new SecureRandom();
        int randSize = 10;
        for(int i = 1; i <= 10000000; i++)
            list.add(new Square(i + rand.nextInt(randSize), i + rand.nextInt(randSize)));

        //Create shallow copies to allow for timing
        ArrayList<Square> comp = new ArrayList<Square>(list);
        ArrayList<Square> merge = new ArrayList<Square>(list);

        long startTime = System.nanoTime();
        comp.sort(new SquareSort());
        long endTime = System.nanoTime();
        long duration = (endTime - startTime);
        System.out.println("Time in nanoseconds for comparator sort: " + duration);

        long startTime1 = System.nanoTime();
        merge = mergeSort(merge);
        long endTime1 = System.nanoTime();
        long duration1 = (endTime1 - startTime1);
        System.out.println("Time in nanoseconds for merge sort: " + duration1);

        if(duration < duration1)
            System.out.println("Standard Sort is faster");
        else if(duration == duration1)
            System.out.println("The sorts are the same");
        else
            System.out.println("Merge Sort is faster");
    }

    private class SquareSort implements Comparator<Square> {
        @Override
        public int compare(Square s1, Square s2) {
            if(s1.getLocation()[0] > s2.getLocation()[0]) {
                return 1;
            } else if(s1.getLocation()[0] == s2.getLocation()[0]) {
                if(s1.getLocation()[1] > s2.getLocation()[1]) {
                    return 1;
                } else if(s1.getLocation()[1] == s2.getLocation()[1]) {
                    return 0;
                } else {
                    return -1;
                }
            } else {
                return -1;
            }
        }
    }

    public ArrayList<Square> mergeSort(ArrayList<Square> whole) {
        ArrayList<Square> left = new ArrayList<Square>();
        ArrayList<Square> right = new ArrayList<Square>();
        int center;

        if (whole.size() <= 1) {    
            return whole;
        } else {
            center = whole.size()/2;

            for (int i = 0; i < center; i++) {
                left.add(whole.get(i));
            }

            for (int i = center; i < whole.size(); i++) {
                right.add(whole.get(i));
            }

            left  = mergeSort(left);
            right = mergeSort(right);

            merge(left, right, whole);
        }
        return whole;
    }

    private void merge(ArrayList<Square> left, ArrayList<Square> right, ArrayList<Square> whole) {
        int leftIndex = 0;
        int rightIndex = 0;
        int wholeIndex = 0;

        while (leftIndex < left.size() && rightIndex < right.size()) {
            if ((left.get(leftIndex).compareTo(right.get(rightIndex))) < 0) {
                whole.set(wholeIndex, left.get(leftIndex));
                leftIndex++;
            } else {
                whole.set(wholeIndex, right.get(rightIndex));
                rightIndex++;
            }
            wholeIndex++;
        }

        ArrayList<Square> rest;
        int restIndex;
        if (leftIndex >= left.size()) {
            rest = right;
            restIndex = rightIndex;
        } else {
            rest = left;
            restIndex = leftIndex;
        }

        for (int i = restIndex; i < rest.size(); i++) {
            whole.set(wholeIndex, rest.get(i));
            wholeIndex++;
        }
    }

    private class Square {
        private int[] location = new int[2];

        public Square(int x, int y) {
            location[0] = x;
            location[1] = y;
        }

        public int[] getLocation() {
            return location;
        }

        @Override
        public boolean equals(Object obj) {
            if(obj instanceof Square)
                if(getLocation()[0] == ((Square) obj).getLocation()[0] && 
                        getLocation()[1] == ((Square) obj).getLocation()[1])
                return true;
            return false;
        }

        @Override
        public int hashCode() {
            return Objects.hash(getLocation()[0], getLocation()[1]);    
        }

        public int compareTo(Square arg0) {
            if(getLocation()[0] > arg0.getLocation()[0]) {
                return 1;
            } else if(getLocation()[0] == arg0.getLocation()[0]) {
                if(getLocation()[1] > arg0.getLocation()[1]) {
                    return 1;
                } else if(getLocation()[1] == arg0.getLocation()[1]) {
                    return 0;
                } else {
                    return -1;
                }
            } else {
                return -1;
            }
        }
    }

    public static void main(String[] args) {
        SortSquares e = new SortSquares();
        e.run();
    }
}

导入java.security.SecureRandom；
导入java.util.ArrayList；
导入java.util.Comparator；
导入java.util.Objects；
公共类分拣区{
公开募捐{
ArrayList=新建ArrayList（）；
SecureRandom rand=新的SecureRandom（）；
int randSize=10；
对于（int i=1；i s2.getLocation（）[0]）{
返回1；
}else if（s1.getLocation（）[0]==s2.getLocation（）[0]）{
如果（s1.getLocation（）[1]>s2.getLocation（）[1]）{
返回1；
}else if（s1.getLocation（）[1]==s2.getLocation（）[1]）{
返回0；
}否则{
返回-1；
}
}否则{
返回-1；
}
}
}
公共ArrayList合并排序（整个ArrayList）{
ArrayList left=新的ArrayList（）；
ArrayList right=新的ArrayList（）；
国际中心；
if（整.size（）=左.size（））{
休息=右；
restIndex=rightIndex；
}否则{
休息=左；
restIndex=leftIndex；
}
for（int i=restIndex；iarg0.getLocation（）[0]）{
返回1；
}else if（getLocation（）[0]==arg0.getLocation（）[0]）{
如果（getLocation（）[1]>arg0.getLocation（）[1]）{
返回1；
}else if（getLocation（）[1]==arg0.getLocation（）[1]）{
返回0；
}否则{
返回-1；
}
}否则{
返回-1；
}
}
}
公共静态void main（字符串[]args）{
SortSquares e=新的SortSquares（）；
e、 run（）；
}
}
事实正好相反：标准方法要快得多

首先，在对递归函数mergeSort的每次调用中创建两个数组。标准数组可能会合并原始数组中的元素，并使用范围开始和结束的索引

其次，标准方法可以在多核机器上启动新线程。
考虑到算法，它在很大程度上取决于数据

假设您的排序方法是quicksort。
您有O（n2）最坏情况运行时和O（nlogn）平均情况运行时

合并排序始终为O（n日志n）。这意味着稳定。这就是为什么选择它对java集合进行排序

sort和您实现的mergesort都是相同的算法（java集合上的排序基于mergesort）。您需要多次运行相同的代码，并首先预热jvm以获得更可靠的结果。
以某种方式，您可以确保自定义mergesort是高效的，并与collections进行比较

在任何情况下，您都不必为简单的事情实现自己的合并排序。
您可以使用jdk中的java.util.Collections.sort（列表）方法。如上所述，它使用复杂度为O（nlogn）的合并排序

为了度量您的实现的性能并将其与其他实现进行比较，我建议使用jmh。请在下面找到一个简短的例子

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode( Mode.AverageTime )
@OutputTimeUnit( TimeUnit.NANOSECONDS )
@State( Scope.Benchmark )
@Warmup( iterations = 5)
@Measurement( iterations = 5 )
@Fork( value = 1)
public class SortingPerformanceBenchmark
{
    private final int[] dataArray = new int[10_000_000];
    List<Integer> arrayList;

    @Setup
    public void load() {
        Random rand = new Random();
        for (int i = 0; i < dataArray.length; ++i) {
           dataArray[i] = rand.nextInt();
        }
   }

   @Benchmark
    public List<Integer> Benchmark_SortObjects() {
             arrayList = new ArrayList( Arrays.asList( dataArray ) );
             Collections.sort( arrayList );

          return arrayList;
    }

    public static void main(String... args) throws Exception {
       Options opts = new OptionsBuilder()
        .include(SortingPerformanceBenchmark.class.getSimpleName())
        .build();
    new Runner( opts).run();
    }
}

import org.openjdk.jmh.annotations.*；
导入org.openjdk.jmh.runner.runner；
导入org.openjdk.jmh.runner.options.options；
导入org.openjdk.jmh.runner.options.OptionsBuilder；
导入java.util.*；
导入java.util.concurrent.TimeUnit；
@基准模式（Mode.AverageTime）
@输出时间单位（时间单位。纳秒）
@国家（范围、基准）
@预热（迭代次数=5次）
@测量（迭代次数=5次）
@Fork（值=1）
公共类排序性能BenchMark
{
private final int[]dataArray=新int[10\u 000\u 000]；
列表数组列表；
@设置
公共空荷载（）{
Random rand=新的Random（）；
对于（int i=0；i