【数据结构】算法的时间复杂度
目录
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; else return 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];
}
}
总结：
常见的时间复杂度