【数据结构】算法的时间复杂度

目录

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];
    }
}

---

总结：

常见的时间复杂度