时间复杂度和空间复杂度

在计算执行程序的过程中，有两个衡量一个程序的所要消耗的空间和时间，这两个单位就是空间和时间复杂度。

因为如果只是单纯的对计算机的执行时间进行一个时间复杂度的定义，因为每台计算机的执行速度因配置而定，很难完全相同，所以这样定义的时间复杂度是有问题的，但是如果将时间复杂度定义为一个程序最大执行的次数，就可以避开这个问题，因为无论是配置怎样高的计算机，他对一个程序的执行次数是肯定的，所以时间复杂度就是一个程序执行的次数。我么这里说的执行次数都是最大执行次数，因为一个程序的最差的情况往往是越容易发生的，所以我们选取最大的运行次数来计算时间复杂度。

而空间复杂度的含义就和他的字面意思一样，就是程序在运行过程中所需要消耗的内存空间的大小。

 

上面的是基本的定义，我们这里进行一个时间复杂度的具体讨论，空间复杂的具体讨论参照时间复杂度，就不一 一列举了。

1.当计算机的执行次数为有限次的时候，时间复杂度是 O(1)。

        如果一个程序中有一个循环，循环进行的次数是确定的，那么这个循环的时间复杂度就是 O(1)。所以当我们看到一个时间复杂度为O(1)的程序的时候，并不是说这个程序仅仅执行了一个，而是这个程序执行了有限次，你可以知道的有限次，哪怕执行了一万次，一千万次，只要他的执行次数是已知的，时间复杂度都是O(1)。

for(int i = 0;i < 10;i++)//这样的循环有10次，时间复杂度是O(1)
{
    printf("%d\n",i);
}

for(int i = 0;i < 100000000;i++)//这样的循环有100000000次，时间复杂度是O(1)
{
    printf("%d\n",i);
}

2.当计算机的执行次数并不能之直接指导具体的执行次数的时候，根据情况，进行时间复杂度的分析

        看一下例子，如果一个循环的循环次数并不已知，而是根据传入的参数进行变化，那就把这个次数定位n，当出现执行次数为N*N的时候，时间复杂度就是 N^2，不能进行简化，但是如果执行次数为2N的时候，时间复杂度就是N，因为在计算机的运行过程中，这样有限的已知的倍数可以化简为1，所以不进行计算。并且如果一个 N+20的运行次数，也应该简化为N，因为有限的运行次数都是需要进行简化的。

        这里的简化标准仅仅只是一个开始，我准备了一些例子，通过例子，来看具体的简化操作。答案我会附在后面，可以自己作对比。

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

void Func2(int N)// 计算Func2的时间复杂度？
{ 
	int count = 0;
	for (int k = 0; k < 2 * N; ++k) 
	{ 
		++count;
	}


	int M = 10; 
	while (M--) 
	{ 
		++count; 
	}
	printf("%d\n", count);
}
 
void Func3(int N, int M)// 计算Func3的时间复杂度？
{ 
	int count = 0;
	for (int k = 0; k < M; ++k)
	{
		++count; 
	}
	for (int k = 0; k < N; ++k)
	{ 
		++count; 
	}
	printf("%d\n", count); 
}



void Func4(int N)// 计算Func4的时间复杂度？ 
{
	int count = 0;
	for (int k = 0; k < 100; ++k) 
	{ 
		++count;
	}
	printf("%d\n", count); 
}


void BubbleSort(int* a, int n) // 计算BubbleSort的时间复杂度？ 
{ 
	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;
	}
}

int BinarySearch(int* a, int n, int x)// 计算BinarySearch的时间复杂度？
{ 
	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;
}

这里是答案：

2. 实例2基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M) 
3. 实例3基本操作执行了10次，通过推导大O阶方法，时间复杂度为 O(1)
4. 实例4基本操作执行最好1次，最坏N次，时间复杂度一般看最坏，时间复杂度为 O(N)
5. 实例5基本操作执行最好N次，最坏执行了(N*(N+1)/2次，通过推导大O阶方法+时间复杂度一般看最 坏，时间复杂度为 O(N^2) 
6. 实例6基本操作执行最好1次，最坏O(logN)次，时间复杂度为 O(logN)  ps：logN在算法分析中表示是底 数为2，对数为N。有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的