Java:Is Merge Sort是O（N^2）还是O（N Log（N））

我创建了自己的合并排序实现，并对其进行了测试。然而，我不确定它是应该是O（N Log（N））还是O（N^2），你能看看我的代码并告诉我吗

分类列表

public abstract class SortedList {
    public final ArrayList<Integer> params = new ArrayList<Integer>();

    public void add(int... params) {
        for (int parameter : params) {
            this.params.add(parameter);
        }
    }

    abstract public void sort();

    public void print() {
        for (int parameter : params) {
            System.out.print(parameter + " ");
        }
        System.out.println();
    }
}

public class MargeSort extends SortedList{

    private int buffer[];

    @Override
    public void sort() {
        buffer = new int[params.size()];
        for(int i = 1; i < params.size(); i *= 2){
            sort(i);
        }
    }

    private void sort(int interval) {
        for(int i = 0; i < params.size() - interval; i += interval * 2){
            sort(i, i + interval, interval);
        }
    }

    private void sort(int index1, int index2, int interval) {
        int startingIndex = index1;
        int index1MaxValue = index1 + interval;
        int index2MaxValue = index2 + interval;
        if(index2MaxValue >= params.size()){
            index2MaxValue = params.size();
        }
        int counter = 0;

        for(counter = 0; index1 < index1MaxValue && index2 < index2MaxValue; counter++){
            int param1 = params.get(index1);
            int param2 = params.get(index2);
            if(param1 < param2){
                buffer[counter] = param1;
                index1++;
            }
            else{
                buffer[counter] = param2;
                index2++;
            }
        }
        int index, indexMaxValue;
        if(index1 < index1MaxValue){
            index = index1;
            indexMaxValue = index1MaxValue;
        }
        else{
            index = index2;
            indexMaxValue = index2MaxValue;
        }

        while(index < indexMaxValue){
            int param = params.get(index);
            buffer[counter] = param;
            index++;
            counter++;
        }

        for(int i = 0; i < interval * 2 && i + startingIndex < params.size(); i++){
            params.set(i + startingIndex, buffer[i]);
        }
    }
}

公共抽象类分类列表{
public final ArrayList params=new ArrayList（）；
公共无效添加（int…params）{
for（int参数：params）{
此.params.add（参数）；
}
}
抽象公共空排序（）；
公开作废印刷品（）{
for（int参数：params）{
系统输出打印（参数+“”）；
}
System.out.println（）；
}
}

MargeSort

public abstract class SortedList {
    public final ArrayList<Integer> params = new ArrayList<Integer>();

    public void add(int... params) {
        for (int parameter : params) {
            this.params.add(parameter);
        }
    }

    abstract public void sort();

    public void print() {
        for (int parameter : params) {
            System.out.print(parameter + " ");
        }
        System.out.println();
    }
}

public class MargeSort extends SortedList{

    private int buffer[];

    @Override
    public void sort() {
        buffer = new int[params.size()];
        for(int i = 1; i < params.size(); i *= 2){
            sort(i);
        }
    }

    private void sort(int interval) {
        for(int i = 0; i < params.size() - interval; i += interval * 2){
            sort(i, i + interval, interval);
        }
    }

    private void sort(int index1, int index2, int interval) {
        int startingIndex = index1;
        int index1MaxValue = index1 + interval;
        int index2MaxValue = index2 + interval;
        if(index2MaxValue >= params.size()){
            index2MaxValue = params.size();
        }
        int counter = 0;

        for(counter = 0; index1 < index1MaxValue && index2 < index2MaxValue; counter++){
            int param1 = params.get(index1);
            int param2 = params.get(index2);
            if(param1 < param2){
                buffer[counter] = param1;
                index1++;
            }
            else{
                buffer[counter] = param2;
                index2++;
            }
        }
        int index, indexMaxValue;
        if(index1 < index1MaxValue){
            index = index1;
            indexMaxValue = index1MaxValue;
        }
        else{
            index = index2;
            indexMaxValue = index2MaxValue;
        }

        while(index < indexMaxValue){
            int param = params.get(index);
            buffer[counter] = param;
            index++;
            counter++;
        }

        for(int i = 0; i < interval * 2 && i + startingIndex < params.size(); i++){
            params.set(i + startingIndex, buffer[i]);
        }
    }
}

公共类MargeSort扩展了分类列表{
专用整数缓冲区[]；
@凌驾
公共无效排序（）{
buffer=newint[params.size（）]；
对于（int i=1；i=params.size（））{
index2MaxValue=params.size（）；
}
int计数器=0；
用于（计数器=0；index1

sort（int）

被称为

lg N

次，其中

N=params.size（）

。[

lg N

在这里和任何地方进一步表示

celi（lg N）

]

循环

sort（int）

循环

N/（interval/2）

次，其中

interval在[1..lgN]

中，调用

sort（…）

，它执行nr个步骤，这是线性的，取决于它的“

间隔”

参数

因此，步骤的数量为：

Sigma（k从1到lgN）：（N/（区间/2））*（C*区间）=C*N/2*Sigma（1..lgN）1=C*N*lgN/2

---

[C是计算内部

排序（…）

成本的常数]

仅从代码看，我既没有看到递归调用，也没有看到维护某些索引的堆栈。请澄清合并应在何处进行；事实上，你可能已经实现了一个不同的算法。合并排序是O（nlogn），也就是O（n^2）。这有点难理解，但我明白了。从更深的角度看，我认为C在平均和最坏的情况下等于2，这也是唯一符合逻辑的；）