Question

我正在编写一个java方法来查找数组的稳定性索引。我的算法工作正常，但我不确定它的运行时复杂性。我认为它是O（n），因为第一个循环是O（n），两个内循环是O（2n），但我不确定。

int[] arr = {0, -3, 5, -4, -2, 3, 1, 0};

for(int num = 0; num < arr.length; num++){
    int sumLeft= 0;
    int sumRight = 0;
    for(int i = 0; i<num; i++){
        sumLeft= sumLeft + arr[i];
    }
    for(int i = num + 1; i < arr.length;i++){
        sumRight= sumRight + arr[i];
    }
    if(sumLeft==sumRight){
        System.out.println(num);
    }
}

输出：

0
3
7

Answer 1

我们可以做两件事：

我们可以给你一个答案，答案是O(N^2)。
我们可以解释如何为自己解决这个问题。

解决问题的方法是计算操作。

当我说＆＃34;计算＆＃34;时，我不是字面意思。实际上我的意思是你需要计算代数公式，执行一些指示性操作的次数。

因此，在您的示例中，我将这两个语句标识为最重要的语句：

      sumLeft= sumLeft + arr[i];

      sumRight= sumRight + arr[i];

（为什么我选择这些陈述？直觉/经验！迂腐这样做的方法是计算所有操作。但是根据经验，你可以选择重要的那些......其余的都不重要。）

现在对于公式：

在外循环的一次迭代中，第一个语句从0 to num-1执行;即num次。
在外循环的一次迭代中，第二个语句从num+1 to array.length - 1执行;即array.length - num - 1次。
因此，在外部循环的一次迭代中，两个语句执行num + array.length - num - 1次，减少到array.length - 1次。
但外循环运行array.length次。因此，这两个语句执行array.length x (array.length - 1)次。

最后，根据Big Oh的定义，array.length x (array.length - 1)位于复杂性类O(N^2)中，其中N是数组大小。

Answer 2

是O（n ^ 2）

...
"devDependencies": {
  "babel-cli": "latest",
  "babel-core": "^6.26.3",
  "babel-eslint": "^8.2.3",
  "babel-jest": "^22.4.4",
  "babel-loader": "latest",
  "babel-plugin-dynamic-import-node": "^1.2.0",
  "babel-plugin-lodash": "latest",
  "babel-plugin-syntax-dynamic-import": "^6.18.0",
  "babel-plugin-transform-class-properties": "^6.24.1",
  "babel-plugin-transform-decorators-legacy": "latest",
  "babel-plugin-transform-dynamic-import": "^2.0.0",
  "babel-plugin-transform-flow-strip-types": "^6.22.0",
  "babel-plugin-transform-object-rest-spread": "latest",
  "babel-polyfill": "^6.26.0",
  "babel-preset-env": "^1.7.0",
  "babel-preset-flow": "^6.23.0",
  "babel-preset-react": "^6.24.1",
  "babel-preset-react-app-babel-7": "^4.0.1",
  "babel-preset-stage-0": "^6.24.1",
 ...

One for循环中的两个for循环的运行时复杂度

2 个答案: