程序博客网 > ubuntu java环境搭配

数据结构时间复杂度

来源：互联网 发布：ubuntu java环境搭配 编辑：程序博客网 时间：2024/05/21 07:07

时间复杂度用O（）来体现，我们称之为大O记法。记做：T(n)=O(f(n))

一般情况下随着n的增大，T（n）增长最慢的算法为最优算法。

O（1）叫常数阶 O（n）叫线性阶 O（n2）叫平方阶

 

推倒大O阶

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

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

3.       如果最高阶项存在且不是1，则去除与这个项相乘的常数。

得到的结果就是大O阶。

 

对于高斯算法而言，这个算法的运行次数函数是f(n)=3，根据我们推导大O阶的方法，第一步就是把常数项3改为1。在保留最高阶项时发现，它根本没有最高阶项，所以这个算法的时间复杂度为O(1)。

 

对于分支结构而言，无论是真，还是假，执行的次数都是恒定的，不会随着n的变大而发生变化，所以单纯的分支结构（不包含在循环结构中），其时间复杂度也是O（1）。

 

线性阶：

Int I;

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

{

 

}

因为循环体中的代码要执行N次，所以它的循环的时间复杂度为O(n)。

 

对数阶：

Int count=1;

While (count<n)

{

   Count=count*2;

}

由于每次count乘以2以后，就距离n更近了一分。也就是，有多少个2相乘以后大于n，则会退出循环。由 2x=n 得到x=log2n。所以这个循环的时间复杂度为O(logn)

 

 

最坏情况运行时间是一种保证，那就是运行时间将不会再坏了。在应用中，这是一种最重要的需求，通常，除非特别指定，我们提到的运行时间都是最坏情况的运行时间。

 

 

算法空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记做：S(n)=O(f(n))，其中n为问题的规模，f(n)为语句关于n所占存储空间的函数。

常见的时间复杂度所耗时间的大小排列

O(1)<O(logn)<O(n)<O(nlogn)<O(n2)

 

http://blog.csdn.net/hitwhylz/article/details/12374407

算法的时间复杂度定义为：

在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T(n}=0(f(n))。它表示随问题规模n的增大，算法执行时间的埔长率和 f(n)的埔长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f( n)是问题规横n的某个函数。

根据定义，求解算法的时间复杂度的具体步骤是：

　　⑴ 找出算法中的基本语句；
　　算法中执行次数最多的那条语句就是基本语句，通常是最内层循环的循环体。
　　⑵ 计算基本语句的执行次数的数量级；
　　只需计算基本语句执行次数的数量级，这就意味着只要保证基本语句执行次数的函数中的最高次幂正确即可，可以忽略所有低次幂和最高次幂的系数。这样能够简化算法分析，并且使注意力集中在最重要的一点上：增长率。
　　⑶ 用大Ο记号表示算法的时间性能。
　　将基本语句执行次数的数量级放入大Ο记号中。


如何推导大o阶呢？我们给出了下面 的推导方法：

1.用常数1取代运行时间中的所有加法常数。
2.在修改后的运行次数函数中，只保留最髙阶项。
3.如果最高阶项存在且不是1,则去除与这个项相乘的常数。

简单的说，就是保留求出次数的最高次幂，并且把系数去掉。  如T(n)=2n^2+n+1 =O(n^2)

举个例子。

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. #include "stdio.h"   
  2.   
  3. int main()  
  4. {  
  5.     int i, j, x = 0, sum = 0, n = 100;  /* 执行1次 */  
  6.     for( i = 1; i <= n; i++)    /* 执行n+1次 */  
  7.     {  
  8.         sum = sum + i;               /* 执行n次 */     
  9.         for( j = 1; j <= n; j++)    /* 执行n*(n+1)次 */  
  10.         {  
  11.             x++;                /* 执行n*n次 */  
  12.             sum = sum + x;      /* 执行n*n次 */  
  13.         }  
  14.     }  
  15.     printf("%d", sum);          /* 执行1次 */  
  16. }  
[cpp] view plain copy
  1. #include "stdio.h"  
  2.   
  3. int main()  
  4. {  
  5.     int i, j, x = 0, sum = 0, n = 100;  /* 执行1次 */  
  6.     for( i = 1; i <= n; i++)    /* 执行n+1次 */  
  7.     {  
  8.         sum = sum + i;               /* 执行n次 */     
  9.         for( j = 1; j <= n; j++)    /* 执行n*(n+1)次 */  
  10.         {  
  11.             x++;                /* 执行n*n次 */  
  12.             sum = sum + x;      /* 执行n*n次 */  
  13.         }  
  14.     }  
  15.     printf("%d", sum);          /* 执行1次 */  
  16. }  



 

按照上面推导“大O阶”的步骤，我们来看

第一步：“用常数 1 取代运行时间中的所有加法常数”，

则上面的算式变为：执行总次数 =3n^2 + 3n + 1

（直接相加的话,应该是T(n) = 1 + n+1 + n + n*(n+1) + n*n + n*n + 1 = 3n^2 + 3n + 3。现在用常数 1 取代运行时间中的所有加法常数，就是把T(n) = 3n^2 + 3n + 3中的最后一个3改为1. 就得到了 T(n) = 3n^2 + 3n + 1）


 

第二步：“在修改后的运行次数函数中，只保留最高阶项”。

这里的最高阶是 n 的二次方，所以算式变为：执行总次数 = 3n^2


 

第三步：“如果最高阶项存在且不是 1 ，则去除与这个项相乘的常数”。

这里 n 的二次方不是 1 所以要去除这个项的相乘常数，算式变为：执行总次数 = n^2


因此最后我们得到上面那段代码的算法时间复杂度表示为： O( n^2 )


下面我把常见的算法时间复杂度以及他们在效率上的高低顺序记录在这里，使大家对算法的效率有个直观的认识。

O(1) 常数阶 < O(logn) 对数阶 < O(n) 线性阶 < O(nlogn) < O(n^2) 平方阶 < O(n^3) < { O(2^n) < O(n!) < O(n^n) }

最后三项用大括号把他们括起来是想要告诉大家，如果日后大家设计的算法推导出的“大O阶”是大括号中的这几位，那么趁早放弃这个算法，在去研究新的算法出来吧。因为大括号中的这几位即便是在 n 的规模比较小的情况下仍然要耗费大量的时间，算法的时间复杂度大的离谱，基本上就是“不可用状态”。



好了，原理就介绍到这里了。下面通过几个例子具体分析下时间复杂度计算过程。

一。计算 1 + 2 + 3 + 4 + ...... + 100。

常规算法，代码如下：

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. #include "stdio.h"   
  2.   
  3. int main()  
  4. {  
  5.     int i, sum = 0, n = 100;    /* 执行1次 */  
  6.     for( i = 1; i <= n; i++) /* 执行 n+1 次 */  
  7.     {  
  8.         sum = sum + i;          /* 执行n次 */  
  9.         //printf("%d \n", sum);   
  10.     }  
  11.     printf("%d", sum);          /* 执行1次 */  
  12. }  
[cpp] view plain copy
  1. #include "stdio.h"  
  2.   
  3. int main()  
  4. {  
  5.     int i, sum = 0, n = 100;    /* 执行1次 */  
  6.     for( i = 1; i <= n; i++) /* 执行 n+1 次 */  
  7.     {  
  8.         sum = sum + i;          /* 执行n次 */  
  9.         //printf("%d \n", sum);  
  10.     }  
  11.     printf("%d", sum);          /* 执行1次 */  
  12. }  


从代码附加的注释可以看到所有代码都执行了多少次。那么这写代码语句执行次数的总和就可以理解为是该算法计算出结果所需要的时间。该算法所用的时间（算法语句执行的总次数）为： 1 + ( n + 1 ) + n + 1 = 2n + 3

而当 n 不断增大，比如我们这次所要计算的不是 1 + 2 + 3 + 4 + ...... + 100 = ？ 而是 1 + 2 + 3 + 4 + ...... + n = ？其中 n 是一个十分大的数字，那么由此可见，上述算法的执行总次数（所需时间）会随着 n 的增大而增加，但是在 for 循环以外的语句并不受 n 的规模影响（永远都只执行一次）。所以我们可以将上述算法的执行总次数简单的记做： 2n 或者简记 n

这样我们就得到了我们设计的算法的时间复杂度，我们把它记作： O(n)


再来看看高斯的算法，代码如下：

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. #include "stdio.h"   
  2.   
  3. int main()  
  4. {  
  5.     int sum = 0, n = 100;   /* 执行1次 */  
  6.     sum = (1 + n) * n/2;    /* 执行1次 */  
  7.   
  8.     printf("%d", sum);      /* 执行1次 */  
  9. }  
[cpp] view plain copy
  1. #include "stdio.h"  
  2.   
  3. int main()  
  4. {  
  5.     int sum = 0, n = 100;   /* 执行1次 */  
  6.     sum = (1 + n) * n/2;    /* 执行1次 */  
  7.   
  8.     printf("%d", sum);      /* 执行1次 */  
  9. }  


这个算法的时间复杂度： O(3)，但一般记作 O(1)。

从感官上我们就不难看出，从算法的效率上看，O(1) < O(n) 的，所以高斯的算法更快，更优秀。

这也就难怪为什么每本算法书开篇都是拿高斯的这个例子来举例了（至少我看的都是）...人家也确实有那个资本。



二。求两个n阶方阵C=A*B的乘积其算法如下:

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. //右边列为语句执行的频度   
  2.   
  3.    void MatrixMultiply(int A[n][n]，int B [n][n]，int C[n][n])  
  4.   
  5.    {  
  6.   
  7. (1) for(int i=0; i <n; i++)                       //n+1   
  8.   
  9.       {  
  10.   
  11. (2)      for (j=0;j < n; j++)                       //n*(n+1)   
  12.   
  13.            {  
  14.   
  15. (3)           C[i][j]=0;                                  //n^2   
  16.   
  17. (4)           for (k=0; k<n; k++)                 //n^2*(n+1)   
  18.   
  19.                {  
  20.   
  21. (5)              C[i][j]=C[i][j]+A[i][k]*B[k][j]; //n^3   
  22.   
  23.               }  
  24.   
  25.           }  
  26.   
  27.       }  
  28.   
  29.   }  
[cpp] view plain copy
  1. //右边列为语句执行的频度  
  2.   
  3.    void MatrixMultiply(int A[n][n]，int B [n][n]，int C[n][n])  
  4.   
  5.    {  
  6.   
  7. (1) for(int i=0; i <n; i++)                       //n+1  
  8.   
  9.       {  
  10.   
  11. (2)      for (j=0;j < n; j++)                       //n*(n+1)  
  12.   
  13.            {  
  14.   
  15. (3)           C[i][j]=0;                                  //n^2  
  16.   
  17. (4)           for (k=0; k<n; k++)                 //n^2*(n+1)  
  18.   
  19.                {  
  20.   
  21. (5)              C[i][j]=C[i][j]+A[i][k]*B[k][j]; //n^3  
  22.   
  23.               }  
  24.   
  25.           }  
  26.   
  27.       }  
  28.   
  29.   }  

则该算法所有语句的频度之和为:

T(n) = 2n^3+3n^2+2n+1;  利用大O表示法,该算法的时间复杂度为O(n^3)。


三。分析下列时间复杂度

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. void test_(int n)  
  2. {  
  3.     i = 1, k = 100;  
  4.     while (i<n)  
  5.     {  
  6.         k = k + 1;  
  7.         i += 2;  
  8.     }  
  9. }  
[cpp] view plain copy
  1. void test_(int n)  
  2. {  
  3.     i = 1, k = 100;  
  4.     while (i<n)  
  5.     {  
  6.         k = k + 1;  
  7.         i += 2;  
  8.     }  
  9. }  


设for循环语句执行次数为T(n),则 i = 2T(n) + 1 <= n - 1,  即T(n) <= n/2 - 1 = O(n)


四。分析下列时间复杂度

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. void test_2(int b[]， int n)  
  2. {  
  3.     int i, j, k;  
  4.     for (i=0; i<n-1; i++)  
  5.     {  
  6.         k = i;  
  7.         for (j=i+1; j<n; j++)  
  8.         {  
  9.             if (b[k] > b[j])  
  10.             {  
  11.                 k = j;  
  12.             }  
  13.         }  
  14.         x = b[i];  
  15.         b[i] = b[k];  
  16.         b[k] = x;  
  17.     }  
  18. }  
[cpp] view plain copy
  1. void test_2(int b[]， int n)  
  2. {  
  3.     int i, j, k;  
  4.     for (i=0; i<n-1; i++)  
  5.     {  
  6.         k = i;  
  7.         for (j=i+1; j<n; j++)  
  8.         {  
  9.             if (b[k] > b[j])  
  10.             {  
  11.                 k = j;  
  12.             }  
  13.         }  
  14.         x = b[i];  
  15.         b[i] = b[k];  
  16.         b[k] = x;  
  17.     }  
  18. }  


其中，算法的基本运算语句是

if (b[k] > b[j])

{

   k = j;

}

其执行次数T(n)为：



五。分析下列时间复杂度

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. void test_3(int n)  
  2. {  
  3.     int i = 0, s = 0;  
  4.     while (s<n)  
  5.     {  
  6.         i++;  
  7.         s = s + i;  
  8.     }  
  9. }  
[cpp] view plain copy
  1. void test_3(int n)  
  2. {  
  3.     int i = 0, s = 0;  
  4.     while (s<n)  
  5.     {  
  6.         i++;  
  7.         s = s + i;  
  8.     }  
  9. }  



 

其中，算法的基本运算语句即while循环内部分，

设while循环语句执行次数为T(n),则



六。Hanoi(递归算法)时间复杂度分析

[cpp] view plaincopy在CODE上查看代码片派生到我的代码片
  1. void hanoi(int n, char a, char b, char c)  
  2. {  
  3.     if (n==1)  
  4.     {  
  5.         printf("move %d disk from %c to %c \n", n, a, c);  //执行一次   
  6.     }  
  7.     else  
  8.     {  
  9.         hanoi(n-1, a, c, b);    //递归n-1次   
  10.         printf("move %d disk from %c to %c \n", n, a, c);  //执行一次   
  11.         hanoi(n-1, b, a, c);    //递归n-1次   
  12.     }  
  13. }  
[cpp] view plain copy
  1. void hanoi(int n, char a, char b, char c)  
  2. {  
  3.     if (n==1)  
  4.     {  
  5.         printf("move %d disk from %c to %c \n", n, a, c);  //执行一次  
  6.     }  
  7.     else  
  8.     {  
  9.         hanoi(n-1, a, c, b);    //递归n-1次  
  10.         printf("move %d disk from %c to %c \n", n, a, c);  //执行一次  
  11.         hanoi(n-1, b, a, c);    //递归n-1次  
  12.     }  
  13. }  


对于递归函数的分析,跟设计递归函数一样，要先考虑基情况(比如hanoi中n==1时候),这样把一个大问题划分为多个子问题的求解。

故此上述算法的时间复杂度的递归关系如下:






阅读全文
0 0
ubuntu java环境搭配 ubuntu java环境搭配
原创粉丝点击
热门IT博客
vue.js v bind的用法vue.js v bind的用法
qq tim 知乎qq tim 知乎
linux日志分析软件
淘宝童装小模特
vmware上的mac补丁
软件立项申请表
金融大数据 pdf 陈云
审美疲劳 知乎
linux libc 源代码
suse linux 开启ssh
数据库概念模型设计
html可以连接数据库吗
java线程注入service
传奇3地图编辑器源码
软件测试看什么书
库卡sim软件下载
飞天侠淘宝客网站程序
sql查表空间使用情况
收获日2优化
二叉树的中序遍历算法
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 ktv吸音棉 隔声罩 隔声材料 风轻轻吹散天地分开相隔万丈 吹叶 吹叶机 小锣号滴滴吹儿歌 吹嘘 吹嘘意思 吹嘘的意思 吹嘘拼音 吹嘘的拼音 一力吹嘘 吹嘘是什么意思 自我吹嘘的意思 绝品修仙狂少 吹嘘 埙的吹法 吹埙为什么不吉利 埙怎么吹 日本一首用埙吹的曲子 埙 唢呐吹奏 口琴吹奏 口琴吹奏法 笛子吹奏法 吹奏 善于吹奏鹰笛 笛子吹奏技巧 竹笛吹奏入门 萨克斯吹奏方法 中国古典吹奏乐器 民族吹奏乐器有哪些 万籁停吹奏什么歌 如何吹奏巴乌 口琴吹奏技法 吹奏乐器大全图片 怎样吹奏巴乌 葫芦丝吹奏教程 葫芦丝的吹奏方法 口琴吹奏方法 婚哲葫芦丝吹奏曲

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里