编程的基础：理解时间和空间复杂度
- 时间复杂度
- 空间复杂度
- 示例
- 常数时间复杂度 O(1)
- 线性时间复杂度 O(n)
- 线性对数时间复杂度 O(n log n)
- 二次时间复杂度 O(n^2)
- 指数时间复杂度 O(2^n)
- 空间复杂度
- 示例
- 常数空间复杂度 O(1)
- 线性空间复杂度 O(n)
- 线性对数空间复杂度 O(log n)
- 总结
了解时间和空间复杂度对于编写高效的代码至关重要。在这篇博客中，我们将深入探讨这两个概念，并提供示例来帮助您计算时间和空间复杂度。
时间复杂度
时间复杂度是指算法运行所需时间的量度，它是输入规模的函数。它通常使用大 O 符号表示，大 O 符号描述了最坏情况下的时间复杂度上限。
时间复杂度的几个常见类别包括：
- O(1) - 常数时间复杂度：无论输入规模如何，算法运行所需的时间都保持不变。
- O(log n) - 对数时间复杂度：随着输入规模的增大，算法运行需要的时间变长，但增长速度与输入规模的对数成正比。
- O(n) - 线性时间复杂度：随着输入规模的增大，算法运行需要的时间变长，增长速度与输入规模成线性关系。
- O(n log n) - 线性对数时间复杂度：随着输入规模的增大，算法运行需要的时间变长，增长速度与输入规模的对数和线性关系成正比。
- O(n^2) - 二次时间复杂度：随着输入规模的增大，算法运行需要的时间变长，增长速度与输入规模的平方成正比。
- O(2^n) - 指数时间复杂度：随着输入规模的增大，算法运行需要的时间变长，增长速度呈指数增长。
空间复杂度
空间复杂度是指算法运行所需的内存量的量度，包括输入数据和算法本身所需的空间。空间复杂度也通常使用大 O 符号表示。
空间复杂度的几个常见类别包括：
- O(1) - 常数空间复杂度：无论输入规模如何，算法运行所需的内存都保持不变。
- O(n) - 线性空间复杂度：算法运行所需的内存与输入规模成正比。
- O(n^2) - 二次空间复杂度：算法运行所需的内存与输入规模的平方成正比。
- O(log n) - 对数空间复杂度：算法运行所需的内存与输入规模的对数成正比。
示例
常数时间复杂度 O(1)
下面是一个计算数组元素之和的 Java 代码，它的时间复杂度为 O(1)：
public static int sumOfArray(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
return arr[0] + arr[arr.length - 1];
}
这个 Java 代码的时间复杂度为 O(1)，因为无论输入规模如何，算法运行所需的时间都保持不变。
线性时间复杂度 O(n)
下面是一个计算数组元素之和的 Java 代码，它的时间复杂度为 O(n)：
public static int sumOfArray(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int total = 0;
for (int i = 0; i < arr.length; i++) {
total += arr[i];
}
return total;
}
这个 Java 代码的时间复杂度为 O(n)，其中 n 是输入数组的长度。原因是，当输入规模增大时，算法运行需要的时间变长，并且时间与输入规模成线性关系。
线性对数时间复杂度 O(n log n)
下面是一个对数序列的排序算法 Java 代码，它的时间复杂度为 O(n log n)：
public static void sort(int[] arr) {
if (arr == null || arr.length == 0) {
return;
}
Arrays.sort(arr);
}
这个 Java 代码的时间复杂度为 O(n log n)，因为它使用了 Java 标准库中的排序算法，该算法的时间复杂度为 O(n log n)。
二次时间复杂度 O(n^2)
下面是一个计算两个数组的交集的 Java 代码，它的时间复杂度为 O(n^2)：
public static int[] intersection(int[] arr1, int[] arr2) {
if (arr1 == null || arr2 == null || arr1.length == 0 || arr2.length == 0) {
return new int[0];
}
int[] result = new int[Math.min(arr1.length, arr2.length)];
int index = 0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr2.length; j++) {
if (arr1[i] == arr2[j]) {
result[index++] = arr1[i];
break;
}
}
}
return Arrays.copyOfRange(result, 0, index);
}
这个 Java 代码的时间复杂度为 O(n^2)，因为它使用了双重循环，时间与输入规模的平方成正比。
指数时间复杂度 O(2^n)
下面是一个计算斐波那契数列的 Java 代码，它的时间复杂度为 O(2^n)：
public static long fibonacci(int n) {
if (n <= 1) {
return n;
}
return fibonacci(n - 1) + fibonacci(n - 2);
}
这个 Java 代码的时间复杂度为 O(2^n)，因为它使用了递归调用，时间呈指数增长。
空间复杂度
空间复杂度是指算法运行所需的内存量的量度，包括输入数据和算法本身所需的空间。空间复杂度也通常使用大 O 符号表示。
空间复杂度的几个常见类别包括：
- O(1) - 常数空间复杂度：无论输入规模如何，算法运行所需的内存都保持不变。
- O(n) - 线性空间复杂度：算法运行所需的内存与输入规模成正比。
- O(n^2) - 二次空间复杂度：算法运行所需的内存与输入规模的平方成正比。
- O(log n) - 对数空间复杂度：算法运行所需的内存与输入规模的对数成正比。
示例
常数空间复杂度 O(1)
下面是一个计算数组元素之和的 Java 代码，它的空间复杂度为 O(1)：
public static int sumOfArray(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
return arr[0] + arr[arr.length - 1];
}
这个 Java 代码的空间复杂度为 O(1)，因为无论输入规模如何，算法运行所需的内存都保持不变。
线性空间复杂度 O(n)
下面是一个计算数组元素之和的 Java 代码，它的空间复杂度为 O(n)：
public static int sumOfArray(int[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
int total = 0;
for (int i = 0; i < arr.length; i++) {
total += arr[i];
}
return total;
}
这个 Java 代码的空间复杂度为 O(n)，因为算法运行所需的内存与输入规模成正比。
线性对数空间复杂度 O(log n)
下面是一个二分查找算法 Java 代码，它的空间复杂度为 O(log n)：
public static int binarySearch(int[] arr, int target) {
if (arr == null || arr.length == 0) {
return -1;
}
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
这个 Java 代码的空间复杂度为 O(log n)，因为算法运行所需的内存与输入规模的对数成正比。
总结
了解时间和空间复杂度对于编写高效的代码至关重要，这些代码在运行时需要最少的时间并使用最小的内存。通过分析代码的时间和空间复杂度，您可以做出明智的决策，以优化代码以获得更好的性能。通过练习，您将能够识别不同算法的时间和空间复杂度，并为不同需求选择最有效的算法。
版权声明：
原创博主：牛哄哄的柯南
博主原文链接：https://keafmd.blog.csdn.net/
个人博客链接：https://www.keafmd.top/
看完如果对你有帮助，感谢点击下面的点赞支持！
[哈哈][抱拳]
加油！
共同努力！
Keafmd
感谢支持牛哄哄的柯南，期待你的三连+关注~~
keep accumulate for my dream【共勉】
↓ ↓ ↓ 合作 交流 ↓ ↓ ↓
