算法效率的评估
评估算法效率的好坏主要涉及到算法的时间复杂度（Time Complexity）、空间复杂度（Space Complexity）以及在实际应用中的运行性能。 曾经调侃中文压缩包事件[1] ,白话、成语、文言文，大多数时候我们明意思白时间和知识量是递增的，时间增长和我们学习的文言文长短有关，就可以一定程度上反映难度，时间的增长情况反映的更为明显， 我们要查的书籍也会增长，要的知识量就会越大，反映他的增长情况（求一阶导数的作用）这些因素有助于我们理解算法在不同输入规模下的表现，预测其在实际应用中的可行性和效率。以下是评估算法效率的几个关键方面：
1. 时间复杂度
时间复杂度是描述算法运行时间如何随着输入规模增加而变化的数学表示。常见的时间复杂度有：
计算时间复杂度（Time Complexity）主要是通过分析算法的运行步骤，并估算其在输入规模 (n) 增长时，执行步骤的增长情况。这通常涉及以下几个步骤：
1. 识别算法中的基本操作
基本操作是算法中最频繁执行的操作，通常是最内层的操作，可以是比较、赋值、交换等。
2. 计算基本操作的执行次数
分析算法中基本操作随输入规模 (n) 增长的执行次数。通常需要分析循环、递归等结构的执行次数。
3. 用大O表示法表示时间复杂度
将基本操作的执行次数表示为输入规模 (n) 的函数，并使用大O表示法来表示时间复杂度。大O表示法关注的是执行次数增长的数量级，而忽略常数因子和低阶项。
具体示例
1. 常数时间复杂度 (O(1))
算法的运行时间不随输入规模的变化而变化。
int x = 5; // 这个操作只执行一次，与输入规模无关
2. 线性时间复杂度 (O(n))
算法的运行时间与输入规模成正比。例如，一个遍历数组的操作：
for (int i = 0; i < n; i++) {
System.out.println(arr[i]);
}
此处，基本操作 System.out.println 执行 (n) 次，所以时间复杂度是 (O(n))。
3. 平方时间复杂度 (O(n^2))
算法的运行时间与输入规模的平方成正比。例如，两个嵌套的循环：
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.println(arr[i][j]);
}
}
此处，基本操作 System.out.println 在每次外层循环中执行 (n) 次，而外层循环也执行 (n) 次，总执行次数为 n2，所以时间复杂度是 (O(n^2))。
4. 对数时间复杂度 (O(log n))
算法的运行时间随输入规模的对数增长。
例如，二分查找：
int binarySearch(int[] arr, int target) {
int low = 0, high = arr.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
此处，每次迭代都将搜索范围减半，因此基本操作的执行次数是对数级别的，时间复杂度是 (O(log n))。
5. 线性对数时间复杂度 (O(n log n))
例如，快速排序在平均情况下的时间复杂度：
void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
6. 指数时间复杂度 (O(2 n )) 和 阶乘时间复杂度 (𝑂(𝑛!))
O(n!)：运行时间随着输入规模呈指数或阶乘增长，这类算法通常仅适用于非常小的输入规模。
快速排序在每次划分操作中，都会将数组分成两部分，平均情况下这需要对数次的划分操作，每次划分需要线性时间来处理，所以平均时间复杂度是 (O(n log n))。
实际计算步骤
例子：计算冒泡排序的时间复杂度
void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
步骤1：识别基本操作
基本操作是比较和交换，即 if (arr[j] > arr[j + 1]) 和交换操作。
步骤2：计算基本操作的执行次数
- 外层循环：执行 (n-1) 次。
- 内层循环：每次外层循环，内层循环执行 (n-i-1) 次。
总的比较次数为：
步骤3：用大O表示法表示时间复杂度
执行次数是：
用大O表示法表示为 (O(n2))。
综上所述，算法的时间复杂度是通过分析其基本操作的执行次数来计算的，并使用大O表示法来表示其增长情况。通过这种方式，可以估算算法在输入规模增加时的性能表现。
2. 空间复杂度
空间复杂度描述了算法在运行过程中所需的内存空间，如何随输入规模的变化而变化。算法的空间复杂度同样使用大O表示法来描述。
常数空间复杂度 (O(1))
常数空间复杂度表示算法所需的额外空间不随输入规模的变化而变化。这种情况通常发生在算法仅使用少量的额外变量来存储数据。例：交换数
void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
}
线性空间复杂度 (O(n))
线性空间复杂度表示算法所需的额外空间与输入规模成正比。这种情况通常发生在算法需要存储与输入规模相关的数据结构或在递归算法中。例：复制数组
int[] copyArray(int[] arr) {
int[] newArr = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
额外的空间是 newArr 数组，其大小与输入数组 arr 的大小相同。
因此，空间复杂度是 (O(n))。
更复杂的空间复杂度示例
有时，算法的空间复杂度可能不仅仅是 (O(1)) 或 (O(n))，还可能是其他形式的复杂度。以下是一些示例。
示例1：空间复杂度为 (O(\log n))
二分查找算法的空间复杂度通常是 (O(\log n))，因为递归调用栈的深度是对数级别的。
int binarySearch(int[] arr, int target, int low, int high) {
if (low > high) {
return -1;
}
int mid = (low + high) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
return binarySearch(arr, target, mid + 1, high);
} else {
return binarySearch(arr, target, low, mid - 1);
}
}
递归调用栈的深度是对数级别的 (log n)。每次递归调用需要常量空间来存储参数和返回地址。因此，空间复杂度是 (O(log n))。
3. 实际运行性能
实际运行性能涉及在实际硬件和环境中测量算法的执行时间和内存使用。这可以通过以下几种方法进行：
-
基准测试（Benchmarking）：使用实际数据运行算法并测量其执行时间和内存使用。
public class Benchmark { public static void main(String[] args) { long startTime = System.nanoTime(); // 运行算法 long endTime = System.nanoTime(); long duration = (endTime - startTime); System.out.println("Execution time: " + duration + " nanoseconds"); } } -
分析工具：使用分析工具（如 Java 的 VisualVM）来获取详细的性能数据。
4. 最坏情况、最优情况和平均情况分析
算法效率的分析通常包括最坏情况、最优情况和平均情况三种情境：
- 最坏情况（Worst-case）：描述算法在最不利输入情况下的表现。通常使用大O表示法。
- 最优情况（Best-case）：描述算法在最有利输入情况下的表现。
- 平均情况（Average-case）：描述算法在所有可能输入情况下的平均表现。
例如，快速排序的时间复杂度在最坏情况下是 (O(n2))，但在平均情况下是 (O(nlog n))。
有时，即使两个算法的时间复杂度和空间复杂度相同，实际运行性能也可能不同。这通常与实现细节有关，例如：
- 内存访问模式：缓存友好的算法往往在实际运行中更快。
- 常数因子：虽然大O表示法忽略了常数因子，但在实际应用中，这些因子可能显著影响性能。
- 编程语言和优化：不同编程语言和编译器优化也会影响算法的效率。
示例：比较排序算法
以下是一个简单的示例，比较不同排序算法在同一数据集上的性能：
import java.util.Arrays;
import java.util.Random;
public class SortingComparison {
// 冒泡排序
public static void bubbleSort(int[] data) {
int n = data.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (data[j] > data[j + 1]) {
// 交换 data[j] 和 data[j + 1]
int temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
}
// 快速排序
public static void quickSort(int[] data, int low, int high) {
if (low < high) {
int pi = partition(data, low, high);
quickSort(data, low, pi - 1);
quickSort(data, pi + 1, high);
}
}
public static int partition(int[] data, int low, int high) {
int pivot = data[high];
int i = (low - 1); // 小于pivot的元素的索引
for (int j = low; j < high; j++) {
if (data[j] <= pivot) {
i++;
// 交换 data[i] 和 data[j]
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
// 交换 data[i+1] 和 data[high] (即 pivot)
int temp = data[i + 1];
data[i + 1] = data[high];
data[high] = temp;
return i + 1;
}
// 生成随机数据
public static int[] generateRandomArray(int size, int maxValue) {
Random rand = new Random();
int[] array = new int[size];
for (int i = 0; i < size; i++) {
array[i] = rand.nextInt(maxValue);
}
return array;
}
public static void main(String[] args) {
int[] data = generateRandomArray(1000, 1000);
// 测试冒泡排序
int[] dataCopy1 = Arrays.copyOf(data, data.length);
long startTime = System.nanoTime();
bubbleSort(dataCopy1);
long endTime = System.nanoTime();
System.out.println("Bubble Sort Time: " + (endTime - startTime) + " nanoseconds");
// 测试快速排序
int[] dataCopy2 = Arrays.copyOf(data, data.length);
startTime = System.nanoTime();
quickSort(dataCopy2, 0, dataCopy2.length - 1);
endTime = System.nanoTime();
System.out.println("Quick Sort Time: " + (endTime - startTime) + " nanoseconds");
}
}
通过这种方式，你可以直接比较不同算法在相同数据集上的实际运行时间，从而评估其效率。
数学方法计算还是推荐下方链接，毕竟数学这种自己会，讲给别人难，还是实践代码简单一点：https://www.hello-algo.com/chapter_computational_complexity/time_complexity/#3-on2
评估算法效率的好坏需要综合考虑时间复杂度、空间复杂度、实际运行性能、最坏和平均情况分析、可扩展性、并行性、实现细节和实际应用表现。持续更新中~~
