数据结构和算法--时间复杂度学习总结

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_31881469/article/details/61419220

一、时间复杂度:是指一个算法执行所耗费的时间。

时间频度 :一个算法中的语句执行次数。哪个算法中语句执行次数多,它花费时间就多

n称为问题的规模:一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数

        在时间频度不相同时,时间复杂度有可能相同,如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同,但时间复杂度相同,都为O(n2)。

按数量级递增排列,常见的时间复杂度有: 常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2),立方阶O(n3),..., k次方阶O(nk),指数阶O(2n)

空间复杂度 :与时间复杂度类似,空间复杂度是指算法在计算机内执行时所需存储空间的度量。

以下六种计算算法时间的多项式是最常用的。其关系为:

     O(1) < O(n) < O(n) < O(nn) < O(n2) < O(n3)

  指数时间的关系为:

    O(2n) < O(n!) < O(nn)

 二、常见算法时间复杂度

O(1): 表示算法的运行时间为常量

O(n): 表示该算法是线性算法

O(㏒2n): 二分查找算法

O(n2): 对数组进行排序的各种简单算法,例如直接插入排序的算法。

O(n3): 做两个n阶矩阵的乘法运算

O(2n): 求具有n个元素集合的所有子集的算法

O(n!): 求具有N个元素的全排列的算法

优<---------------------------<劣

O(1)<O(㏒2n)<O(n)<O(n2)<O(2n)

时间复杂度按数量级递增排列依次为:常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n2)、立方阶O(n3)、……k次方阶O(nk)、指数阶O(2n)。

三、算法的时间复杂度(计算实例)

O(1)

Temp=i;i=j;j=temp;                    

以上三条单个语句的频度均为1,该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶,记作T(n)=O(1)。如果算法的执行时 间不随着问题规模n的增加而增长,即使算法中有上千条语句,其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。


O(n^2)

2.1. 交换i和j的内容

     sum=0;                 (一次)

     for(i=1;i<=n;i++)       (n次 )

        for(j=1;j<=n;j++) (n^2次 )

         sum++;       (n^2次 )

解:T(n)=2n^2+n+1 =O(n^2)

2.2.   

    for (i=1;i<n;i++)

    {

        y=y+1;         ①   

        for (j=0;j<=(2*n);j++)    

           x++;        ②      

    }         

解: 语句1的频度是n-1

          语句2的频度是(n-1)*(2n+1)=2n^2-n-1

          f(n)=2n^2-n-1+(n-1)=2n^2-2

          该程序的时间复杂度T(n)=O(n^2).         



O(n)     

                                                      

2.3.

    a=0;

    b=1;                      ①

    for (i=1;i<=n;i++) ②

    {  

       s=a+b;    ③

       b=a;     ④  

       a=s;     ⑤

    }

解: 语句1的频度:2,        

           语句2的频度: n,        

          语句3的频度: n-1,        

          语句4的频度:n-1,    

          语句5的频度:n-1,                                  

          T(n)=2+n+3(n-1)=4n-1=O(n).

                                                                                                 

O(log2n )

2.4.

     i=1;       ①

    while (i<=n)

       i=i*2; ②

解: 语句1的频度是1,  

          设语句2的频度是f(n),   则:2^f(n)<=n;f(n)<=log2n    

          取最大值f(n)= log2n,

          T(n)=O(log2n )


O(n^3)

2.5.

    for(i=0;i<n;i++)

    {  

       for(j=0;j<i;j++)  

       {

          for(k=0;k<j;k++)

             x=x+2;  

       }

    }

解:当i=m, j=k的时候,内层循环的次数为k当i=m时, j 可以取 0,1,...,m-1 , 所以这里最内循环共进行了0+1+...+m-1=(m-1)m/2次所以,i从0取到n, 则循环共进行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6所以时间复杂度为O(n^3).



我们还应该区分算法的最坏情况的行为和期望行为。如快速排序的最 坏情况运行时间是 O(n^2),但期望时间是 O(nlogn)。通过每次都仔细 地选择基准值,我们有可能把平方情况 (即O(n^2)情况)的概率减小到几乎等于 0。在实际中,精心实现的快速排序一般都能以 (O(nlogn)时间运行。

下面是一些常用的记法:

访问数组中的元素是常数时间操作,或说O(1)操作。一个算法如 果能在每个步骤去掉一半数据元素,如二分检索,通常它就取 O(logn)时间。用strcmp比较两个具有n个字符的串需要O(n)时间 。常规的矩阵乘算法是O(n^3),因为算出每个元素都需要将n对 元素相乘并加到一起,所有元素的个数是n^2。


参考文章:http://blog.csdn.net/qq_14961511/article/details/39804677

没有更多推荐了,返回首页