算法在编写成可执行程序后，运行时需要消耗时间资源和空间（内存）资源，因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的。

        时间复杂度主要衡量一个算法运行的快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间，今天我们主要来讲讲时间复杂度。

目录

一、时间复杂度的概念

二、大O的渐进表示法

三、常见的时间复杂度计算

---

一、时间复杂度的概念

一个算法所花的时间与其中语句的执行次数成正比，算法中的基本操作的执行次数，为算法的时间复杂度。

二、大O的渐进表示法

实际计算时间复杂度时，我们并不需要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

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

推导大O阶的方法：

1、用常数1取代运行时间中所有的加法常数。

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

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

另外，有些算法的时间复杂度存在最好、平均、最坏的情况。

最坏情况：

任意输入规模的最大运行次数（上线）

平均情况：

任意输入规模的期望运行次数

最好情况：

任意输入规模的最小运行次数

例如，在一个长度为N的数组中搜索一个数据x

最好情况：一次找到

平均情况：N/2次找到

最坏情况：N次找到

在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O（N）

三、常见的时间复杂度计算

实例1：

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-1次）后，发现就顺序的，所以最好是N次。

最坏是（N*(N+1)）/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为O（N^2）.

实例2：

//二分查找
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 - 1;
		}
		else
		{
			return mid;
		}

	}
	return -1;
}

二分查找：

最好情况：中间那个数就是要找的O（1）

最坏情况：一直除2,，到只剩一个值时，要么找到了，要么找不到。

假设N是数组个数，x是最坏查找次数，N/2/2/2……/2=1

2^x=N,x=logN(logN在算法分析中表示以2为底数，N为对数，有些地方也写成lg N）

实例3：

//计算斐波那契数列的时间复杂度
long long Fib(size_t N)
{
	if (N < 3)
		return 1;
	return Fib(N - 1) + Fib(N - 2);
}

 运用等比数列求和公式可知，执行次数为2^N的数量级

所以时间复杂度应为O（2^N）

实例4：

//计算阶乘递归Fac的时间复杂度
long long Fac(size_t N)
{
	if (0 == N)
		return 1;
	return Fac(N - 1) * N;
}

时间复杂度为O（N）