目录
1.算法的复杂度
2.时间复杂度
2.1 时间复杂度的概念
2.2 大O的渐进表示法
2.3 常见的时间复杂度计算举例
实例1
实例2
实例3
实例4
实例5
实例6
实例7
3. 面试题
题目1：消失的数字
题目2：轮转数组
1.算法的复杂度
算法在编写成可执行程序后，运行时需要耗费时间资源和空间(内存)资源 。因此衡量一个算法的好坏，一般是从时间和空间两个维度来衡量的，即时间复杂度和空间复杂度。 时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计 算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。
2.时间复杂度
2.1 时间复杂度的概念
时间复杂度的定义：在计算机科学中，算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法的时间复杂度。
即：找到某条基本语句与问题规模N之间的数学表达式，就是算出了该算法的时间复杂度。
请计算一下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); }
Func1 执行的基本操作次数 ：T(N)=N^2+2*N+10
- N = 10 T(N) = 130
- N = 100 T(N) = 10210
- N = 1000 T(N) = 1002010
实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。
2.2 大O的渐进表示法
大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
使用大O的渐进表示法以后，Func1的时间复杂度为：O(N^2)
- N = 10 T(N) = 100
- N = 100 T(N) = 10000
- N = 1000 T(N) = 1000000
通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。
另外有些算法的时间复杂度存在最好、平均和最坏情况：
- 最坏情况：任意输入规模的最大运行次数(上界)
- 平均情况：任意输入规模的期望运行次数
- 最好情况：任意输入规模的最小运行次数(下界)
例如：在一个长度为N数组中搜索一个数据x
- 最好情况：1次找到
- 最坏情况：N次找到
- 平均情况：N/2次找到
在实际中一般关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)
如果我们想求某一个函数或者代码段运行的时间，我们可以借助clock函数
#include <stdio.h> #include<time.h> int main() {long begin = clock();int n = 10000000;int x = 10;for (int i = 0; i < n; i++){++x;}long end = clock();printf("%d\n", x);printf("%ld毫秒\n", end - begin);return 0; }运行结果：
clock函数
函数返回从程序开始运行到clock()被调用所耗费的时间，创建两个变量分别在代码段的前面和代码段的后面(这两个变量可以用 clock_t类型来创建，但本质上clock_t就是一个typedef长整型)，然后利用差值来求出这段代码运行的时间。需要包含头文件<time.h>，单位是毫秒。
2.3 常见的时间复杂度计算举例
实例1
计算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); }Func2执行的基本操作次数：T(N）=2*N+10
Func2的时间复杂度为：O(N)
实例2
计算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); }Func3执行的基本操作次数：T(N）= M+N
Func3的时间复杂度为：O(M+N) 或者 O(max(M,N)）
如果M远大于N，O(M)
如果N远大于M，O(N)
实例3
计算Func4的时间复杂度
void Func4(int N) {int count = 0;for (int k = 0; k < 100; ++ k){++count;}printf("%d\n", count); }Func2执行的基本操作次数：T(N）=100
Func2的时间复杂度为：O(1) 用常数1取代运行时间中的所有加法常数
实例4
计算strchr的时间复杂度
char *strchr(char *src, char c) { while( *src != '\0'){if( *src == c){return src;}src++;}return NULL; }最好：1次找到
最坏：N次找到
时间复杂度为：O(N)
实例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;} }执行的基本操作次数：T(N）=(N-1)*(1+N-1)/2=(N^2-N)/2
时间复杂度为：O(N^2)
实例6
计算func的时间复杂度
void func(int n) {int x = 0;for (int i = 1; i < n; i *= 2){++x;}printf("%d\n", x); } int main() {func(8);func(1024);func(1024 * 1024); }1*2*2*2*2*2……*2=N
设循环走x次，x个2相乘,2^x=N---->x=log₂N
时间复杂度：O(log₂N),为了方便，可以省略底数2（其它底数不能省略），写作O(logN)。
实例7
计算Binary Search（二分查找）的时间复杂度
int BinarySearch(int* a, int n, int x) {assert(a);int begin = 0;int end = n-1;// [begin, end]：begin和end是左闭右闭区间，因此有=号while (begin <= end){int mid = begin + ((end-begin)>>1);if (a[mid] < x)begin = mid+1;else if (a[mid] > x)end = mid-1;elsereturn mid;}return -1; }查找区间的变化：N-->N/2-->N/4-->N/8-->N/16-->……-->1（最坏情况）
N/2/2/2……/2=1,查找了多少次，就是除了多少次2
设查找了x次 N=2^x--->x=log₂N
时间复杂度：写作O(logN)
3. 面试题
题目1：消失的数字
思路1：利用等差数列求0到N的和，再依次减去数组中的值，剩下的那个值就是消失的数字。
int missingNumber(int* nums, int numsSize) {int N=numsSize;//共有N+1项int ret=(0+N)*(N+1)/2;for(int i=0;i<numsSize;i++){ret-=nums[i];}return ret; }
思路2：累积按位异或数组中所有的数字和 0~n 的数字，得到的结果就是那个消失的数字，用两个for循环来累积按位异或。
int missingNumber(int* nums, int numsSize) {int N = numsSize; int x=0;for(int i=0;i<N;i++){x^=nums[i];}for(int j=0;j<=N;j++){x^=j;}return x; }
题目2：轮转数组
每个元素真实的旋转次数：K%=N;
每个元素旋转次数最坏情况：K%N=N-1;
最好情况：K%N=0;
旋转次数：N*(N-1);
时间复杂度：O(N^2);
思路1：利用循环每次移动一位
void rotate(int* nums, int numsSize, int k) {int N=numsSize;k%=N;while(k--){//旋转1次int tmp=nums[N-1];for(int i=N-2;i>=0;i--){nums[i+1]=nums[i];}nums[0]=tmp; //不算赋值语句，准确来说旋转次数T(N)=(N-1)*(N-1) 代码时间复杂度为O(N^2)} }运行结果：
时间复杂度为O(N^2)，代码不通过，那我们怎么解决这个问题呢？
思路2：我们采用三段逆置的方法，算法优化让程序的时间复杂度为O(N)【每个元素被翻转两次，共N个元素】。
代码实现：
void reverse(int* p,int left,int right)
{while(left<right){int tmp=p[left];p[left]=p[right];p[right]=tmp;left++;right--;}
}
void rotate(int* nums, int numsSize, int k) {int len=numsSize;k%=len;//3段逆置reverse(nums,0,len-k-1);reverse(nums,len-k,len-1);reverse(nums,0,len-1);
}
思路3：额外创建一个新数组，先将数组后k个元素拷贝到新数组的正确位置，再将数组剩下的元素拷贝到新数组的正确位置，最后将新数组的内容拷贝到原数组，可以使用memcpy函数，也可以使用for循环。
代码实现：
void rotate(int* nums, int numsSize, int k) {int len=numsSize;k%=len;int arr[len]; int i,j;//先把后半部分数组保存到新数组for(j=len-k,i=0;j<len;j++,i++){arr[i]=nums[j];}//再保存前半部分数组到新数组for(i=0;i<=len-k-1;i++){arr[k+i]=nums[i];} //最后把新数组赋值给原数组for(i=0;i<len;i++){nums[i]=arr[i];}
}
总结：
常见的时间复杂度