Arrays 空间复杂性-各种情况下涉及数组的函数

在这里，我写了一些不同的函数案例，这些函数以数组作为输入，我需要帮助来确定我的答案背后的推理是否正确（我在我遇到困难的案例上打了问号）

案例1:

algo(arr[],n){
  //does nothing
}

algo(arr[],n){
   int i;
}

algo(arr[],n){
   int i;
   for(i=0; i<n ; i++){
    //does nothing
   }
}

空格=（0）+0=O（1）

辅助空间=0=O（1）

（原因：分配给输入的存储尚未使用，函数内未声明临时存储）

案例2:

algo(arr[],n){
  //does nothing
}

algo(arr[],n){
   int i;
}

algo(arr[],n){
   int i;
   for(i=0; i<n ; i++){
    //does nothing
   }
}

空格=（0）+1=O（1）

辅助空间=1=O（1）

（原因：为输入分配的存储尚未使用，需要为变量i分配一个临时存储）

案例3:

algo(arr[],n){
  //does nothing
}

algo(arr[],n){
   int i;
}

algo(arr[],n){
   int i;
   for(i=0; i<n ; i++){
    //does nothing
   }
}

空格=（1+1）+0=O（1）

辅助空间=0=O（1）

（原因：正在处理变量n的1个存储，并且在arr[]中始终只处理1个存储，无论n的值是多少，都没有声明临时存储）

案例6：

algo(arr1[],n){
   int i;
   int m=10;
   int arr2[m];

   for(i=0;i<m;i++){
     arr2[i]= i;
   }   

}

其中，arr[]是大小为L的数组，其中L>i

algo(arr[],n){
   int i = 1;
  arr[i]=i;
}

algo(arr[],n){
   int i;
   for(i=0;i<n;i++){
    // does nothing
   }
   i = 1;
   arr[i] = i;

}

空格=（1）+1=O（1）

辅助空间=1=O（1）

（原因：在arr[]中只有一个存储始终工作，它始终在arr[i]中，而i需要一个临时存储）

案例7：

algo(arr1[],n){
   int i;
   int m=10;
   int arr2[m];

   for(i=0;i<m;i++){
     arr2[i]= i;
   }   

}

其中，arr[]是大小为L的数组，其中L>n

algo(arr[],n){
   int i;
   for(i=0;i<n;i++){
    arr[i] = i;
   }
}

algo(arr[],n){               
   arr[n]=n;
}

algo(arr[],n){
   int i;
   for(i=0;i<n;i++){
    // does nothing
   }
   arr[n] = n;

}

空格=（1）+n=O（n）

辅助空间=n=O（n）

（原因：1个存储用于处理变量n，n个临时存储用于arr2[]）

案例10：

algo(arr1[],n){
   int i;
   int m=10;
   int arr2[m];

   for(i=0;i<m;i++){
     arr2[i]= i;
   }   

}

其中，arr1[]是大小为L的数组

algo(arr1[],n){
   int m=1;
   int arr2[m];
}

空间=（0）+1+m=O（m）

辅助空间=1+m=O（m）

（原因：变量m需要1个临时存储，arr2[]需要m个临时存储）

或

空格=（0）+1+1=O（1）

辅助空间=1+1=O（1）

（原因：1变量m需要临时存储，并且由于m是常数，因此arr2[]所需的空间将始终是常数c）

案例11：

algo(arr1[],n){
   int i;
   int m=10;
   int arr2[m];

   for(i=0;i<m;i++){
     arr2[i]= i;
   }   

}

空格=（0）+1=O（1）

辅助空间=1=O（1）

---

（原因：每当调用函数时，总是需要10个空格来声明arr2）

如果您使用的是已分配的数组（例如整数数组），那么它将具有相同的大小；sizeof（int）*n，这里n是所述数组的大小。如果您通过值传递它，您将拥有它的本地副本，如果您通过引用或使用指针传递它，您将不会复制它。将元素放入数组或修改其元素不会改变其已分配的大小，您将具有相同的空间复杂性

声明一个固定数量的变量也不会改变空间复杂度，请注意这里我说的空间复杂度不是实际的空间。所以，一次回答你所有的问题

• 如果修改已存在数组的元素，则不会更改空间复杂度（即使其为空，它也已分配了

  sizeof（elementtype）*element\u number

  空间）
• 如果之前有

  O（n）

  空间，然后使用

  m

  元素创建一个新数组，则需要额外的空间，空间复杂度将为

  O（m+n）

  （以较大者为准）
• 固定数量的变量不会影响空间的复杂性，只会影响您使用的总空间

---

好的，我将尝试帮助您理解空间复杂性，这可能会回答您所有的疑问，而不是逐一解决每个案例

方法的空间复杂度定义为额外的 随着输入的增长，方法使用的空间用于运行算法 选择

在上述方法定义中-

• 如果我只对参数变量和一些额外变量进行操作，比如-
  INTA=1，b=10，c=99
  int[]新数组=新int[1000]
  int m=1；int[]arr=新的int[m]
  所有这些仍将被视为

  O（1）

  空间复杂性。正如你所看到的 无论我的输入有多大，变量的数量和大小都不会改变

• 如果我声明了其他变量，这些变量随着输入的增长而增长，比如-
  int[]和=新的int[n]
  int[][]和=新的int[n][n]
  整数[]和=新整数[n][m]
  正如您所注意到的，数组的大小取决于所使用的参数

  n

  传递给该方法。这里，如果我的输入数组大小恰好是

  100000000

  ，我的 方法还将消耗空间中的

  100000000

  使其

  O（n）

  int[]和=新的int[n]；占用

  O（n）

  空间，因为大小取决于

  n

  int[][]和=新的int[n][n]；占用O（n2）空间，因为它有

  n

  行和

  n

  列
  整数[]和=新整数[n][m]；占用

  O（n*m）

  空间，因为它有

  n

  行和

  m

  列

int[]arr=newint[n][]；
对于（int i=0；在案例4中，您已经声明了数组，所以它是O（L），并且将新变量分配到它的位置不会进一步改变它的大小。因此辅助空间是O（1）我投票结束这个问题，因为它太宽泛了，因为它本质上是14个不同的问题，我们在这里提供答案，而不是验证它们。我们没有一个很好的关于空间复杂性的规范性问题（我已经看到），所以这可能是有用的，但这需要相当多的编辑才能达到目的（但不，我真的不知道编辑应该是什么样子）。谢谢你的解释，真的帮助我完成了算法课程