时间复杂度

算法的时间复杂度定义

在进行算法分析时，语句总的执行次数 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)

例 1

public static void main(String[] args) {
int sum = 0; //1
for (int i = 1; i <= 100; i++) { //n+1
sum = sum + i; // n
for (int j = 1; j <= 100; j++) { // n*n
sum = sum + j; // n*n
}
}
System.out.println(sum); /1
}

T(n) = 1+n+1+n+2n²⁺¹⁼²ⁿ2+2n+3
用 1 取代所有运行时间中的加法常数
T(n) =2n^2+2n+1
修改后的函数中只保留最高阶项
T(n) =2n^2
如果最高阶项存在且不是 1 则去除与这一项相乘的常数
T(n) =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) }

例 2

计算 1+2+3+4+5+…+100 一般算法

public static void main1(String[] args) {
int sum = 0;//1
int n = 100;//1
for (int i = 1; i <= n; i++) {//n+1
sum = sum + i; // n
}
System.out.println(sum);//1
}

T(n) = 2n+4=2n
或简记 T(n) = n
根据上面的计算流程得出时间复杂度为: O(n)

高斯算法

public static void main(String[] args) {
int sum = 0; // 1
int n = 100; // 1
sum = (1 + n) * n / 2;// 1
System.out.println(sum); // 1
}

时间复杂度为: O(4) , 一般简记为 O(1)
例题:

1. T(n) = 2n³⁺³ⁿ2+2n+1
2. T(n) <= n/2 - 1

例 3

public static void main(String[] args) {
int[] arr = {1, 2, 3, 56, 77, 21, 7, 10};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
System.out.println(dichotomizingSearch(arr,9));
}
private static int dichotomizingSearch(int[] arr, int value) {
int low = 0; //1
int high = arr.length - 1;//1
while (low <= high) {
int middle = (low + high) / 2;
if (value == arr[middle]) {
return middle;
}
if (value > arr[middle]) {
low = middle + 1;
}
if (value < arr[middle]) {
high = middle - 1;
}
}
return -1;
}
n/2^k = 1
k = logn
T(n) = logn * 5 + 3 = logn = O(logn)