时间-空间复杂度相关知识总结

//引入：
//int Fib(int N)
//{
//	if (N < 3)
//		return 0;
//	return Fib(N - 1) + Fib(N - 2);
//}
//递归类型的代码，用以 斐波那契数列

//如何衡量一个算法的好坏？(速度快，占用内存小)
//一个算法的复杂度进行衡量
//时间复杂度
//空间复杂度
//本质：都是求数学表达式–某条基本语句关于问题规模N的数学表达式

//1.算法效率
//算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

//2.时间复杂度
//2.1 时间复杂度的概念
// 时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
// 理解：是一个关于问题规模N的数学表达式，计算算法中某条基本语句总的执行次数
//2.2 大O的渐进表示法

//例题：
//请计算一下Func1基本操作执行了多少次？（++count这个执行了多少次）

//void Func1(int N)
//{
//	int count = 0;
//	for (int i = 0; i < N; ++i)
//	{
//		for (int j = 0; j < N; ++j)
//		{
//			++count;
//		}
//	}
//	for (int k = 0; k < 2 * N; ++k)
//	{
//		++count;
//	}
//	int M = 10;
//	while (M--)
//	{
//		++count;
//	}
//	printf("%d\n", count);
//}

//F(N) = N^2 + 2 * N +10
//N = 10 F(N) = 130
//N = 100 F(N) = 10210
//N = 1000 F(N) = 1002010
//实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。
//大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
//推导大O阶方法：
//先计算出数学表达式，按照以下规则来进行处理
//1、用常数1取代运行时间中的所有加法常数。
//例如：某个代码运行次数：F(N)=100
// O(F(N))=O(100)---->O(1)
//2、在修改后的运行次数函数中，只保留最高阶项。
// 对于Func1 我们知道：F(N) = N^2 + 2 * N +10
// O(F(N)) —> O(N^2 + 2 * N +10) —> O（N^2）
//3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
//使用大O的渐进表示法以后，Func1的时间复杂度为：
//O（N^2）
//N = 10 F(N) = 100
//N = 100 F(N) = 10000
//N = 1000 F(N) = 1000000
//通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。

//另外有些算法的时间复杂度存在最好、平均和最坏情况：
//最坏情况：任意输入规模的最大运行次数(上界)
//平均情况：任意输入规模的期望运行次数
//最好情况：任意输入规模的最小运行次数(下界)
//例如：在一个长度为N数组中搜索一个数据x
//最好情况：1次找到
//最坏情况：N次找到
//平均情况：N / 2次找到
//在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

//时间复杂度为什么要总次数作为参考，而不是以时间参考？
//应该将算法放在不同的机器中进行衡量：
//不同机器里面运行的时间不同，则没有实际价值（硬件环境不同，时间没有参考价值）
//在一台机器上运行代码，此时机器运行的不止你一个代码，还有别的程序
//在不同的机器运行我们的程序，我们的程序运行的次数是一定的

//常见举例：
// 计算Func2的时间复杂度？

//void Func2(int N)
//{
//	int count = 0;
//	for (int k = 0; k < 2 * N; ++k)
//	{
//		++count;
//	}
//	int M = 10;
//	while (M--)
//	{
//		++count;
//	}
//	printf("%d\n", count);
//}
//基本操作执行了2N + 10次，通过推导大O阶方法知道，时间复杂度为 O(N)

// 计算Func3的时间复杂度？
//void Func3(int N, int M)
//{
//	int count = 0;
//	for (int k = 0; k < M; ++k)
//	{
//		++count;
//	}
//	for (int k = 0; k < N; ++k)
//	{
//		++count;
//	}
//	printf("%d\n", count);
//}
//基本操作执行了M + N次，有两个未知数M和N，时间复杂度为 O(N + M)

// 计算Func4的时间复杂度？
//void Func4(int N)
//{
//	int count = 0;
//	for (int k = 0; k < 100; ++k)
//	{
//		++count;
//	}
//	printf("%d\n", count);
//}
//基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1)

//4.
// 计算strchr的时间复杂度？
//const char * strchr(const char * str, int character);
//基本操作执行最好1次，最坏N次，时间复杂度一般看最坏，时间复杂度为 O(N)
//strchr表示：给定一个字符character，然后在str（字符串）中查找是否含有这个字符

//5.冒泡排序 
// 计算BubbleSort的时间复杂度？
//void BubbleSort(int* a, int n)
//{
//	assert(a);
//	for (size_t end = n; end > 0; --end)
//	{
//		int exchange = 0;
//		for (size_t i = 1; i < end; ++i)
//		{
//			if (a[i - 1] > a[i])
//			{
//				Swap(&a[i - 1], &a[i]);
//				exchange = 1;
//			}
//		}
//		if (exchange == 0)
//			break;
//	}
//}
//基本操作执行最好N次，最坏执行了(N*(N + 1) / 2次，通过推导大O阶方法 + 时间复杂度一般看最坏，时间复杂度为 O(N ^ 2)
//6.
// 计算BinarySearch的时间复杂度？
//int BinarySearch(int* a, int n, int x)
//{
//	assert(a);
//	int begin = 0;
//	int end = n - 1;
//
//	while (begin < end)
//	{
//		int mid = begin + ((end - begin) >> 1);
//		if (a[mid] < x)
//			begin = mid + 1;
//		else if (a[mid] > x)
//			end = mid;
//		else
//			return mid;
//	}
//	return -1;
//}
//基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN) ps：logN在算法分析中表示是底数为2，对数为N。有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的）

//7.
// 计算阶乘递归Factorial的时间复杂度？
//long long Factorial(size_t N)
//{
//	return N < 2 ? N : Factorial(N - 1)*N;
//}
//通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。

//8.
// 计算斐波那契递归Fibonacci的时间复杂度？
//long long Fibonacci(size_t N)
//{
//	return N < 2 ? N : Fibonacci(N - 1) + Fibonacci(N - 2);
//}
//通过计算分析发现基本操作递归了2^N次，时间复杂度为O(2 ^ N)。（建议画图递归栈帧的二叉树讲解）
//优化至O（N）
//unsigned long long Fib(int N)
//{
//	unsigned long long first = 1;
//	unsigned long long second = 1;
//	unsigned long long ret = 1;//保存结果
//	for (int i = 2; i < N; ++i)
//	{
//		ret = first + second;
//		first = second;
//		second = ret;
//	}
//	return ret;
//}
//int main()
//{
//	printf("%d ", Fib(10));
//	return 0; 
//}

//3.空间复杂度
//理解：和时间复杂度求法一样，都是数学表达式，是函数中创建变量（对象）个数的函数

//例1：
//unsigned long long Fib(int N)
//{
//	unsigned long long first = 1;
//	unsigned long long second = 1;
//	unsigned long long ret = 1;//保存结果
//	for (int i = 2; i < N; ++i)
//	{
//		ret = first + second;
//		first = second;
//		second = ret;
//	}
//	return ret;
//}
//int main()
//{
//	printf("%d ", Fib(10));
//	return 0; 
//}
//int N,unsigned long long first,unsigned long long second,unsigned long long ret,int i一共创建五个变量
//创建的变量是固定的，因此：
//空间复杂度O(1)

//例2：
//有两个有序的序列，要求：两个序列合并成一个有序的序列：
//第一序列：2 5 6 8 
//第二序列：1 3 5 7 8 9 
//方法：创
//1.建第三序列，
//2.把一二序列里面的按顺序放到第三序列
// （1）创建两个变量index1，index2，index分别表示一二三序列的第一个数字
// （2）index1和index2进行比较，小的赋值index并且向后加一位，大的不变
// （3）重复比较
//#include<stdio.h>
//#include<malloc.h>
//int* MergeData(int array1[], int size1, int array2[], int size2)
//{
//	int index1 = 0, index2 = 0, index = 0;
//	int* array = (int*)malloc((size1 + size2)*sizeof(array1[0]));
//	if (NULL == array )
//		return NULL;
//	while (index1 < size1 && index2 < size2)
//	{
//		if (array1[index1] <= array2[index2])
//			array[index++] = array1[index1++];
//		else
//			array[index++] = array2[index2++];
//	}
//	while (index1 < size1);
//        array[index++] = array1[index1++];
//	while (index2 < size2);
//		array[index++] = array2[index2++];
//	return array;
//}
//int main()
//{
//	int array1[] = { 2, 5, 6, 8 }; 
//	int array2[] = { 1, 3, 5, 7, 8, 9 };
//	int* array = MergeData(array1, sizeof(array1) / sizeof(array1[0]), array2, sizeof(array2) / sizeof(array2[0]));
//	for (int i = 0; i < 10; ++i)
//		printf("%d ", array[i]);
//	printf("\n");
//	free(array);
//	array = NULL;
//	return 0;
//}
//时间复杂度:O(M+N)
//空间复杂度:O(M+N)  数组中的个数在变化（malloc）  

//递归算法：
//例1：
//int Fac(int N)
//{
//	if (0 == N)
//	    return 1;
//	return Fac(N - 1)*N;
//} 
//每一个函数在运行时，系统必须要在栈上给该函数划分一段栈空间
//栈空间保存：存储,局部变量,寄存器信息。。。
//只要函数确定，编译器给该函数每次调用时划分的栈空间大小都是相同的--常量
//N+1*单词空间--》常量--》O()
//空间复杂度：O(N)
//时间复杂度：O(1)
//注意：递归程度不能太深 
//      原因：每次递归都是一次函数调用，每次函数调用都需要在栈上划分一个栈帧，二栈的大小是有限制的，如果栈过深，可能无法分配战阵而导致程序崩溃
//例2：斐波那契数列
//long long Fib(int N)
//{
//	if (N < 3) return 1;
//	return Fib(N - 1) + Fib(N - 2);
//}
//时间复杂度：O(2^N)
//举例：
//        f5
//        /\
//     f4    f3
//     /\      /\
//   f3  f2  f2  f1
//   /\      1    1     
//  f2 f1 
//  1   1
//先调用左边的，然后右边的。
//先用左边，当左边用完后，会把空间还给系统，此时右边才占用左边的刚用完空间
//（好处：节约空间）
//空间复杂度O(N)

对于时间-空间复杂度相关知识，我用了许多例题进行总结，深入了解后，其算法也就是学数学问题，还有要注意，有时候会忘记一些点，这对于求结果是有很大的缺陷的。
本文仅供参考，其中代码我都自己运行过，均无问题，如果有什么问题，请留言，互相学习学习，让我们一起共同进步。