【Day01数据结构 & 时间复杂度1】

鲜衣怒码少年郎。

已于 2023-02-15 00:52:37 修改

阅读量361

点赞数 32

分类专栏：数据结构文章标签：数据结构算法

于 2023-02-15 00:17:15 首次发布

本文链接：https://blog.csdn.net/2201_75533641/article/details/129016867

版权

数据结构专栏收录该内容

2 篇文章 1 订阅

订阅专栏

前言

一、什么是时间复杂度？

二、时间复杂度的分析与计算.

1.计算时间复杂度(代码的执行次数)

2.分析时间复杂度

三、1. 时间复杂度的表示编辑

四、常见的时间复杂度对比

总结

前言

我们知道递归代码需要重复计算大量的数据,所以并不是说代码越简洁,效率就越高,那么我们如何去判断一个算法的优劣呢,因此我们就引出了时间复杂度这一概念.

一、什么是时间复杂度？

是不是很疑惑,别急,我们慢慢来.

老规矩,我们先上概念:

复杂度：又称渐进复杂度。

它又可以分为时间复杂度和空间复杂度;

时间复杂度通常是用来衡量算法的优劣的，衡量算法的时间严格来讲是很难衡量的，由于不同的机器性能不用环境都会造成不同的执行时间。算法的执行时间和语句的执行次数成正比，因此通过机器执行测试来推断执行时间。其实就是算法（代码）的执行效率，算法(代码)的执行时间。

二、时间复杂度的分析与计算.

首先我们要知道的是时间复杂度的计算并不是去计算这段代码它真正意义上到底跑了多少秒,例如两台不同的机器,我们需要它们去计算10000个数,A机器配置效率很高,可能很快就跑完了,但是如果用配置很低的B机器去计算,效率就会很慢(ps:就好比某些学校的机房). 所以我们算的并不是代码的运行时间,而是计算代码的执行次数.

1.计算时间复杂度(代码的执行次数)

我们先来看一个简单的代码

void Func1(int N)
{
     int count = 0;
     //这是第一个部分,有两层for循环,N*N次
     for (int i = 0; i < N ; ++ i)
 {
         for (int j = 0; j < N ; ++ j)
         {
             ++count;
         }
 }
//这是第二个部分,2*N次
 for (int k = 0; k < 2 * N ; ++ k)
 {
    ++count;
 }
//这是第三个循环,10次--
 int M = 10;
 while (M--)
 {
     ++count;
 }
 printf("%d\n", count);
}

2.分析时间复杂度

我们先来计算Func1函数执行了多少次代码,可以看到第一个部分里有两层循环,外层循环执行一次,内存循环就要执行N次,所以我们可以得到执行次数是 N*N 次;再看第二部分, 因为 for 循环里判断条件是<2*N ,所以循环执行 2*N 次;其次第三部分 M-- 要进行 10 次.所以准确的次数就是 N^2+2*N+10 次,那我们这段代码的时间复杂度是这个吗,其实并不是.

假设 N 分别是 10 , 100, 1000,我们得到以下算式:

我们仔细观察,不难发现,随着 N 的增大,表达式 N*N+2*N+10 表达式中 N^2 这一项的结果对整个表达式的影响是最大,从这一角度去看,我们要知道时间复杂度本质上其实是一个估算,是去看表达式中影响最大的那一项,其他项对结果的影响是微乎其微的. 当N变得越来越大时，公式中的低阶，常量，系数三部分影响不了其增长趋势，所以可以直接忽略他们，只记录一个最大的量级就可以了.(也就是说用的并不是准确值（事实上也无法得出），而是根据合理方法得到的预估值).

三、1. 时间复杂度的表示

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要 大概执行次

数，那么这里我们使用 大O的渐进表示法 。

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

大O时间复杂度也叫作渐进时间复杂度，简称时间复杂度.(其实就是一个估算,记住O(频度)就可以了).通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数. 所以上述代码的时间复杂度就可以表示为:O(N^2).

O(频度):这里的频度为最简之后所得的频度。或许各位对最简化频度并不是很清楚。这里给大家总结一下，在数据结构中，频度表达式可以这样简化：

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

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

如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O(频度).

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

算法执行了 2N+10 次，通过推导大 O阶方法知道，常数化为1保留最高阶项,所以时间复杂度为 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的时间复杂度是O(M+N),因为我们并不知道M要执行多少次,也不知道N要执行多少次,他们俩都是一个未知数,也就是说,算法的时间复杂度有可能是一个未知数也有可能是多个未知数.

但是如果我们给这一题加上条件: 1.M远大于N,这里的时间复杂度就是O(M),又或者给出的条件是2.M和N差不多大,则时间复杂度就是O(M)或者O(N).所以我们要根据实际情况得出算法的时间复杂度.(并不是说一层循环就是O(N),两层循环就是O(N^2),我们要根据算法的实际情况判断)

3.OK,再来:

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

这里给了一个N,但是程序中并没有使用到N;又因为上述文中,大O简化频度规定过用常数1取代运行时间中的所有加法常数。只要我们这里是确定的常数次,不管他是多少都用 1 替代 , 所以这里的时间复杂度是O(1).同理,假设题目说一个算法的时间复杂度是O(1),我们就能知道算法的执行次数是它的常数次, 这一题的常数无论怎么变,对N的影响很小,算法的时间复杂度取决于 N .

4.代码演示:

//计算strchr的时间复杂度？
const char * strchr ( const char * str, char character )
{
  while(*str != '\0')
 {
      if(*str == character)
          return str;
      
      ++str;
 }
  
  return NULL;
}

这段代码的意思是在一个字符串中找到一个指定的字符,如果找到返回,没有找到,str继续++,如果走到最后都没有找到,那就返回NULL.这题我们要分情况讨论:

举个例子,假设有字符串"dhfgsfsdsds".

1.假设找字符's':我们在字符的二分之一处找到了.(平均,O(N/2))

2.假设找字符'd',开头就找到了(最好的情况,O(1))

3.假设找字符'x',找不到(最坏的情况,O(N))

所以,一个算法的时间复杂度存在最好,平均和最坏的情况,由上可知,虽坏的情况我们的时间复杂度就是O(N),平均的情况要找O(N/2),最好的情况要找O(1).

数据结构中规定:当算法存在这三种情况的时候,看最坏的情况,也就是说时间复杂度取最坏的情况.

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

假设我们冒泡排序 4 个数，第一趟比较次数 4 次，第二趟 3 次，第三趟 2 次....(第一趟的数还要和数列末项的后面一块空间比较一次,这里是比较次数 4 次,如果是交换次数则为 3 次), 如果我们要冒泡排序 N 个数，第一趟比较 N 次,第二趟 N-1 次,第三趟 N-2 次...第N趟则为 1 次(最后一趟只剩一个数了,不用比较所以是 1 ),将每一项相加后我们发现冒泡排序的算法其实就是一个 等差数列(N+1)*N/2) , 拆分后这个表达式的最大项是 N^2 ,所以它的时间复杂度是O(N^2).

6.代码演示

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

这是一二分查找的算法,在一个有序数组中查找指定元素,这里不细说它的算法思想,不了解得的可以参考一下我写的博客/C语言实现二分查找/.如果不用二分查找算法来找一个数组中的指定元素,它的时间复杂度显而易见就是O(N),但是二分查找算法是要分情况讨论的.

假设有一数组 :{ 0,1,2,3,4,5,6,7,8,9 }

1.最好的情况: 要找的元素是 4 数组下标的平均值mid就是 4 ,所以时间复杂度是O(1);

2.最坏的情况: 要找的元素是 10 ,找不到,时间复杂度是O(N);

我们重点要看的是第三种情况:假设要找的元素是 8 ,第一次折半查找到的元素是 4 ,小于我们的 8 ,那么 begin=mid+1,此时是找 5 和 9的中间值,得到 7 ,仍然小于 8 ,begin=mid+1,再找 8 和 9 的中间值得到指定元素 8 . 可能这里我们还是不能理解它的时间复杂度,现在我们可以将刚刚的过程反过来看,每次都是折一半得到一个值, 假设我们找了 X 次找到指定元素,如果再进行 X 次乘2后就会得到原来的所有元素.(可以想象一下纸张对折X次后又将它 X 次乘 2 的方式再展开.)

我们可以得到 1*2*2*2...*2 = N,可以转换为2^X=N, X=,因为算法的复杂度计算,可以省略简写成logN,因为很多地方不好写底数,所以折半查找算法的时间复杂度就是O(logN).

7.代码如下:

// 计算阶乘递归Factorial的时间复杂度？
long long Factorial(size_t N)
{
 return N < 2 ? N : Factorial(N-1)*N;
}

s这一题要了解递归,这里不详细介绍有需要的可以看看:zhttp://t.csdn.cn/OM6Pu

递归的表达式为 1*2*3*4*5*6*7...*n, 如果递归了 N 次,每次递归运算就是O(1),整体的复杂度就是O(N), 递归是函数调用多次,也就是调用了N次,每次都是O(1).

8.代码如下:

// 求递归斐波那契数复杂度
long Fibonacci(int n) {
 5     if (n == 0)
 6         return 0;
 7     else if (n == 1)
 8         return 1;
 9     else
10         return Fibonacci(n - 1) + Fibonacci(n-2);
11 }

斐波那契数指的是这样一个数列：0、1、1、2、3、5、8、13...前两项之和等于第三项,第一项是0,第二项和第三项都是1,所以递归就可以这样规定F（0）=0，F（1）=1，F（n=F(n-1)+F(n-2),所以求F(n)必须先计算F(n-1)和F(n-2),而要计算F(n-1)和F(n-2)，又必须先计算F(n-3)和F(n-4)...以此类推要进行重复大量的计算,算法的复杂度呈指数上升,所以它的时间复杂度是O(N^2).