在这里我写了一些不同的函数实例，这些函数具有数组作为输入，我需要帮助来确定答案背后的推理是否正确（我在遇到困难的案例上加了问号）
情况1：
algo(arr[],n){
//does nothing
}
空格=（0）+ 0 = O（1）
辅助空间= 0 = O（1）
（原因：尚未处理分配给输入的存储，并且未在函数内部声明临时存储）
情况2：
algo(arr[],n){
int i;
}
空格=（0）+1 = O（1）
辅助空间= 1 = O（1）
（原因：尚未处理分配给输入的存储，并且需要为变量i临时存储1个）
情况3：
algo(arr[],n){
int i;
for(i=0; i<n ; i++){
//does nothing
}
}
空格=（1）+1 = O（1）
辅助空间= 1 = O（1）
（原因：正在处理变量n的存储，并且需要1个临时存储给变量i）
情况4：
其中arr []是大小为L的数组，其中L> n
algo(arr[],n){
int i;
for(i=0;i<n;i++){
arr[i] = i;
}
}
空格=（1 + n）+1 = O（n）
辅助空间= 1 = O（1）
（原因：正在为变量n提供1个存储，为arr [0] .... arr [n-1]提供n个存储，并且需要为变量i提供1个临时存储）
案例5 ：??
其中arr []是大小为L的数组，其中L> n
algo(arr[],n){
arr[n]=n;
}
空格=（1 +1）+ 0 = O（1）
辅助空间= 0 = O（1）
（原因：正在处理变量n的1个存储，并且无论n的值如何，arr []中始终只能处理1个存储，没有声明临时存储）
案例6 ：??
其中arr []是大小为L的数组，其中L> i
algo(arr[],n){
int i = 1;
arr[i]=i;
}
空格=（1）+1 = O（1）
辅助空间= 1 = O（1）
（原因：在arr []中始终只能处理1个存储，而在arr [i]中始终可以处理，而i则需要1个临时存储）
案例7 ：??
其中arr []是大小为L的数组，其中L> n
algo(arr[],n){
int i;
for(i=0;i<n;i++){
// does nothing
}
arr[n] = n;
}
空格=（1 +1）+1 = O（1）
辅助空间= 1 = O（1）
（原因：变量n的1个存储正在被处理，而无论n的值如何，arr []中将始终仅处理1个存储，为变量i声明了1个临时存储）
案例8 ：??
其中arr []是大小为L的数组，其中L> i
algo(arr[],n){
int i;
for(i=0;i<n;i++){
// does nothing
}
i = 1;
arr[i] = i;
}
空格=（1 +1）+1 = O（1）
辅助空间= 1 = O（1）
（原因：始终在arr [i]中始终在arr []中处理1个存储，对于变量n正在处理1个存储，对于变量i需要1个临时存储）
案例9 ：
其中arr1 []是大小为m的数组
algo(arr1[],n){
int arr2[n];
}
空格=（1）+ n = O（n）
辅助空间= n = O（n）
（原因：正在处理变量n的1个存储，arr2 []需要n个临时存储）
案例10 ：??
其中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）
（原因：变量m需要1个临时存储空间，并且由于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 + 1 +1 = O（1）
辅助空间= 1 +1 + 1 = O（1）
（原因：变量m需要1个临时存储空间，变量i需要1个临时存储空间，并且由于m为常数，所以arr2 []所需的空间始终为常数c）
案例12 ：
其中arr1 []是大小为L的数组，其中L> n，然后arr2 []是大小为K的数组，其中K> m
algo(arr1[],n, arr2[], m){
int i;
for(i=0;i<n;i++){
arr1[i]= i;
}
for(i=0;i<m;i++){
arr2[i]= i;
}
}
空间=（1 + n + 1 + m）+1 = O（n + m）
辅助空间= 1 = O（1）
（原因：正在处理var n和m的2个存储，正在处理arr1的n个存储，用于arr2的m个存储，并且var i需要1个存储）
案例13 ：??
其中arr1 []是大小为L且L> n的数组
algo(arr1[],n){
int i;
int m=10;
int arr2[m];
for(i=0;i<n;i++){
arr1[i]= i;
}
for(i=0;i<m;i++){
arr2[i]= i;
}
}
空间=（1 + n）+1 + 1 +1 = O（n）
辅助空间= 1 +1 + 1 = O（1）
（原因：变量i和m需要2个空间，arr2需要常数m的空间，var n需要1个空间，arr1需要n个空间）
案例14 ：
algo(arr1[],n){
int arr2[10];
}
空格=（0）+1 = O（1）
辅助空间= 1 = O（1）
（原因：每次调用函数时，声明arr2总是需要10个空格）
答案 0 :(得分：0)
如果您使用一个已经分配的数组，例如INTEGERS，它将具有大小； sizeof（int）* n，n是所述数组的大小。如果按值传递它，则将具有它的本地副本；如果按引用传递它或使用指针传递，则不会复制它。将元素放入数组或修改其元素不会更改其已分配的大小，您将具有相同的空间复杂度。
声明固定数量的变量也不会改变空间复杂度，请注意，这里我说的是空间复杂度而不是实际空间。因此，一次全部回答您的问题；
sizeof(elementtype)* element_number个空间）。O(n)个空间，然后使用m个元素创建一个新数组，则将需要额外的空间，并且空间复杂度将为O(m+n)（以较大者为准）。 / li>
答案 1 :(得分：0)
好吧，我不会尝试一个接一个地解决每个问题，而是会帮助您了解空间复杂性，这可能会回答您的所有疑问。
方法的空间复杂度定义为多少额外的量 随着输入的增长，您的方法使用的空间来运行您的算法 选择。
algo(arr[],n){
}
algo(arr1[],n, arr2[], m){
}
在上述方法定义中-
如果我仅对参数变量以及一些额外的变量（如-
）进行运算int a = 1，b = 10，c = 99;
int [] new_array = new int [1000];
int m = 1; int [] arr =新的int [m];
所有这些仍将被视为O(1)空间复杂度。如您所见，
无论输入的内容多大，变量的数量和大小都不会改变。
如果我声明其他随输入而增长的变量，例如-
int [] sum = new int [n];
int [] [] sum = new int [n] [n];
int [] [] sum = new int [n] [m];
您会注意到，我数组的大小取决于n，它是
传递给方法。在这里，如果我的输入数组大小恰好是1000000000，
该方法还将消耗1000000000，使其在空间O(n)。
int [] sum = new int [n];由于大小取决于
，因此占用O(n)n空间int [] [] sum = new int [n] [n];占用O（n 2 ）空间，因为它有
n行，并且n列。int [] [] sum = new int [n] [m];占用
O(n*m)空间，因为它有n行和m列。
int[][] arr = new int[n][]; for(int i=0;i<n;++i){ arr[i] = new int[i+1]; }
上面的代码段执行以下操作-
n行的数组。示例-
1 st 行-1列。
2 nd 行-2列。
3 rd 行-3列。
第4 行-4列。
依此类推，直到
n th 行-n列。
以上代码的空间复杂度为O（n 2 ）。原因是因为，以渐近符号表示，我们更关心worst case场景。在这里，不管其他行如何，对于第n 行，我们都有n列，并且随着输入的增加而增加。
我希望这可以使您了解空间的复杂性。