24.时间复杂度和空间复杂度

算法

        算法是可执行程序运行所需的时间和空间资源，一个算法的好坏，看时间复杂度和空间复杂度。时间复杂度是算法的运算速度，空间复杂读是算法所需的额外空间。

        早期的时候，计算机的存储容量很小，时间复杂度和空间复杂度都很重要。现在计算机的存储容量很大，提升的也很快（摩尔定律——价格不变时，集成电路上可容纳的晶体管数目，约每隔18个月便会增加一倍，性能也将提升一倍。），现在主要关注时间复杂度。

时间复杂度

        在计算机科学中，时间复杂性，又称时间复杂度，算法的时间复杂度是一个函数，它定性描述该算法的运行时间。这是一个代表算法输入值的字符串的长度的函数。时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数，一般使用变量N表示未知数。时间复杂度可被称为是渐进的，为什么使用O这种方法？因为设备不一样，程序运行的速度也不一样，只需要估算大概程序的运行次数，方便比较。时间复杂度有三种情况：最好情况、平均情况、最坏情况。一般问时间复杂度都是最坏情况。

大O的渐进表示法

        大O符号：是用于描述函数渐进行为的数学符号。

        常数项用1表示。

        在修改后的运行次数函数中，只保留最高阶项。

        如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。

计算时间复杂度

10的阶乘

int test()
{
	int sum = 0;
	for (int i = 1; i <= 10; ++i)
	{
		sum += i;
	}
	return sum;
}

        函数F = 10，使用大O表示，只有常数，时间复杂度是O(1)。

N的阶乘 

int test(int n)
{
	int sum = 0;
	for (int i = 1; i <= n; ++i)
	{
		sum += i;
	}
	return sum;
}

        函数F = N，使用大O表示，最高阶N系数为1，时间复杂度是O(N)。

N个N的阶乘 

int test(int n)
{
	int sum = 0;
	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= n; ++i)
		{
			sum += j;
		}
	}
	return sum;
}

        函数F = N^2，使用大O表示，最高阶N^2系数为1，时间复杂度是O(N^2)。

多个阶乘

int test(int n)
{
	int sum = 0;
	for (int i = 1; i <= 2 * n; ++i)
	{
		for (int j = 1; j <= 2 * n; ++i)
		{
			sum += j;
		}
	}

	for (int i = 1; i <= n; ++i)
	{
		sum += i;
	}

	for (int i = 1; i <= 10; ++i)
	{
		sum += i;
	}
	return sum;
}

        函数F = 4N^2 + N + 10，使用大O表示，最高项N^2的系数是4，将系数变为1，时间复杂度是O(N^2)。

冒泡排序

void bubble_sort(int arr[], int sz)
{
    // sz个元素需要排序sz-1趟
	for (int i = 0; i < sz - 1; ++i)
	{
        bool flag = true;
        // sz个数，排序sz-1次，每次排序一个数，下一趟少排一个数
		for (int j = 0; j < sz - 1 - i; ++j)
		{
            // 依次比较
			if (arr[j] > arr[j + 1])
			{
                flag = false;
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
        
        if (flag)
            break;
	}
}

        函数F = N-1 + N-2 + N-3 + ... + 3 + 2 + 1。等差序列求和，首项加尾项的和乘以项数再除2，，使用大O表示，最高项N^2的系数是1/2，将系数变为1，时间复杂度是O(N^2)。最好情况：O(N)，平均情况：O(N^2)，最坏情况：O(N^2)。

斐波那契数列

int fibonacci(int n)
{
    // 如果n等于1或者0返回 1 
	if (n == 1 || n == 2)
		return 1;
	
	return fibonacci(n - 1) + fibonacci(n - 2);
}

        有一些是没有的，但是算的是大概的，不影响。等比数列求和公式。

        尾项乘以公比减首项再除以公比减1的差。

        (2^(N-2)*2 - 1)/(2-1) = 2^(N-1)-1，使用大O表示，最高项2^(N-1)的系数是1，时间复杂度是O(2^N)。

        二分算法的时间复杂度一般写为O(logN)，省略底数2。 

        时间复杂度的计算，不能数嵌套了多少个循环，不一定准确，要看思想。

时间复杂度量级

        O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)

空间复杂度

        空间复杂度是一个数学表达式，是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度并不是计算整个算法开辟了多少字节的空间，而是为算法额外开辟的空间。

        上面的阶乘的空间复杂度都是O(1)。

        冒泡排序的空间复杂度是O(1)。

        斐波那契数列的空间复杂度是O(N)。时间是累积的，而空间是可以重复利用，函数调用完，会销毁栈帧，将这一块空间返还给操作系统。