标签：执行 -- 复杂度 int 算法 100 数据结构 输入
时间复杂度
要计算算法时间耗费情况，首先得度量算法的执行时间，那么如何度量呢？
事后分析估算方法
比较容易想到的方法就是把算法执行若干次，用计算机计时。这种统计方法主要是通过设计好的测试程序和测试数据，利用计算机计时器对不同的算法编制的程序的运行时间进行比较，从而确定算法效率的高低，但是这种方法有很大的缺陷：必须依据算法实现编制好的测试程序，通常要花费大量时间和精力，测试完了如果发现测试的是非常糟糕的算法，那么之前所做的事情就全部白费了，并且不同的测试环境(硬件环境)的差别导致测试的结果差异也很大
事前分析估算方法
在计算机程序编写前，依据统计方法对算法进行估算
算法程序在计算机上运行所消耗的时间取决于下列因素：
算法采用的策略和方案
编译产生的代码质量
问题的输入规模(所谓的问题输入规模就是输入量的多少)
机器执行指令的速度
抛开与计算机硬件、软件有关的因素，一个程序的运行时间依赖于算法的好坏和问题的输入规模。 如果算法固定，那么该算法的执行时间就只和问题的输入规模有关系了
案例分析：计算1到100的和
/**
* 解法一
*/
public void sum() {
int sum = 0; //执行1次
int n=100; //执行1次
for (int i = 1; i <= n; i++) {//执行n+1次
sum += i; //执行n次
}
System.out.println("sum=" + sum);
}
/**
* 解法二
*/
public void sum() {
int sum = 0; //执行1次
int n=100; //执行1次
sum = (n+1)*n/2; //执行1次
System.out.println("sum="+sum);
}当输入规模为n时，第一种算法执行了1+1+(n+1)+n=2n+3次；第二种算法执行了1+1+1=3次。如果把第一种算法的循环体看做是一个整体，忽略结束条件的判断，那么其实这两个算法运行时间的差距就是n和1的差距
为什么循环判断在算法1里执行了n+1次，看起来是个不小的数量，但是却可以忽略呢？看下一个例子： 计算100个1+100个2+100个3+...100个100的结果
public void count() {
int sum=0;
int n=100;
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++) {
sum+=i;//核心操作
}
}
System.out.println("sum="+sum);
}上面这个例子中，由于真正计算和的代码是内循环的循环体，所以，在研究算法的效率时，只考虑核心代码的执行次数，这样可以简化分析（即研究算法复杂度，侧重的是当输入规模不断增大时，算法的增长量的一个抽象(规律)，而不是精确地定位需要执行多少次），不计那些循环索引的递增和循环终止的条件、变量声明、打印结果等操作，最终在分析程序的运行时间时，最重要的是把程序看做是独立于程序设计语言的算法或一系列步骤。分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模关联起来
时间复杂度规则
随着输入规模的增大，算法的常数操作可以忽略不计
假设四个算法的输入规模都是n：
算法A1要做2n+3次操作,可以这么理解：先执行n次循环，执行完毕后，再有一个n次循环，最后有3次运算
算法A2要做2n次操作
算法B1要做3n+1次操作，可以这个理解：先执行n次循环，再执行一个n次循环，再执行一个n次循环，最后有1 次运算
算法B2要做3n次操作
那么，上述算法，哪一个更快一些？
通过数据表格，比较算法A1和算法B1：
- 当输入规模n=1时，A1需要执行5次，B1需要执行4次，所以A1的效率比B1的效率低
- 当输入规模n=2时，A1需要执行7次，B1需要执行7次，所以A1的效率和B1的效率一样
- 当输入规模n>2时，A1需要的执行次数一直比B1需要执行的次数少，所以A1的效率比B1的效率高
得出结论：当输入规模n>2时，算法A1的渐近增长小于算法B1 的渐近增长
通过观察折线图，随着输入规模的增大，算法A1和算法A2逐渐重叠到一块，算法B1和算法B2逐渐重叠到一块
由此可以得出结论： 随着输入规模的增大，算法的常数操作可以忽略不计
随着输入规模的增大，与最高次项相乘的常数可以忽略
假设四个算法的输入规模都是n：
算法C1需要做4n+8次操作
算法C2需要做n次操作
算法D1需要做2n2次操作
算法D2需要做n2次操作
那么上述算法，哪个更快一些？
通过数据表格，对比算法C1和算法D1
- 当输入规模n<=3时，算法C1执行次数多于算法D1，因此算法C1效率低一些
- 当输入规模n>3时，算法C1执行次数少于算法D1，因此，算法D2效率低一些
所以，总体上，算法C1要优于算法D1
通过折线图，对比对比算法C1和C2
- 随着输入规模的增大，算法C1和算法C2几乎重叠
通过折线图，对比算法C系列和算法D系列
- 随着输入规模的增大，即使去除n^2前面的常数因子，D系列的次数要远远高于C系列
可以得出结论： 随着输入规模的增大，与最高次项相乘的常数可以忽略
最高次项的指数大的，随着n的增长，结果也会变得增长特别快
假设四个算法的输入规模都是n：
算法E1: 2n2+3n+1
算法E2： n2
算法F1： 2n3+3n+1
算法F2： n3
那么上述算法，哪个更快一些？
通过数据表格，对比算法E1和算法F1
- 当n=1时，算法E1和算法F1的执行次数一样
- 当n>1时，算法E1的执行次数远远小于算法F1的执行次数
所以算法E1总体上是由于算法F1的
通过折线图看到，算法F系列随着n的增长会变得特块，算法E系列随着n的增长相比较算法F来说，变得比较慢
可以得出结论： 最高次项的指数大的，随着n的增长，结果也会变得增长特别快
算法函数中n最高次幂越小，算法效率越高
假设五个算法的输入规模都是n：
- 算法G： n3
- 算法H: n2
- 算法I： n
- 算法J： log2n
- 算法K: 1
那么上述算法，哪个效率更高呢？
通过观察数据表格和折线图，很容易可以得出结论： 算法函数中n最高次幂越小，算法效率越高
总结
总上所述，在比较算法随着输入规模的增长量时，可以有以下规则
算法函数中的常数可以忽略
算法函数中最高次幂的常数因子可以忽略
算法函数中最高次幂越小，算法效率越高
时间复杂度之大O记法
在进行算法分析时，语句总的执行次数T(n)是关于问题规模n的函数，进而分析T(n)随着n的变化情况并确定T(n)的量级。算法的时间复杂度，就是算法的时间量度，记作:T(n)=O(f(n))。它表示随着问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称作算法的渐近时间复杂度，简称时间复杂度，其中f(n)是问题规模n的某个函数。
在这里，需要明确一个事情：执行次数=执行时间
用大写O()来体现算法时间复杂度的记法，称之为大O记法。一般情况下，随着输入规模n的增大，T(n)增长最慢的算法为最优算法
实例
/**
* 当输入规模为n时,算法执行的次数 3 次
*/
public void sum() {
int sum = 0; //执行1次
int n=100; //执行1次
sum = (n + 1) * n /2;//执行1次
System.out.println("sum=" + sum);
}/**
* 当输入规模为n时,算法执行的次数 n+2 次
*/
public void sum() {
int sum = 0;//执行1次
int n=100;//执行1次
for (int i = 1; i <= n; i++) {
sum += i;//执行了n次
}
System.out.println("sum=" + sum);
}/**
* 当输入规模为n时,算法执行的次数 n^2+2 次
*/
public void sum(){
int sum=0;//执行1次
int n=100;//执行1次
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++) {
sum+=i;//执行n^2次
}
}
System.out.println("sum="+sum);
}如果用大O记法表示上述每个算法的时间复杂度，应该如何表示呢？基于对函数渐近增长的分析，推导大O阶的表示法有以下几个规则可以使用
用常数1取代运行时间中的所有加法常数
在修改后的运行次数中，只保留高阶项
如果最高阶项存在，且常数因子不为1，则去除与这个项相乘的常数
所以，上述算法的大O记法分别为
算法一：O(1)
算法二：O(n)
算法三：O(n2)
常见的大O阶
- 线性阶 ：一般含有非嵌套循环涉及线性阶，线性阶就是随着输入规模的扩大，对应计算次数呈直线增长
- 一下代码中，它的循环的时间复杂度为O(n),因为循环体中的代码需要执行n次
public static void main(String[] args) {
int sum = 0;
int n=100;
for (int i = 1; i <= n; i++) {
sum += i;
}
System.out.println("sum=" + sum);
}- 平方阶 ：一般嵌套循环属于这种时间复杂度
- 下面这段代码，n=100，也就是说，外层循环每执行一次，内层循环就执行100次，那总共程序想要从这两个循环中出来，就需要执行100*100次，也就是n的平方次，所以这段代码的时间复杂度是O(n2)
public static void main(String[] args) {
int sum=0,n=100;
for (int i = 1; i <=n ; i++) {
for (int j = 1; j <=n ; j++) {
sum+=i;
}
}System.out.println(sum);
}- 立方阶 ：一般三层嵌套循环属于这种时间复杂度
- 下面这段代码，n=100，也就是说，外层循环每执行一次，中间循环循环就执行100次，中间循环每执行一次，最内层循环需要执行100次，那总共程序想要从这三个循环中出来，就需要执行100乘100乘100次，也就是n的立方，所以这段代码的时间复杂度是O(n3)
public static void main(String[] args) {
int x=0,n=100;
for (int i = 1; i <=n ; i++) {
for (int j = i; j <=n ; j++) {
for (int j = i; j <=n ; j++) {
x++;
}
}
}
System.out.println(x);
}- 对数阶 ：一般在循环中操作数不断的跟某个数相乘，无限接近目标值
- 下面代码中，由于每次i*2之后，就距离n更近一步，假设有x个2相乘后大于n，则会退出循环。由于是2^x=n,得到x=log(2)n,所以这个循环的时间复杂度为O(log2n)
- 对于对数阶，由于随着输入规模n的增大，不管底数为多少，他们的增长趋势是一样的，所以会忽略底数
int i=1,n=100;
while(i<n){
i = i*2;
}- 常数阶 ：一般不涉及循环操作的都是常数阶，因为它不会随着n的增长而增加操作次数
- 下面代码中，不管输入规模n是多少，都执行2次，根据大O推导法则，常数用1来替换，所以上述代码的时间复杂度为O(1)
public static void main(String[] args) {
int n=100;
int i=n+2;
System.out.println(i);
}总结，它们的复杂程度从低到高依次为：O(1)<O(logn)<O(n)<O(nlogn)<O(n2)<O(n3)
| 描述 | 增长的数量级 | 说明 | 举例 |
| 常数级别 | 1 | 普通语句 | 两数相加 |
| 对数级别 | logN | 二分策略 | 二分查找 |
| 线性级别 | N | 循环 | 查找最大值 |
| 线性对数级别 | NlogN | 分治思想 | 归并排序 |
| 平方级别 | N2 | 双层循环 | 检查所有二维数组 |
| 立方级别 | N3 | 三层循环 | 检查所有三元组 |
| 指数级别 | 2N | 穷举查找 | 查找所有子集 |
根据前面的折线图分析，从平方阶开始，随着输入规模的增大，时间成本会急剧增大，所以，算法尽可能的追求的是O(1),O(logn),O(n),O(nlogn)这几种时间复杂度，而如果发现算法的时间复杂度为平方阶、 立方阶或者更复杂的，那么认为这种算法是不可取的，需要优化
最坏的时间复杂度
/**有一个存储了n个随机数字的数组，请从中查找出指定的数字 */
public int search(int num){
int[] arr={11,10,8,9,7,22,23,0};
for (int i = 0; i < arr.length; i++) {
if (num==arr[i]){
return i;
}
}
return -1;
}最好情况：查找的第一个数字就是期望的数字，那么算法的时间复杂度为O(1)
最坏情况：查找的最后一个数字，才是期望的数字，那么算法的时间复杂度为O(n)
平均情况：任何数字查找的平均成本是O(n/2)
最坏情况是一种保证，在应用中，这是一种最基本的保障，即使在最坏情况下，也能够正常提供服务，所以除非特别指定，我们提到的运行时间都指的是最坏情况下的运行时间
空间复杂度
可以用算法的空间复杂度来描述算法对内存的占用
Java中常见内存占用
- 基本数据类型内存占用情况
-
数据类型 占用内存字节数 byte 1 short 2 int 4 long 8 float 4 double 8 boolean 1 char 2
-
- .计算机访问内存的方式都是一次一个字节
- 一个引用（机器地址）需要8个字节表示
- 创建一个对象，比如new Date()，除了Date对象内部存储的数据(例如年月日等信息)占用的内存，该对象本身也有内存开销，每个对象的自身开销是16个字节，用来保存对象的头信息
- 一般内存的使用，如果不够8个字节，都会被自动填充为8字节
- java中数组被限定为对象，他们一般都会因为记录长度而需要额外的内存，一个原始数据类型的数组一般需要24字节的头信息(16个自己的对象开销，4字节用于保存长度以及4个填充字节)再加上保存值所需的内存
计算方法
算法的空间复杂度计算公式记作：S(n)=O(f(n)),其中n为输入规模，f(n)为语句关于n所占存储空间的函数
案例分析：对指定的数组元素进行反转，并返回反转的内容
/**解法一*/
public static int[] reverse1(int[] arr){
int n=arr.length;//申请4个字节
int temp;//申请4个字节
for(int start=0,end=n-1;start<=end;start++,end--){
temp=arr[start];
arr[start]=arr[end];
arr[end]=temp;
}
return arr;
}
/**解法二*/
public static int[] reverse2(int[] arr){
int n=arr.length;//申请4个字节
int[] temp=new int[n];//申请n*4个字节+数组自身头信息开销24个字节
for (int i = n-1; i >=0; i--) {
temp[n-1-i]=arr[i];
}
return temp;
}忽略判断条件占用的内存，得出的内存占用情况如下：
算法一： 不管传入的数组大小为多少，始终额外申请4+4=8个字节
算法二： 4+4n+24=4n+28
根据大O推导法则，算法一的空间复杂度为O(1),算法二的空间复杂度为O(n),所以从空间占用的角度讲，算法一要优于算法二
由于Java中有内存垃圾回收机制，并且JVM对程序的内存占用也有优化（例如即时编译），无法精确的评估一 个Java程序的内存占用情况，但是了解了Java的基本内存占用，使我们可以对Java程序的内存占用情况进行估算
标签：执行,--,复杂度,int,算法,100,数据结构,输入 来源： https://www.cnblogs.com/52-IT-y/p/16513549.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。