时间复杂度和空间复杂度

时间复杂度

在进行算法分析时，通常要考虑该算法运行所用的时间跟空间。
算法的时间复杂度一般记作：O( f(n))，称为大O记法。
f(n) 为该算法解决的问题中规模n的某个函数，也可以看作函数运行的次数。

常见的时间复杂度

常见的时间复杂度：

执行次数	阶	非正式术语
8	O(1)	常数阶
n+1	O(n)	线性阶
log2^n + 2n + 1	O(log n)	对数阶
n2 + log2^n + 2n + 1	O(n2)	平方阶
n log2^n + 2n	O(n log n)	n log n阶
4n3 + 2n + 1	O(n3)	立方阶
2n	O(2n)	指数阶

时间复杂度排序

O(1)<O(log n)<O(n)< O(n log n) < O(n²) < O(n³)< O(2ⁿ)< O(n !)< O(nⁿ)

---

推导时间复杂度 O 的方法

推导大O的方法：

1.用常数1取代运行时间中的所有加法常数。
2.在修改后的运行次数函数中，只保留最高阶项。
3.如果最高阶不为1，除去最高阶项的常数。

此时得到的值就为最大O阶。

---

几种常见时间复杂度

1.常数阶

int main()
{
      int i=0,j=0; 
      i=i+1;
      j=J+1;
      i=i+j;
}

如上图代码，其中一共执行三条语句，运行次数函数是f(n)=3。根据推导时间复杂度 O 的方法进行计算，可得时间复杂度为O(1)。

int sum = 0,n = 10000;
sum = n/2;
sum = n/2;
sum = n/2;
sum = n/2;
sum = n/2;
sum = n/2;
sum = n/2;
sum = n/2;
printf("%d",sum);

上方代码中，无论n的大小为多少，sum = n/2 执行了8次，执行次数与n大小无关，为执行时间恒定的算法。
对于这类时间恒定的算法，我们称之为具有O(1)的时间复杂度，即常数阶。

2.线性阶

通常通过分析循环结构的运行情况，来求得时间复杂度。

int nums[]={1,2,3,4,5,6,7,8,9} , n=0;
n = sizeof(nums)/sizeof(nums[0]);//求nums数组的大小

for(int i = 0;i<n;i++)
{
  nums[i]+=1;
}

该函数中，语句nums[i]+=1为时间复杂度为O(1)，执行了n次，执行次数与n有关。
再结合推导时间复杂度 O 的方法可得，时间复杂度为O(n)。

3.对数阶

int count = 1；
while(count<n)
{
count = count *2;
}

若n=10，函数执行5次；
若n=100，函数执行10次；
若n=10000，函数执行100次；
执行次数随n的变化而变化。
时间复杂度为O(lon2^n)，经过推导大O的方法可得时间复杂度为O(log n)。

二分查找：

while (left < right) {	
        int mid = left + (right - left) / 2;
        if (nums[middle] > target) {
            right = middle - 1;
        } else if (nums[middle] < target) {
            left = middle + 1;
        } else {	
            return mid;
        }
    }

二分查找是常见的时间复杂度为O(log n)的算法。

4.平方阶

下方代码为循环嵌套，如果循环中语句时间复杂度为O(1),那整体函数执行次数为n,整体时间复杂度为O(n)。
如果循环中语句也为时间复杂度为O(n)的循环语句,那整体函数执行次数为n*n=n^2,那么整体时间复杂度为O(n ^ 2)。

int i,j;
for(i=0;i<n;i++)
{
   for(j=0;j<n;j++)
  {
     j+=1;
  }
}

常见的时间复杂度为O(n^2)的算法
冒泡排序（时间复杂度为O(n^2)）：

void bubbleSort(int* arr, int arrSize)//数组  数组长度
{
	int i, j;  
	for (i = 0; i < arrSize; i++)
	{   if (!b){ break; }
		for (j = 0;j<arrSize-i-1;j++) 
		{
			int temp;
			if (arr[j] > arr[j + 1])
			{
				temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

空间复杂度

算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作: S(n)= O(f(n)), 其中，n为问题的规模，f(n)为语句关于 n所占存储空间的函数。

一般情况下，一个程序在机器上执行时，除了需要存储程序本身的指令、常数、变量和输入数据外，还需要存储对数据操作的存储单元。若输入数据所占空间只取决于问题本身，和算法无关，这样只需要分析该算法在实现时所需的辅助单元即可。若算法执行时所需的辅助空间相对于输入数据量而言是个常数，则称此算法为原地工作，空间复杂度为O(1)。

通常，我们都使用“时间复杂度”来指运行时间的需求，使用“空间复杂度”指空间需求。当不用限定词地使用“复杂度”时，通常都是指时间复杂度。