Java SE学习笔记（复杂度）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、复杂度

复杂度中分为
1.时间复杂度
2.空间复杂度
复杂度：衡量一个算法的时间效率及空间效率。

二、时间复杂度

衡量一个算法执行的时间效率
一个算法所花费的时间与其中语句的执行次数成正比例，算法中基本操作的执行次数，为算法的时间复杂度。
大O的渐进法进行表示
1.用常数1取代运行中所有的加法常数。
2.在修改后的运行次数函数中，只保留最高阶项。
3.如果最高阶项存在且不是1，则除去与这个项目相乘的常数。得到的结果就是大O阶。
（找最高位）

    void fun(int n,int m){
        int count=0;
        for (int i = 0; i < m; i++) {   //时间复杂度O(m)
            count++;
        }
        for (int i = 0; i < n; i++) {   //时间复杂度O(n)
            count++;
        }
        System.out.println(count);
    }

以上代码的时间复杂度为O（n+m）

void bubbleSort(int[] array){
        for (int i = array.length;i>0; i++) {
            boolean sorted = true;
            for (int j = 0; j < i; j++) {
                if(array[j-1]>array[j]){
                    Swap(array,i-1,i);
                    sorted=false;
                }
            }
            if (sorted==true){
                break;
            }
        }
    }

最坏情况：O（n^2）
最好情况：O（n）
二分查找

int binarySearch(int[] array,int value){
	int i=0;
	int j=array.length-1;
	while(i<j){
		int mid = i+(j-i/2);
		if(array[mid]<value){
			i=mid+1;
		}else if(array[mad]>value){
			j=mid-1;
		}else{
			return mid;
		}
	}
	return -1;
}

最坏情况：log以2为底的n；
计算递归的时间复杂度
递归的时间复杂度=递归的次数*每次递归的时候执行的次数。

long factorial(int n){
	return N<2?N : factorial(N-1)*N;
}

此时时间复杂度为O（n）

总结来说：时间复杂度需要结合代码的思想来进行判断

三、空间复杂度

衡量一个算法执行的空间效率
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。
空间复杂度不是计算占用了多少bytes的空间，而是计算变量的个数。
大O的渐进表示法表示。

void bubbleSort(int[] array){
        for (int i = array.length;i>0; i++) {
            boolean sorted = true;
            for (int j = 0; j < i; j++) {
                if(array[j-1]>array[j]){
                    Swap(array,i-1,i);
                    sorted=false;
                }
            }
            if (sorted==true){
                break;
            }
        }
    }

上面代码中，空间复杂度O（1）
只浪费了一个sorted来进行优化。

计算递归的空间复杂度

long factorial(int n){
	return N<2?N : factorial(N-1)*N;
}

时间复杂度为O（n）
递归返回时，需要把返回的值进行保存，所以为O（n）