Question

我目前正在努力解决算法问题。但我想我仍然不完全了解如何计算算法的复杂性。我会说我的代码有复杂度O（n ^ 3），因为它们内部有三个主循环处理数据集，有人可以确认这一点，或者如果我错了，请告诉我这段代码应该如何计算？

public class BigOhN3 {

private Integer[] result;
private long time;


BigOhN3(Integer[] list) {
    long start = System.currentTimeMillis();
    int coefficientSum = calculateCoefficient(list);
    result = new Integer[list.length];

    //Main loop
    for(int i = 0; i < list.length; i++) {
        int coefficientSumIndexI = coefficientSum;
        for(int j = 0; j < list.length; j++) {
            Integer[] listIndexJ = list.clone();
            if(j == i && j < list.length - 1) {
                j++;
            }
            int a = listIndexJ[i];
            int b = listIndexJ[j];
            listIndexJ[i] = b;
            listIndexJ[j] = a;
            int coefficientSumIndexJ = calculateCoefficient(listIndexJ);
            if(coefficientSumIndexJ < coefficientSumIndexI) {
                coefficientSumIndexI = coefficientSumIndexJ;
                result[i] = coefficientSumIndexJ;
            }
        }
        if(result[i] == null) {
            result[i] = coefficientSum;
        }
    }
    time = System.currentTimeMillis() - start;
}

public long getTime() {
    return time;
}

private int calculateCoefficient(Integer[] list) {
    int sum = 0;
    for(int i = 0; i < list.length - 1; i++) {
        int item = list[i] - list[i + 1];
        if(item < 0) {
            item = item * (-1);
        }
        sum = sum + item;
    }
    return sum;
}

Integer[] getResult() {
    return result;
}
}

Answer 1

确实是O(n^3)。但即使没有大多数内循环，由于克隆一个列表（实际上是一个数组）至少需要O(n^3)，因此至少需要读取所有元素，因此它将是O(n)。这意味着算法的复杂性是：

O(n)*O(n)*(O(n)+O(n)) = O(n^3)

n次执行循环a。
每执行一次，执行循环b次每次执行b复制一个数组，它取O（n）并运行第三个循环，执行n次。

计算算法的复杂性 - BigO

1 个答案: