mirror of
https://github.com/krahets/hello-algo.git
synced 2025-01-23 06:00:27 +08:00
Polish the chapter
introduction, computational complexity.
This commit is contained in:
krahets
parent
5fb728b3d6
commit
2626de8d0b
@ -135,38 +135,38 @@ int main(int argc, char *argv[]) {
|
||||
printf("输入数据大小 n = %d\n", n);
|
||||
|
||||
int count = constant(n);
|
||||
printf("常数阶的计算操作数量 = %d\n", count);
|
||||
printf("常数阶的操作数量 = %d\n", count);
|
||||
|
||||
count = linear(n);
|
||||
printf("线性阶的计算操作数量 = %d\n", count);
|
||||
printf("线性阶的操作数量 = %d\n", count);
|
||||
// 分配堆区内存（创建一维可变长数组：数组中元素数量为n，元素类型为int）
|
||||
int *nums = (int *)malloc(n * sizeof(int));
|
||||
count = arrayTraversal(nums, n);
|
||||
printf("线性阶（遍历数组）的计算操作数量 = %d\n", count);
|
||||
printf("线性阶（遍历数组）的操作数量 = %d\n", count);
|
||||
|
||||
count = quadratic(n);
|
||||
printf("平方阶的计算操作数量 = %d\n", count);
|
||||
printf("平方阶的操作数量 = %d\n", count);
|
||||
for (int i = 0; i < n; i++) {
|
||||
nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
}
|
||||
count = bubbleSort(nums, n);
|
||||
printf("平方阶（冒泡排序）的计算操作数量 = %d\n", count);
|
||||
printf("平方阶（冒泡排序）的操作数量 = %d\n", count);
|
||||
|
||||
count = exponential(n);
|
||||
printf("指数阶（循环实现）的计算操作数量 = %d\n", count);
|
||||
printf("指数阶（循环实现）的操作数量 = %d\n", count);
|
||||
count = expRecur(n);
|
||||
printf("指数阶（递归实现）的计算操作数量 = %d\n", count);
|
||||
printf("指数阶（递归实现）的操作数量 = %d\n", count);
|
||||
|
||||
count = logarithmic(n);
|
||||
printf("对数阶（循环实现）的计算操作数量 = %d\n", count);
|
||||
printf("对数阶（循环实现）的操作数量 = %d\n", count);
|
||||
count = logRecur(n);
|
||||
printf("对数阶（递归实现）的计算操作数量 = %d\n", count);
|
||||
printf("对数阶（递归实现）的操作数量 = %d\n", count);
|
||||
|
||||
count = linearLogRecur(n);
|
||||
printf("线性对数阶（递归实现）的计算操作数量 = %d\n", count);
|
||||
printf("线性对数阶（递归实现）的操作数量 = %d\n", count);
|
||||
|
||||
count = factorialRecur(n);
|
||||
printf("阶乘阶（递归实现）的计算操作数量 = %d\n", count);
|
||||
printf("阶乘阶（递归实现）的操作数量 = %d\n", count);
|
||||
|
||||
// 释放堆区内存
|
||||
if (nums != NULL) {
|
||||
|
||||
@ -119,7 +119,7 @@ void siftDown(maxHeap *h, int i) {
|
||||
if (r < size(h) && h->data[r] > h->data[max]) {
|
||||
max = r;
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (max == i) {
|
||||
break;
|
||||
}
|
||||
@ -135,7 +135,7 @@ void siftUp(maxHeap *h, int i) {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
int p = parent(h, i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || h->data[i] <= h->data[p]) {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -17,7 +17,7 @@ void siftDown(int nums[], int n, int i) {
|
||||
ma = l;
|
||||
if (r < n && nums[r] > nums[ma])
|
||||
ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i) {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -107,7 +107,7 @@ TreeNode *rotate(TreeNode *node) {
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -132,37 +132,37 @@ int main() {
|
||||
cout << "输入数据大小 n = " << n << endl;
|
||||
|
||||
int count = constant(n);
|
||||
cout << "常数阶的计算操作数量 = " << count << endl;
|
||||
cout << "常数阶的操作数量 = " << count << endl;
|
||||
|
||||
count = linear(n);
|
||||
cout << "线性阶的计算操作数量 = " << count << endl;
|
||||
cout << "线性阶的操作数量 = " << count << endl;
|
||||
vector<int> arr(n);
|
||||
count = arrayTraversal(arr);
|
||||
cout << "线性阶（遍历数组）的计算操作数量 = " << count << endl;
|
||||
cout << "线性阶（遍历数组）的操作数量 = " << count << endl;
|
||||
|
||||
count = quadratic(n);
|
||||
cout << "平方阶的计算操作数量 = " << count << endl;
|
||||
cout << "平方阶的操作数量 = " << count << endl;
|
||||
vector<int> nums(n);
|
||||
for (int i = 0; i < n; i++)
|
||||
nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums);
|
||||
cout << "平方阶（冒泡排序）的计算操作数量 = " << count << endl;
|
||||
cout << "平方阶（冒泡排序）的操作数量 = " << count << endl;
|
||||
|
||||
count = exponential(n);
|
||||
cout << "指数阶（循环实现）的计算操作数量 = " << count << endl;
|
||||
cout << "指数阶（循环实现）的操作数量 = " << count << endl;
|
||||
count = expRecur(n);
|
||||
cout << "指数阶（递归实现）的计算操作数量 = " << count << endl;
|
||||
cout << "指数阶（递归实现）的操作数量 = " << count << endl;
|
||||
|
||||
count = logarithmic((float)n);
|
||||
cout << "对数阶（循环实现）的计算操作数量 = " << count << endl;
|
||||
cout << "对数阶（循环实现）的操作数量 = " << count << endl;
|
||||
count = logRecur((float)n);
|
||||
cout << "对数阶（递归实现）的计算操作数量 = " << count << endl;
|
||||
cout << "对数阶（递归实现）的操作数量 = " << count << endl;
|
||||
|
||||
count = linearLogRecur((float)n);
|
||||
cout << "线性对数阶（递归实现）的计算操作数量 = " << count << endl;
|
||||
cout << "线性对数阶（递归实现）的操作数量 = " << count << endl;
|
||||
|
||||
count = factorialRecur(n);
|
||||
cout << "阶乘阶（递归实现）的计算操作数量 = " << count << endl;
|
||||
cout << "阶乘阶（递归实现）的操作数量 = " << count << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
/* 大顶堆 */
|
||||
class MaxHeap {
|
||||
private:
|
||||
// 使用动态数组，这样无需考虑扩容问题
|
||||
// 使用动态数组，这样无须考虑扩容问题
|
||||
vector<int> maxHeap;
|
||||
|
||||
/* 获取左子节点索引 */
|
||||
@ -32,7 +32,7 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
int p = parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || maxHeap[i] <= maxHeap[p])
|
||||
break;
|
||||
// 交换两节点
|
||||
@ -47,12 +47,12 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 判断节点 i, l, r 中值最大的节点，记为 ma
|
||||
int l = left(i), r = right(i), ma = i;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (l < size() && maxHeap[l] > maxHeap[ma])
|
||||
ma = l;
|
||||
if (r < size() && maxHeap[r] > maxHeap[ma])
|
||||
ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i)
|
||||
break;
|
||||
swap(maxHeap[i], maxHeap[ma]);
|
||||
|
||||
@ -17,7 +17,7 @@ void siftDown(vector<int> &nums, int n, int i) {
|
||||
ma = l;
|
||||
if (r < n && nums[r] > nums[ma])
|
||||
ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i) {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -71,7 +71,7 @@ class AVLTree {
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -160,35 +160,35 @@ public class time_complexity {
|
||||
Console.WriteLine("输入数据大小 n = " + n);
|
||||
|
||||
int count = constant(n);
|
||||
Console.WriteLine("常数阶的计算操作数量 = " + count);
|
||||
Console.WriteLine("常数阶的操作数量 = " + count);
|
||||
|
||||
count = linear(n);
|
||||
Console.WriteLine("线性阶的计算操作数量 = " + count);
|
||||
Console.WriteLine("线性阶的操作数量 = " + count);
|
||||
count = arrayTraversal(new int[n]);
|
||||
Console.WriteLine("线性阶（遍历数组）的计算操作数量 = " + count);
|
||||
Console.WriteLine("线性阶（遍历数组）的操作数量 = " + count);
|
||||
|
||||
count = quadratic(n);
|
||||
Console.WriteLine("平方阶的计算操作数量 = " + count);
|
||||
Console.WriteLine("平方阶的操作数量 = " + count);
|
||||
int[] nums = new int[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums);
|
||||
Console.WriteLine("平方阶（冒泡排序）的计算操作数量 = " + count);
|
||||
Console.WriteLine("平方阶（冒泡排序）的操作数量 = " + count);
|
||||
|
||||
count = exponential(n);
|
||||
Console.WriteLine("指数阶（循环实现）的计算操作数量 = " + count);
|
||||
Console.WriteLine("指数阶（循环实现）的操作数量 = " + count);
|
||||
count = expRecur(n);
|
||||
Console.WriteLine("指数阶（递归实现）的计算操作数量 = " + count);
|
||||
Console.WriteLine("指数阶（递归实现）的操作数量 = " + count);
|
||||
|
||||
count = logarithmic((float)n);
|
||||
Console.WriteLine("对数阶（循环实现）的计算操作数量 = " + count);
|
||||
Console.WriteLine("对数阶（循环实现）的操作数量 = " + count);
|
||||
count = logRecur((float)n);
|
||||
Console.WriteLine("对数阶（递归实现）的计算操作数量 = " + count);
|
||||
Console.WriteLine("对数阶（递归实现）的操作数量 = " + count);
|
||||
|
||||
count = linearLogRecur((float)n);
|
||||
Console.WriteLine("线性对数阶（递归实现）的计算操作数量 = " + count);
|
||||
Console.WriteLine("线性对数阶（递归实现）的操作数量 = " + count);
|
||||
|
||||
count = factorialRecur(n);
|
||||
Console.WriteLine("阶乘阶（递归实现）的计算操作数量 = " + count);
|
||||
Console.WriteLine("阶乘阶（递归实现）的操作数量 = " + count);
|
||||
}
|
||||
}
|
||||
|
||||
@ -8,7 +8,7 @@ namespace hello_algo.chapter_heap;
|
||||
|
||||
/* 大顶堆 */
|
||||
class MaxHeap {
|
||||
// 使用列表而非数组，这样无需考虑扩容问题
|
||||
// 使用列表而非数组，这样无须考虑扩容问题
|
||||
private readonly List<int> maxHeap;
|
||||
|
||||
/* 构造函数，建立空堆 */
|
||||
@ -70,7 +70,7 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
int p = parent(i);
|
||||
// 若“越过根节点”或“节点无需修复”，则结束堆化
|
||||
// 若“越过根节点”或“节点无须修复”，则结束堆化
|
||||
if (p < 0 || maxHeap[i] <= maxHeap[p])
|
||||
break;
|
||||
// 交换两节点
|
||||
|
||||
@ -18,7 +18,7 @@ public class heap_sort {
|
||||
ma = l;
|
||||
if (r < n && nums[r] > nums[ma])
|
||||
ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i)
|
||||
break;
|
||||
// 交换两节点
|
||||
|
||||
@ -84,7 +84,7 @@ class AVLTree {
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -128,36 +128,36 @@ void main() {
|
||||
print('输入数据大小 n = $n');
|
||||
|
||||
int count = constant(n);
|
||||
print('常数阶的计算操作数量 = $count');
|
||||
print('常数阶的操作数量 = $count');
|
||||
|
||||
count = linear(n);
|
||||
print('线性阶的计算操作数量 = $count');
|
||||
print('线性阶的操作数量 = $count');
|
||||
|
||||
count = arrayTraversal(List.filled(n, 0));
|
||||
print('线性阶（遍历数组）的计算操作数量 = $count');
|
||||
print('线性阶（遍历数组）的操作数量 = $count');
|
||||
|
||||
count = quadratic(n);
|
||||
print('平方阶的计算操作数量 = $count');
|
||||
print('平方阶的操作数量 = $count');
|
||||
final nums = List.filled(n, 0);
|
||||
for (int i = 0; i < n; i++) {
|
||||
nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
}
|
||||
count = bubbleSort(nums);
|
||||
print('平方阶（冒泡排序）的计算操作数量 = $count');
|
||||
print('平方阶（冒泡排序）的操作数量 = $count');
|
||||
|
||||
count = exponential(n);
|
||||
print('指数阶（循环实现）的计算操作数量 = $count');
|
||||
print('指数阶（循环实现）的操作数量 = $count');
|
||||
count = expRecur(n);
|
||||
print('指数阶（递归实现）的计算操作数量 = $count');
|
||||
print('指数阶（递归实现）的操作数量 = $count');
|
||||
|
||||
count = logarithmic(n);
|
||||
print('对数阶（循环实现）的计算操作数量 = $count');
|
||||
print('对数阶（循环实现）的操作数量 = $count');
|
||||
count = logRecur(n);
|
||||
print('对数阶（递归实现）的计算操作数量 = $count');
|
||||
print('对数阶（递归实现）的操作数量 = $count');
|
||||
|
||||
count = linearLogRecur(n);
|
||||
print('线性对数阶（递归实现）的计算操作数量 = $count');
|
||||
print('线性对数阶（递归实现）的操作数量 = $count');
|
||||
|
||||
count = factorialRecur(n);
|
||||
print('阶乘阶（递归实现）的计算操作数量 = $count');
|
||||
print('阶乘阶（递归实现）的操作数量 = $count');
|
||||
}
|
||||
|
||||
@ -70,7 +70,7 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
int p = _parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {
|
||||
break;
|
||||
}
|
||||
@ -104,7 +104,7 @@ class MaxHeap {
|
||||
int ma = i;
|
||||
if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;
|
||||
if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i) break;
|
||||
// 交换两节点
|
||||
_swap(i, ma);
|
||||
|
||||
@ -100,7 +100,7 @@ class MinHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
int p = _parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || _minHeap[i] >= _minHeap[p]) {
|
||||
break;
|
||||
}
|
||||
@ -134,7 +134,7 @@ class MinHeap {
|
||||
int mi = i;
|
||||
if (l < size() && _minHeap[l] < _minHeap[mi]) mi = l;
|
||||
if (r < size() && _minHeap[r] < _minHeap[mi]) mi = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (mi == i) break;
|
||||
// 交换两节点
|
||||
_swap(i, mi);
|
||||
|
||||
@ -13,7 +13,7 @@ void siftDown(List<int> nums, int n, int i) {
|
||||
int ma = i;
|
||||
if (l < n && nums[l] > nums[ma]) ma = l;
|
||||
if (r < n && nums[r] > nums[ma]) ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i) break;
|
||||
// 交换两节点
|
||||
int temp = nums[i];
|
||||
|
||||
@ -90,7 +90,7 @@ class AVLTree {
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -14,35 +14,35 @@ func TestTimeComplexity(t *testing.T) {
|
||||
fmt.Println("输入数据大小 n =", n)
|
||||
|
||||
count := constant(n)
|
||||
fmt.Println("常数阶的计算操作数量 =", count)
|
||||
fmt.Println("常数阶的操作数量 =", count)
|
||||
|
||||
count = linear(n)
|
||||
fmt.Println("线性阶的计算操作数量 =", count)
|
||||
fmt.Println("线性阶的操作数量 =", count)
|
||||
count = arrayTraversal(make([]int, n))
|
||||
fmt.Println("线性阶（遍历数组）的计算操作数量 =", count)
|
||||
fmt.Println("线性阶（遍历数组）的操作数量 =", count)
|
||||
|
||||
count = quadratic(n)
|
||||
fmt.Println("平方阶的计算操作数量 =", count)
|
||||
fmt.Println("平方阶的操作数量 =", count)
|
||||
nums := make([]int, n)
|
||||
for i := 0; i < n; i++ {
|
||||
nums[i] = n - i
|
||||
}
|
||||
count = bubbleSort(nums)
|
||||
fmt.Println("平方阶（冒泡排序）的计算操作数量 =", count)
|
||||
fmt.Println("平方阶（冒泡排序）的操作数量 =", count)
|
||||
|
||||
count = exponential(n)
|
||||
fmt.Println("指数阶（循环实现）的计算操作数量 =", count)
|
||||
fmt.Println("指数阶（循环实现）的操作数量 =", count)
|
||||
count = expRecur(n)
|
||||
fmt.Println("指数阶（递归实现）的计算操作数量 =", count)
|
||||
fmt.Println("指数阶（递归实现）的操作数量 =", count)
|
||||
|
||||
count = logarithmic(float64(n))
|
||||
fmt.Println("对数阶（循环实现）的计算操作数量 =", count)
|
||||
fmt.Println("对数阶（循环实现）的操作数量 =", count)
|
||||
count = logRecur(float64(n))
|
||||
fmt.Println("对数阶（递归实现）的计算操作数量 =", count)
|
||||
fmt.Println("对数阶（递归实现）的操作数量 =", count)
|
||||
|
||||
count = linearLogRecur(float64(n))
|
||||
fmt.Println("线性对数阶（递归实现）的计算操作数量 =", count)
|
||||
fmt.Println("线性对数阶（递归实现）的操作数量 =", count)
|
||||
|
||||
count = factorialRecur(n)
|
||||
fmt.Println("阶乘阶（递归实现）的计算操作数量 =", count)
|
||||
fmt.Println("阶乘阶（递归实现）的操作数量 =", count)
|
||||
}
|
||||
|
||||
@ -11,7 +11,7 @@ import (
|
||||
)
|
||||
|
||||
type maxHeap struct {
|
||||
// 使用切片而非数组，这样无需考虑扩容问题
|
||||
// 使用切片而非数组，这样无须考虑扩容问题
|
||||
data []any
|
||||
}
|
||||
|
||||
@ -82,7 +82,7 @@ func (h *maxHeap) siftUp(i int) {
|
||||
for true {
|
||||
// 获取节点 i 的父节点
|
||||
p := h.parent(i)
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if p < 0 || h.data[i].(int) <= h.data[p].(int) {
|
||||
break
|
||||
}
|
||||
@ -123,7 +123,7 @@ func (h *maxHeap) siftDown(i int) {
|
||||
if r < h.size() && h.data[r].(int) > h.data[max].(int) {
|
||||
max = r
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if max == i {
|
||||
break
|
||||
}
|
||||
|
||||
@ -17,7 +17,7 @@ func siftDown(nums *[]int, n, i int) {
|
||||
if r < n && (*nums)[r] > (*nums)[ma] {
|
||||
ma = r
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i {
|
||||
break
|
||||
}
|
||||
|
||||
@ -102,7 +102,7 @@ func (t *aVLTree) rotate(node *TreeNode) *TreeNode {
|
||||
return t.leftRotate(node)
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node
|
||||
}
|
||||
|
||||
|
||||
@ -134,35 +134,35 @@ public class time_complexity {
|
||||
System.out.println("输入数据大小 n = " + n);
|
||||
|
||||
int count = constant(n);
|
||||
System.out.println("常数阶的计算操作数量 = " + count);
|
||||
System.out.println("常数阶的操作数量 = " + count);
|
||||
|
||||
count = linear(n);
|
||||
System.out.println("线性阶的计算操作数量 = " + count);
|
||||
System.out.println("线性阶的操作数量 = " + count);
|
||||
count = arrayTraversal(new int[n]);
|
||||
System.out.println("线性阶（遍历数组）的计算操作数量 = " + count);
|
||||
System.out.println("线性阶（遍历数组）的操作数量 = " + count);
|
||||
|
||||
count = quadratic(n);
|
||||
System.out.println("平方阶的计算操作数量 = " + count);
|
||||
System.out.println("平方阶的操作数量 = " + count);
|
||||
int[] nums = new int[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums);
|
||||
System.out.println("平方阶（冒泡排序）的计算操作数量 = " + count);
|
||||
System.out.println("平方阶（冒泡排序）的操作数量 = " + count);
|
||||
|
||||
count = exponential(n);
|
||||
System.out.println("指数阶（循环实现）的计算操作数量 = " + count);
|
||||
System.out.println("指数阶（循环实现）的操作数量 = " + count);
|
||||
count = expRecur(n);
|
||||
System.out.println("指数阶（递归实现）的计算操作数量 = " + count);
|
||||
System.out.println("指数阶（递归实现）的操作数量 = " + count);
|
||||
|
||||
count = logarithmic((float) n);
|
||||
System.out.println("对数阶（循环实现）的计算操作数量 = " + count);
|
||||
System.out.println("对数阶（循环实现）的操作数量 = " + count);
|
||||
count = logRecur((float) n);
|
||||
System.out.println("对数阶（递归实现）的计算操作数量 = " + count);
|
||||
System.out.println("对数阶（递归实现）的操作数量 = " + count);
|
||||
|
||||
count = linearLogRecur((float) n);
|
||||
System.out.println("线性对数阶（递归实现）的计算操作数量 = " + count);
|
||||
System.out.println("线性对数阶（递归实现）的操作数量 = " + count);
|
||||
|
||||
count = factorialRecur(n);
|
||||
System.out.println("阶乘阶（递归实现）的计算操作数量 = " + count);
|
||||
System.out.println("阶乘阶（递归实现）的操作数量 = " + count);
|
||||
}
|
||||
}
|
||||
|
||||
@ -11,7 +11,7 @@ import java.util.*;
|
||||
|
||||
/* 大顶堆 */
|
||||
class MaxHeap {
|
||||
// 使用列表而非数组，这样无需考虑扩容问题
|
||||
// 使用列表而非数组，这样无须考虑扩容问题
|
||||
private List<Integer> maxHeap;
|
||||
|
||||
/* 构造方法，根据输入列表建堆 */
|
||||
@ -74,7 +74,7 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
int p = parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || maxHeap.get(i) <= maxHeap.get(p))
|
||||
break;
|
||||
// 交换两节点
|
||||
@ -108,7 +108,7 @@ class MaxHeap {
|
||||
ma = l;
|
||||
if (r < size() && maxHeap.get(r) > maxHeap.get(ma))
|
||||
ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i)
|
||||
break;
|
||||
// 交换两节点
|
||||
|
||||
@ -20,7 +20,7 @@ public class heap_sort {
|
||||
ma = l;
|
||||
if (r < n && nums[r] > nums[ma])
|
||||
ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i)
|
||||
break;
|
||||
// 交换两节点
|
||||
|
||||
@ -87,7 +87,7 @@ class AVLTree {
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -124,32 +124,32 @@ const n = 8;
|
||||
console.log('输入数据大小 n = ' + n);
|
||||
|
||||
let count = constant(n);
|
||||
console.log('常数阶的计算操作数量 = ' + count);
|
||||
console.log('常数阶的操作数量 = ' + count);
|
||||
|
||||
count = linear(n);
|
||||
console.log('线性阶的计算操作数量 = ' + count);
|
||||
console.log('线性阶的操作数量 = ' + count);
|
||||
count = arrayTraversal(new Array(n));
|
||||
console.log('线性阶（遍历数组）的计算操作数量 = ' + count);
|
||||
console.log('线性阶（遍历数组）的操作数量 = ' + count);
|
||||
|
||||
count = quadratic(n);
|
||||
console.log('平方阶的计算操作数量 = ' + count);
|
||||
console.log('平方阶的操作数量 = ' + count);
|
||||
let nums = new Array(n);
|
||||
for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums);
|
||||
console.log('平方阶（冒泡排序）的计算操作数量 = ' + count);
|
||||
console.log('平方阶（冒泡排序）的操作数量 = ' + count);
|
||||
|
||||
count = exponential(n);
|
||||
console.log('指数阶（循环实现）的计算操作数量 = ' + count);
|
||||
console.log('指数阶（循环实现）的操作数量 = ' + count);
|
||||
count = expRecur(n);
|
||||
console.log('指数阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('指数阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
count = logarithmic(n);
|
||||
console.log('对数阶（循环实现）的计算操作数量 = ' + count);
|
||||
console.log('对数阶（循环实现）的操作数量 = ' + count);
|
||||
count = logRecur(n);
|
||||
console.log('对数阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('对数阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
count = linearLogRecur(n);
|
||||
console.log('线性对数阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('线性对数阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
count = factorialRecur(n);
|
||||
console.log('阶乘阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('阶乘阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
@ -70,7 +70,7 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
const p = this.#parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || this.#maxHeap[i] <= this.#maxHeap[p]) break;
|
||||
// 交换两节点
|
||||
this.#swap(i, p);
|
||||
@ -102,7 +102,7 @@ class MaxHeap {
|
||||
let ma = i;
|
||||
if (l < this.size() && this.#maxHeap[l] > this.#maxHeap[ma]) ma = l;
|
||||
if (r < this.size() && this.#maxHeap[r] > this.#maxHeap[ma]) ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma === i) break;
|
||||
// 交换两节点
|
||||
this.#swap(i, ma);
|
||||
|
||||
@ -17,7 +17,7 @@ function siftDown(nums, n, i) {
|
||||
if (r < n && nums[r] > nums[ma]) {
|
||||
ma = r;
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma === i) {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -89,7 +89,7 @@ class AVLTree {
|
||||
return this.#leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -121,31 +121,31 @@ if __name__ == "__main__":
|
||||
print("输入数据大小 n =", n)
|
||||
|
||||
count: int = constant(n)
|
||||
print("常数阶的计算操作数量 =", count)
|
||||
print("常数阶的操作数量 =", count)
|
||||
|
||||
count: int = linear(n)
|
||||
print("线性阶的计算操作数量 =", count)
|
||||
print("线性阶的操作数量 =", count)
|
||||
count: int = array_traversal([0] * n)
|
||||
print("线性阶（遍历数组）的计算操作数量 =", count)
|
||||
print("线性阶（遍历数组）的操作数量 =", count)
|
||||
|
||||
count: int = quadratic(n)
|
||||
print("平方阶的计算操作数量 =", count)
|
||||
print("平方阶的操作数量 =", count)
|
||||
nums = [i for i in range(n, 0, -1)] # [n, n-1, ..., 2, 1]
|
||||
count: int = bubble_sort(nums)
|
||||
print("平方阶（冒泡排序）的计算操作数量 =", count)
|
||||
print("平方阶（冒泡排序）的操作数量 =", count)
|
||||
|
||||
count: int = exponential(n)
|
||||
print("指数阶（循环实现）的计算操作数量 =", count)
|
||||
print("指数阶（循环实现）的操作数量 =", count)
|
||||
count: int = exp_recur(n)
|
||||
print("指数阶（递归实现）的计算操作数量 =", count)
|
||||
print("指数阶（递归实现）的操作数量 =", count)
|
||||
|
||||
count: int = logarithmic(n)
|
||||
print("对数阶（循环实现）的计算操作数量 =", count)
|
||||
print("对数阶（循环实现）的操作数量 =", count)
|
||||
count: int = log_recur(n)
|
||||
print("对数阶（递归实现）的计算操作数量 =", count)
|
||||
print("对数阶（递归实现）的操作数量 =", count)
|
||||
|
||||
count: int = linear_log_recur(n)
|
||||
print("线性对数阶（递归实现）的计算操作数量 =", count)
|
||||
print("线性对数阶（递归实现）的操作数量 =", count)
|
||||
|
||||
count: int = factorial_recur(n)
|
||||
print("阶乘阶（递归实现）的计算操作数量 =", count)
|
||||
print("阶乘阶（递归实现）的操作数量 =", count)
|
||||
|
||||
@ -61,7 +61,7 @@ class MaxHeap:
|
||||
while True:
|
||||
# 获取节点 i 的父节点
|
||||
p = self.parent(i)
|
||||
# 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
# 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if p < 0 or self.max_heap[i] <= self.max_heap[p]:
|
||||
break
|
||||
# 交换两节点
|
||||
@ -92,7 +92,7 @@ class MaxHeap:
|
||||
ma = l
|
||||
if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
|
||||
ma = r
|
||||
# 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
# 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i:
|
||||
break
|
||||
# 交换两节点
|
||||
|
||||
@ -11,7 +11,7 @@ def binary_search(nums: list[int], target: int) -> int:
|
||||
i, j = 0, len(nums) - 1
|
||||
# 循环，当搜索区间为空时跳出（当 i > j 时为空）
|
||||
while i <= j:
|
||||
# 理论上 Python 的数字可以无限大（取决于内存大小），无需考虑大数越界问题
|
||||
# 理论上 Python 的数字可以无限大（取决于内存大小），无须考虑大数越界问题
|
||||
m = (i + j) // 2 # 计算中点索引 m
|
||||
if nums[m] < target:
|
||||
i = m + 1 # 此情况说明 target 在区间 [m+1, j] 中
|
||||
|
||||
@ -16,7 +16,7 @@ def sift_down(nums: list[int], n: int, i: int):
|
||||
ma = l
|
||||
if r < n and nums[r] > nums[ma]:
|
||||
ma = r
|
||||
# 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
# 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i:
|
||||
break
|
||||
# 交换两节点
|
||||
|
||||
@ -85,7 +85,7 @@ class AVLTree:
|
||||
# 先右旋后左旋
|
||||
node.right = self.__right_rotate(node.right)
|
||||
return self.__left_rotate(node)
|
||||
# 平衡树，无需旋转，直接返回
|
||||
# 平衡树，无须旋转，直接返回
|
||||
return node
|
||||
|
||||
def insert(self, val):
|
||||
|
||||
@ -139,32 +139,32 @@ fn main() {
|
||||
println!("输入数据大小 n = {}", n);
|
||||
|
||||
let mut count = constant(n);
|
||||
println!("常数阶的计算操作数量 = {}", count);
|
||||
println!("常数阶的操作数量 = {}", count);
|
||||
|
||||
count = linear(n);
|
||||
println!("线性阶的计算操作数量 = {}", count);
|
||||
println!("线性阶的操作数量 = {}", count);
|
||||
count = array_traversal(&vec![0; n as usize]);
|
||||
println!("线性阶（遍历数组）的计算操作数量 = {}", count);
|
||||
println!("线性阶（遍历数组）的操作数量 = {}", count);
|
||||
|
||||
count = quadratic(n);
|
||||
println!("平方阶的计算操作数量 = {}", count);
|
||||
println!("平方阶的操作数量 = {}", count);
|
||||
let mut nums = (1..=n).rev().collect::<Vec<_>>(); // [n,n-1,...,2,1]
|
||||
count = bubble_sort(&mut nums);
|
||||
println!("平方阶（冒泡排序）的计算操作数量 = {}", count);
|
||||
println!("平方阶（冒泡排序）的操作数量 = {}", count);
|
||||
|
||||
count = exponential(n);
|
||||
println!("指数阶（循环实现）的计算操作数量 = {}", count);
|
||||
println!("指数阶（循环实现）的操作数量 = {}", count);
|
||||
count = exp_recur(n);
|
||||
println!("指数阶（递归实现）的计算操作数量 = {}", count);
|
||||
println!("指数阶（递归实现）的操作数量 = {}", count);
|
||||
|
||||
count = logarithmic(n as f32);
|
||||
println!("对数阶（循环实现）的计算操作数量 = {}", count);
|
||||
println!("对数阶（循环实现）的操作数量 = {}", count);
|
||||
count = log_recur(n as f32);
|
||||
println!("对数阶（递归实现）的计算操作数量 = {}", count);
|
||||
println!("对数阶（递归实现）的操作数量 = {}", count);
|
||||
|
||||
count = linear_log_recur(n as f32);
|
||||
println!("线性对数阶（递归实现）的计算操作数量 = {}", count);
|
||||
println!("线性对数阶（递归实现）的操作数量 = {}", count);
|
||||
|
||||
count = factorial_recur(n);
|
||||
println!("阶乘阶（递归实现）的计算操作数量 = {}", count);
|
||||
println!("阶乘阶（递归实现）的操作数量 = {}", count);
|
||||
}
|
||||
|
||||
@ -8,7 +8,7 @@ include!("../include/include.rs");
|
||||
|
||||
/* 大顶堆 */
|
||||
struct MaxHeap {
|
||||
// 使用 vector 而非数组，这样无需考虑扩容问题
|
||||
// 使用 vector 而非数组，这样无须考虑扩容问题
|
||||
max_heap: Vec<i32>,
|
||||
}
|
||||
|
||||
@ -76,7 +76,7 @@ impl MaxHeap {
|
||||
}
|
||||
// 获取节点 i 的父节点
|
||||
let p = Self::parent(i);
|
||||
// 当“节点无需修复”时，结束堆化
|
||||
// 当“节点无须修复”时，结束堆化
|
||||
if self.max_heap[i] <= self.max_heap[p] {
|
||||
break;
|
||||
}
|
||||
@ -114,7 +114,7 @@ impl MaxHeap {
|
||||
if r < self.size() && self.max_heap[r] > self.max_heap[ma] {
|
||||
ma = r;
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@ fn sift_down(nums: &mut [i32], n: usize, mut i: usize) {
|
||||
if r < n && nums[r] > nums[ma] {
|
||||
ma = r;
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -123,7 +123,7 @@ impl AVLTree {
|
||||
Self::left_rotate(Some(node))
|
||||
}
|
||||
} else {
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
node
|
||||
}
|
||||
}
|
||||
|
||||
@ -140,33 +140,33 @@ enum TimeComplexity {
|
||||
print("输入数据大小 n = \(n)")
|
||||
|
||||
var count = constant(n: n)
|
||||
print("常数阶的计算操作数量 = \(count)")
|
||||
print("常数阶的操作数量 = \(count)")
|
||||
|
||||
count = linear(n: n)
|
||||
print("线性阶的计算操作数量 = \(count)")
|
||||
print("线性阶的操作数量 = \(count)")
|
||||
count = arrayTraversal(nums: Array(repeating: 0, count: n))
|
||||
print("线性阶（遍历数组）的计算操作数量 = \(count)")
|
||||
print("线性阶（遍历数组）的操作数量 = \(count)")
|
||||
|
||||
count = quadratic(n: n)
|
||||
print("平方阶的计算操作数量 = \(count)")
|
||||
print("平方阶的操作数量 = \(count)")
|
||||
var nums = Array(stride(from: n, to: 0, by: -1)) // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums: &nums)
|
||||
print("平方阶（冒泡排序）的计算操作数量 = \(count)")
|
||||
print("平方阶（冒泡排序）的操作数量 = \(count)")
|
||||
|
||||
count = exponential(n: n)
|
||||
print("指数阶（循环实现）的计算操作数量 = \(count)")
|
||||
print("指数阶（循环实现）的操作数量 = \(count)")
|
||||
count = expRecur(n: n)
|
||||
print("指数阶（递归实现）的计算操作数量 = \(count)")
|
||||
print("指数阶（递归实现）的操作数量 = \(count)")
|
||||
|
||||
count = logarithmic(n: Double(n))
|
||||
print("对数阶（循环实现）的计算操作数量 = \(count)")
|
||||
print("对数阶（循环实现）的操作数量 = \(count)")
|
||||
count = logRecur(n: Double(n))
|
||||
print("对数阶（递归实现）的计算操作数量 = \(count)")
|
||||
print("对数阶（递归实现）的操作数量 = \(count)")
|
||||
|
||||
count = linearLogRecur(n: Double(n))
|
||||
print("线性对数阶（递归实现）的计算操作数量 = \(count)")
|
||||
print("线性对数阶（递归实现）的操作数量 = \(count)")
|
||||
|
||||
count = factorialRecur(n: n)
|
||||
print("阶乘阶（递归实现）的计算操作数量 = \(count)")
|
||||
print("阶乘阶（递归实现）的操作数量 = \(count)")
|
||||
}
|
||||
}
|
||||
|
||||
@ -69,7 +69,7 @@ class MaxHeap {
|
||||
while true {
|
||||
// 获取节点 i 的父节点
|
||||
let p = parent(i: i)
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if p < 0 || maxHeap[i] <= maxHeap[p] {
|
||||
break
|
||||
}
|
||||
@ -110,7 +110,7 @@ class MaxHeap {
|
||||
if r < size(), maxHeap[r] > maxHeap[ma] {
|
||||
ma = r
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i {
|
||||
break
|
||||
}
|
||||
|
||||
@ -18,7 +18,7 @@ func siftDown(nums: inout [Int], n: Int, i: Int) {
|
||||
if r < n, nums[r] > nums[ma] {
|
||||
ma = r
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if ma == i {
|
||||
break
|
||||
}
|
||||
|
||||
@ -84,7 +84,7 @@ class AVLTree {
|
||||
return leftRotate(node: node)
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node
|
||||
}
|
||||
|
||||
|
||||
@ -124,34 +124,34 @@ const n = 8;
|
||||
console.log('输入数据大小 n = ' + n);
|
||||
|
||||
let count = constant(n);
|
||||
console.log('常数阶的计算操作数量 = ' + count);
|
||||
console.log('常数阶的操作数量 = ' + count);
|
||||
|
||||
count = linear(n);
|
||||
console.log('线性阶的计算操作数量 = ' + count);
|
||||
console.log('线性阶的操作数量 = ' + count);
|
||||
count = arrayTraversal(new Array(n));
|
||||
console.log('线性阶（遍历数组）的计算操作数量 = ' + count);
|
||||
console.log('线性阶（遍历数组）的操作数量 = ' + count);
|
||||
|
||||
count = quadratic(n);
|
||||
console.log('平方阶的计算操作数量 = ' + count);
|
||||
console.log('平方阶的操作数量 = ' + count);
|
||||
var nums = new Array(n);
|
||||
for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums);
|
||||
console.log('平方阶（冒泡排序）的计算操作数量 = ' + count);
|
||||
console.log('平方阶（冒泡排序）的操作数量 = ' + count);
|
||||
|
||||
count = exponential(n);
|
||||
console.log('指数阶（循环实现）的计算操作数量 = ' + count);
|
||||
console.log('指数阶（循环实现）的操作数量 = ' + count);
|
||||
count = expRecur(n);
|
||||
console.log('指数阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('指数阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
count = logarithmic(n);
|
||||
console.log('对数阶（循环实现）的计算操作数量 = ' + count);
|
||||
console.log('对数阶（循环实现）的操作数量 = ' + count);
|
||||
count = logRecur(n);
|
||||
console.log('对数阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('对数阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
count = linearLogRecur(n);
|
||||
console.log('线性对数阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('线性对数阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
count = factorialRecur(n);
|
||||
console.log('阶乘阶（递归实现）的计算操作数量 = ' + count);
|
||||
console.log('阶乘阶（递归实现）的操作数量 = ' + count);
|
||||
|
||||
export {};
|
||||
|
||||
@ -69,7 +69,7 @@ class MaxHeap {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
const p = this.parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;
|
||||
// 交换两节点
|
||||
this.swap(i, p);
|
||||
@ -101,7 +101,7 @@ class MaxHeap {
|
||||
let ma = i;
|
||||
if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;
|
||||
if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma === i) break;
|
||||
// 交换两节点
|
||||
this.swap(i, ma);
|
||||
|
||||
@ -17,7 +17,7 @@ function siftDown(nums: number[], n: number, i: number): void {
|
||||
if (r < n && nums[r] > nums[ma]) {
|
||||
ma = r;
|
||||
}
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma === i) {
|
||||
break;
|
||||
}
|
||||
|
||||
@ -90,7 +90,7 @@ class AVLTree {
|
||||
return this.leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -143,37 +143,37 @@ pub fn main() !void {
|
||||
std.debug.print("输入数据大小 n = {}\n", .{n});
|
||||
|
||||
var count = constant(n);
|
||||
std.debug.print("常数阶的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("常数阶的操作数量 = {}\n", .{count});
|
||||
|
||||
count = linear(n);
|
||||
std.debug.print("线性阶的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("线性阶的操作数量 = {}\n", .{count});
|
||||
var nums = [_]i32{0}**n;
|
||||
count = arrayTraversal(&nums);
|
||||
std.debug.print("线性阶（遍历数组）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("线性阶（遍历数组）的操作数量 = {}\n", .{count});
|
||||
|
||||
count = quadratic(n);
|
||||
std.debug.print("平方阶的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("平方阶的操作数量 = {}\n", .{count});
|
||||
for (&nums, 0..) |*num, i| {
|
||||
num.* = n - @as(i32, @intCast(i)); // [n,n-1,...,2,1]
|
||||
}
|
||||
count = bubbleSort(&nums);
|
||||
std.debug.print("平方阶（冒泡排序）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("平方阶（冒泡排序）的操作数量 = {}\n", .{count});
|
||||
|
||||
count = exponential(n);
|
||||
std.debug.print("指数阶（循环实现）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("指数阶（循环实现）的操作数量 = {}\n", .{count});
|
||||
count = expRecur(n);
|
||||
std.debug.print("指数阶（递归实现）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("指数阶（递归实现）的操作数量 = {}\n", .{count});
|
||||
|
||||
count = logarithmic(@as(f32, n));
|
||||
std.debug.print("对数阶（循环实现）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("对数阶（循环实现）的操作数量 = {}\n", .{count});
|
||||
count = logRecur(@as(f32, n));
|
||||
std.debug.print("对数阶（递归实现）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("对数阶（递归实现）的操作数量 = {}\n", .{count});
|
||||
|
||||
count = linearLogRecur(@as(f32, n));
|
||||
std.debug.print("线性对数阶（递归实现）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("线性对数阶（递归实现）的操作数量 = {}\n", .{count});
|
||||
|
||||
count = factorialRecur(n);
|
||||
std.debug.print("阶乘阶（递归实现）的计算操作数量 = {}\n", .{count});
|
||||
std.debug.print("阶乘阶（递归实现）的操作数量 = {}\n", .{count});
|
||||
|
||||
_ = try std.io.getStdIn().reader().readByte();
|
||||
}
|
||||
|
||||
@ -10,7 +10,7 @@ pub fn MaxHeap(comptime T: type) type {
|
||||
return struct {
|
||||
const Self = @This();
|
||||
|
||||
max_heap: ?std.ArrayList(T) = null, // 使用列表而非数组，这样无需考虑扩容问题
|
||||
max_heap: ?std.ArrayList(T) = null, // 使用列表而非数组，这样无须考虑扩容问题
|
||||
|
||||
// 构造方法，根据输入列表建堆
|
||||
pub fn init(self: *Self, allocator: std.mem.Allocator, nums: []const T) !void {
|
||||
@ -82,7 +82,7 @@ pub fn MaxHeap(comptime T: type) type {
|
||||
while (true) {
|
||||
// 获取节点 i 的父节点
|
||||
var p = parent(i);
|
||||
// 当“越过根节点”或“节点无需修复”时，结束堆化
|
||||
// 当“越过根节点”或“节点无须修复”时，结束堆化
|
||||
if (p < 0 or self.max_heap.?.items[i] <= self.max_heap.?.items[p]) break;
|
||||
// 交换两节点
|
||||
try self.swap(i, p);
|
||||
@ -115,7 +115,7 @@ pub fn MaxHeap(comptime T: type) type {
|
||||
var ma = i;
|
||||
if (l < self.size() and self.max_heap.?.items[l] > self.max_heap.?.items[ma]) ma = l;
|
||||
if (r < self.size() and self.max_heap.?.items[r] > self.max_heap.?.items[ma]) ma = r;
|
||||
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
|
||||
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
|
||||
if (ma == i) break;
|
||||
// 交换两节点
|
||||
try self.swap(i, ma);
|
||||
|
||||
@ -103,7 +103,7 @@ pub fn AVLTree(comptime T: type) type {
|
||||
return self.leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡树，无需旋转，直接返回
|
||||
// 平衡树，无须旋转，直接返回
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
## C/C++ 环境
|
||||
|
||||
1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无需安装。
|
||||
1. Windows 系统需要安装 [MinGW](https://sourceforge.net/projects/mingw-w64/files/)（[配置教程](https://blog.csdn.net/qq_33698226/article/details/129031241)），MacOS 自带 Clang 无须安装。
|
||||
2. 在 VSCode 的插件市场中搜索 `c++` ，安装 C/C++ Extension Pack 。
|
||||
3. （可选）打开 Settings 页面，搜索 `Clang_format_fallback Style` 代码格式化选项，设置为 `{ BasedOnStyle: Microsoft, BreakBeforeBraces: Attach }` 。
|
||||
|
||||
|
||||
@ -283,7 +283,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
|
||||
同理，如果我们想要删除索引 $i$ 处的元素，则需要把索引 $i$ 之后的元素都向前移动一位。
|
||||
|
||||
请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无需特意去修改它。
|
||||
请注意，删除元素完成后，原先末尾的元素变得“无意义”了，所以我们无须特意去修改它。
|
||||
|
||||
|
||||
|
||||
@ -601,7 +601,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
|
||||
|
||||
数组存储在连续的内存空间内，且元素类型相同。这包含丰富的先验信息，系统可以利用这些信息来优化操作和运行效率，包括：
|
||||
|
||||
- **空间效率高**: 数组为数据分配了连续的内存块，无需额外的结构开销。
|
||||
- **空间效率高**: 数组为数据分配了连续的内存块，无须额外的结构开销。
|
||||
- **支持随机访问**: 数组允许在 $O(1)$ 时间内访问任何元素。
|
||||
- **缓存局部性**: 当访问数组元素时，计算机不仅会加载它，还会缓存其周围的其他数据，从而借助高速缓存来提升后续操作的执行速度。
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
内存空间是所有程序的公共资源，在一个复杂的系统运行环境下，空闲的内存空间可能散落在内存各处。我们知道，存储数组的内存空间必须是连续的，而当数组非常大时，内存可能无法提供如此大的连续空间。此时链表的灵活性优势就体现出来了。
|
||||
|
||||
「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无需连续的。
|
||||
「链表 Linked List」是一种线性数据结构，其中的每个元素都是一个节点对象，各个节点通过“引用”相连接。引用记录了下一个节点的内存地址，我们可以通过它从当前节点访问到下一个节点。这意味着链表的各个节点可以被分散存储在内存各处，它们的内存地址是无须连续的。
|
||||
|
||||
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
**数组长度不可变导致实用性降低**。在实际中，我们可能事先无法确定需要存储多少数据，这使数组长度的选择变得困难。若长度过小，需要在持续添加数据时频繁扩容数组；若长度过大，则会造成内存空间的浪费。
|
||||
|
||||
为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无需担心超过容量限制。
|
||||
为解决此问题，出现了一种被称为「动态数组 Dynamic Array」的数据结构，即长度可变的数组，也常被称为「列表 List」。列表基于数组实现，继承了数组的优点，并且可以在程序运行过程中动态扩容。我们可以在列表中自由地添加元素，而无须担心超过容量限制。
|
||||
|
||||
## 列表常用操作
|
||||
|
||||
|
||||
@ -55,7 +55,7 @@
|
||||
|
||||
假如把列表元素换成链表节点 `n = [n1, n2, n3, n4, n5]` ，通常情况下这五个节点对象也是被分散存储在内存各处的。然而，给定一个列表索引，我们仍然可以在 $O(1)$ 时间内获取到节点内存地址，从而访问到对应的节点。这是因为数组中存储的是节点的引用，而非节点本身。
|
||||
|
||||
与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无需连续的。
|
||||
与许多语言不同的是，在 Python 中数字也被包装为对象，列表中存储的不是数字本身，而是对数字的引用。因此，我们会发现两个数组中的相同数字拥有同一个 id ，并且这些数字的内存地址是无须连续的。
|
||||
|
||||
!!! question "C++ STL 里面的 std::list 已经实现了双向链表，但好像一些算法的书上都不怎么直接用这个，是不是有什么局限性呢?"
|
||||
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
|
||||
类似于全排列问题，我们可以把子集的生成过程想象成一系列选择的结果，并在选择过程中实时更新“元素和”，当元素和等于 `target` 时，就将子集记录至结果列表。
|
||||
|
||||
而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无需借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
|
||||
而与全排列问题不同的是，**本题集合中的元素可以被无限次选取**，因此无须借助 `selected` 布尔列表来记录元素是否已被选择。我们可以对全排列代码进行小幅修改，初步得到解题代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
||||
@ -8,6 +8,6 @@
|
||||
|
||||
!!! abstract
|
||||
|
||||
复杂度犹如浩瀚的算法宇宙中的指南针。
|
||||
复杂度犹如浩瀚的算法宇宙中的时空向导。
|
||||
|
||||
它引导我们在时间与空间的维度上深入探索，寻找更优雅的解决方案。
|
||||
它带领我们在时间与空间这两个维度上深入探索，寻找更优雅的解决方案。
|
||||
|
||||
@ -1,11 +1,11 @@
|
||||
# 算法效率评估
|
||||
|
||||
在算法设计中，我们先后追求以下两个层面的目标：
|
||||
在算法设计中，我们先后追求以下两个层面的目标。
|
||||
|
||||
1. **找到问题解法**：算法需要在规定的输入范围内，可靠地求得问题的正确解。
|
||||
2. **寻求最优解法**：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
|
||||
|
||||
因此在能够解决问题的前提下，算法效率成为主要的评价维度，包括：
|
||||
因此，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度。
|
||||
|
||||
- **时间效率**：算法运行速度的快慢。
|
||||
- **空间效率**：算法占用内存空间的大小。
|
||||
@ -18,28 +18,28 @@
|
||||
|
||||
假设我们现在有算法 `A` 和算法 `B` ，它们都能解决同一问题，现在需要对比这两个算法的效率。最直接的方法是找一台计算机，运行这两个算法，并监控记录它们的运行时间和内存占用情况。这种评估方式能够反映真实情况，但也存在较大局限性。
|
||||
|
||||
**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
|
||||
一方面，**难以排除测试环境的干扰因素**。硬件配置会影响算法的性能表现。比如在某台计算机中，算法 `A` 的运行时间比算法 `B` 短；但在另一台配置不同的计算机中，我们可能得到相反的测试结果。这意味着我们需要在各种机器上进行测试，统计平均效率，而这是不现实的。
|
||||
|
||||
**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。
|
||||
另一方面，**展开完整测试非常耗费资源**。随着输入数据量的变化，算法会表现出不同的效率。例如，在输入数据量较小时，算法 `A` 的运行时间比算法 `B` 更少；而输入数据量较大时，测试结果可能恰恰相反。因此，为了得到有说服力的结论，我们需要测试各种规模的输入数据，而这样需要耗费大量的计算资源。
|
||||
|
||||
## 理论估算
|
||||
|
||||
由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 Asymptotic Complexity Analysis」，简称为「复杂度分析」。
|
||||
由于实际测试具有较大的局限性，我们可以考虑仅通过一些计算来评估算法的效率。这种估算方法被称为「渐近复杂度分析 asymptotic complexity analysis」，简称「复杂度分析」。
|
||||
|
||||
复杂度分析评估的是算法执行所需的时间和空间资源。**它被表示为一个函数，描述了随着输入数据大小的增加，算法所需时间（空间）的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解：
|
||||
复杂度分析评估的是算法运行所需的时间和空间资源，**它描述了随着输入数据大小的增加，算法所需时间（空间）的增长趋势**。这个定义有些拗口，我们可以将其分为三个重点来理解。
|
||||
|
||||
1. “时间（空间）”分别对应「时间复杂度 Time Complexity」和「空间复杂度 Space Complexity」。
|
||||
1. “时间和空间资源”分别对应「时间复杂度 time complexity」和「空间复杂度 space complexity」。
|
||||
2. “随着输入数据大小的增加”意味着复杂度反映了算法运行效率与输入数据体量之间的关系。
|
||||
3. “增长趋势”表示复杂度分析关注的是算法时间与空间的增长趋势，而非具体的运行时间或占用空间。
|
||||
|
||||
**复杂度分析克服了实际测试方法的弊端**。首先，它独立于测试环境，分析结果适用于所有运行平台。其次，它可以体现不同数据量下的算法效率，尤其是在大数据量下的算法性能。
|
||||
|
||||
如果你对复杂度分析的概念仍感到困惑，无需担心，我们会在后续章节详细介绍。
|
||||
如果你对复杂度分析的概念仍感到困惑，无须担心，我们会在后续章节中详细介绍。
|
||||
|
||||
## 复杂度的重要性
|
||||
|
||||
复杂度分析为我们提供了一把评估算法效率的“标尺”，帮助我们衡量了执行某个算法所需的时间和空间资源，并使我们能够对比不同算法之间的效率。
|
||||
|
||||
复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第一章的内容。
|
||||
复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度看，复杂度分析可能不太适合作为第 1 章的内容。
|
||||
|
||||
然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，能够完成简单算法的复杂度分析**。
|
||||
然而，当我们讨论某个数据结构或算法的特点时，难以避免要分析其运行速度和空间使用情况。因此，在深入学习数据结构与算法之前，**建议你先对复杂度建立初步的了解，以便能够完成简单算法的复杂度分析**。
|
||||
|
||||
@ -1,24 +1,24 @@
|
||||
# 空间复杂度
|
||||
|
||||
「空间复杂度 Space Complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
|
||||
「空间复杂度 space complexity」用于衡量算法占用内存空间随着数据量变大时的增长趋势。这个概念与时间复杂度非常类似，只需将“运行时间”替换为“占用内存空间”。
|
||||
|
||||
## 算法相关空间
|
||||
|
||||
算法运行过程中使用的内存空间主要包括以下几种：
|
||||
算法在运行过程中使用的内存空间主要包括以下几种。
|
||||
|
||||
- **输入空间**：用于存储算法的输入数据。
|
||||
- **暂存空间**：用于存储算法运行过程中的变量、对象、函数上下文等数据。
|
||||
- **暂存空间**：用于存储算法在运行过程中的变量、对象、函数上下文等数据。
|
||||
- **输出空间**：用于存储算法的输出数据。
|
||||
|
||||
一般情况下，空间复杂度的统计范围是“暂存空间”加上“输出空间”。
|
||||
|
||||
暂存空间可以进一步划分为三个部分：
|
||||
暂存空间可以进一步划分为三个部分。
|
||||
|
||||
- **暂存数据**：用于保存算法运行过程中的各种常量、变量、对象等。
|
||||
- **栈帧空间**：用于保存调用函数的上下文数据。系统在每次调用函数时都会在栈顶部创建一个栈帧，函数返回后，栈帧空间会被释放。
|
||||
- **指令空间**：用于保存编译后的程序指令，在实际统计中通常忽略不计。
|
||||
|
||||
因此在分析一段程序的空间复杂度时，**我们通常统计暂存数据、输出数据、栈帧空间三部分**。
|
||||
在分析一段程序的空间复杂度时，**我们通常统计暂存数据、栈帧空间和输出数据三部分**。
|
||||
|
||||
|
||||
|
||||
@ -288,7 +288,7 @@
|
||||
|
||||
## 推算方法
|
||||
|
||||
空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“计算操作数量”转为“使用空间大小”。
|
||||
空间复杂度的推算方法与时间复杂度大致相同，只需将统计对象从“操作数量”转为“使用空间大小”。
|
||||
|
||||
而与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**。这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
|
||||
|
||||
@ -426,7 +426,7 @@
|
||||
|
||||
```
|
||||
|
||||
**在递归函数中，需要注意统计栈帧空间**。例如以下代码：
|
||||
**在递归函数中，需要注意统计栈帧空间**。例如在以下代码中：
|
||||
|
||||
- 函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。
|
||||
- 递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
|
||||
@ -652,7 +652,7 @@
|
||||
|
||||
## 常见类型
|
||||
|
||||
设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）：
|
||||
设输入数据大小为 $n$ ，下图展示了常见的空间复杂度类型（从低到高排列）。
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
@ -661,17 +661,17 @@ O(1) < O(\log n) < O(n) < O(n^2) < O(2^n) \newline
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
|
||||
|
||||
|
||||
!!! tip
|
||||
|
||||
部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学习完后面章节后再来复习。
|
||||
部分示例代码需要一些前置知识，包括数组、链表、二叉树、递归算法等。如果你遇到看不懂的地方，可以在学完后面章节后再来复习。
|
||||
|
||||
### 常数阶 $O(1)$
|
||||
|
||||
常数阶常见于数量与输入数据大小 $n$ 无关的常量、变量、对象。
|
||||
|
||||
需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ 。
|
||||
需要注意的是，在循环中初始化变量或调用函数而占用的内存，在进入下一循环后就会被释放，即不会累积占用空间，空间复杂度仍为 $O(1)$ ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -771,7 +771,7 @@ $$
|
||||
|
||||
### 线性阶 $O(n)$
|
||||
|
||||
线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
|
||||
线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -847,7 +847,7 @@ $$
|
||||
[class]{}-[func]{linear}
|
||||
```
|
||||
|
||||
以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
|
||||
以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -925,7 +925,7 @@ $$
|
||||
|
||||
### 平方阶 $O(n^2)$
|
||||
|
||||
平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系。
|
||||
平方阶常见于矩阵和图，元素数量与 $n$ 成平方关系：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1077,7 +1077,7 @@ $$
|
||||
|
||||
### 指数阶 $O(2^n)$
|
||||
|
||||
指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间。
|
||||
指数阶常见于二叉树。高度为 $n$ 的「满二叉树」的节点数量为 $2^n - 1$ ，占用 $O(2^n)$ 空间：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1157,9 +1157,9 @@ $$
|
||||
|
||||
对数阶常见于分治算法和数据类型转换等。
|
||||
|
||||
例如“归并排序”算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。
|
||||
例如归并排序算法，输入长度为 $n$ 的数组，每轮递归将数组从中点划分为两半，形成高度为 $\log n$ 的递归树，使用 $O(\log n)$ 栈帧空间。
|
||||
|
||||
再例如“数字转化为字符串”，输入任意正整数 $n$ ，它的位数为 $\log_{10} n$ ，即对应字符串长度为 $\log_{10} n$ ，因此空间复杂度为 $O(\log_{10} n) = O(\log n)$ 。
|
||||
再例如将数字转化为字符串，输入任意正整数 $n$ ，它的位数为 $\log_{10} n + 1$ ，即对应字符串长度为 $\log_{10} n + 1$ ，因此空间复杂度为 $O(\log_{10} n + 1) = O(\log n)$ 。
|
||||
|
||||
## 权衡时间与空间
|
||||
|
||||
@ -1167,4 +1167,4 @@ $$
|
||||
|
||||
**降低时间复杂度通常需要以提升空间复杂度为代价，反之亦然**。我们将牺牲内存空间来提升算法运行速度的思路称为“以空间换时间”；反之，则称为“以时间换空间”。
|
||||
|
||||
选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此以空间换时间通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。
|
||||
选择哪种思路取决于我们更看重哪个方面。在大多数情况下，时间比空间更宝贵，因此“以空间换时间”通常是更常用的策略。当然，在数据量很大的情况下，控制空间复杂度也是非常重要的。
|
||||
|
||||
@ -2,45 +2,45 @@
|
||||
|
||||
**算法效率评估**
|
||||
|
||||
- 时间效率和空间效率是评价算法性能的两个关键维度。
|
||||
- 时间效率和空间效率是衡量算法优劣的两个主要评价指标。
|
||||
- 我们可以通过实际测试来评估算法效率，但难以消除测试环境的影响，且会耗费大量计算资源。
|
||||
- 复杂度分析可以克服实际测试的弊端，分析结果适用于所有运行平台，并且能够揭示算法在不同数据规模下的效率。
|
||||
|
||||
**时间复杂度**
|
||||
|
||||
- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
|
||||
- 最差时间复杂度使用大 $O$ 符号表示，即函数渐近上界，反映当 $n$ 趋向正无穷时，$T(n)$ 的增长级别。
|
||||
- 推算时间复杂度分为两步，首先统计计算操作数量，然后判断渐近上界。
|
||||
- 常见时间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n \log n)$ , $O(n^2)$ , $O(2^n)$ , $O(n!)$ 等。
|
||||
- 时间复杂度用于衡量算法运行时间随数据量增长的趋势，可以有效评估算法效率，但在某些情况下可能失效，如在输入的数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣。
|
||||
- 最差时间复杂度使用大 $O$ 符号表示，对应函数渐近上界，反映当 $n$ 趋向正无穷时，操作数量 $T(n)$ 的增长级别。
|
||||
- 推算时间复杂度分为两步，首先统计操作数量，然后判断渐近上界。
|
||||
- 常见时间复杂度从小到大排列有 $O(1)$ 、$O(\log n)$ 、$O(n)$ 、$O(n \log n)$ 、$O(n^2)$ 、$O(2^n)$ 、$O(n!)$ 等。
|
||||
- 某些算法的时间复杂度非固定，而是与输入数据的分布有关。时间复杂度分为最差、最佳、平均时间复杂度，最佳时间复杂度几乎不用，因为输入数据一般需要满足严格条件才能达到最佳情况。
|
||||
- 平均时间复杂度反映算法在随机数据输入下的运行效率，最接近实际应用中的算法性能。计算平均时间复杂度需要统计输入数据分布以及综合后的数学期望。
|
||||
|
||||
**空间复杂度**
|
||||
|
||||
- 类似于时间复杂度，空间复杂度用于衡量算法占用空间随数据量增长的趋势。
|
||||
- 空间复杂度的作用类似于时间复杂度，用于衡量算法占用空间随数据量增长的趋势。
|
||||
- 算法运行过程中的相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间通常仅在递归函数中影响空间复杂度。
|
||||
- 我们通常只关注最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。
|
||||
- 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 等。
|
||||
- 常见空间复杂度从小到大排列有 $O(1)$ 、$O(\log n)$ 、$O(n)$ 、$O(n^2)$ 、$O(2^n)$ 等。
|
||||
|
||||
## Q & A
|
||||
|
||||
!!! question "尾递归的空间复杂度是 $O(1)$ 吗？"
|
||||
|
||||
理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java, Python, C++, Go, C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。
|
||||
理论上，尾递归函数的空间复杂度可以被优化至 $O(1)$ 。不过绝大多数编程语言（例如 Java 、Python 、C++ 、Go 、C# 等）都不支持自动优化尾递归，因此通常认为空间复杂度是 $O(n)$ 。
|
||||
|
||||
!!! question "函数和方法这两个术语的区别是什么？"
|
||||
|
||||
函数（function）可以独立被执行，所有参数都以显式传递。方法（method）与一个对象关联，方法被隐式传递给调用它的对象，方法能够对类的实例中包含的数据进行操作。
|
||||
函数（function）可以被独立执行，所有参数都以显式传递。方法（method）与一个对象关联，被隐式传递给调用它的对象，能够对类的实例中包含的数据进行操作。
|
||||
|
||||
以几个常见的编程语言为例：
|
||||
下面以几个常见的编程语言来说明。
|
||||
|
||||
- C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。
|
||||
- Java, C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
|
||||
- C++, Python 既支持过程式编程（函数）也支持面向对象编程（方法）。
|
||||
- C 语言是过程式编程语言，没有面向对象的概念，所以只有函数。但我们可以通过创建结构体（struct）来模拟面向对象编程，与结构体相关联的函数就相当于其他语言中的方法。
|
||||
- Java 和 C# 是面向对象的编程语言，代码块（方法）通常都是作为某个类的一部分。静态方法的行为类似于函数，因为它被绑定在类上，不能访问特定的实例变量。
|
||||
- C++ 和 Python 既支持过程式编程（函数），也支持面向对象编程（方法）。
|
||||
|
||||
!!! question "图片“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
|
||||
!!! question "图“空间复杂度的常见类型”反映的是否是占用空间的绝对大小？"
|
||||
|
||||
不是，该图片展示的是空间复杂度，其反映的是即增长趋势，而不是占用空间的绝对大小。
|
||||
不是，该图片展示的是空间复杂度，其反映的是增长趋势，而不是占用空间的绝对大小。
|
||||
|
||||
假设取 $n = 8$ ，你可能会发现每条曲线的值与函数对应不上。这是因为每条曲线都包含一个常数项，用于将取值范围压缩到一个视觉舒适的范围内。
|
||||
|
||||
|
||||
@ -3,14 +3,10 @@
|
||||
运行时间可以直观且准确地反映算法的效率。如果我们想要准确预估一段代码的运行时间，应该如何操作呢？
|
||||
|
||||
1. **确定运行平台**，包括硬件配置、编程语言、系统环境等，这些因素都会影响代码的运行效率。
|
||||
2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作需要 5 ns 等。
|
||||
2. **评估各种计算操作所需的运行时间**，例如加法操作 `+` 需要 1 ns，乘法操作 `*` 需要 10 ns，打印操作 `print()` 需要 5 ns 等。
|
||||
3. **统计代码中所有的计算操作**，并将所有操作的执行时间求和，从而得到运行时间。
|
||||
|
||||
例如以下代码，输入数据大小为 $n$ 。根据以上方法，可以得到算法运行时间为 $6n + 12$ ns 。
|
||||
|
||||
$$
|
||||
1 + 1 + 10 + (1 + 5) \times n = 6n + 12
|
||||
$$
|
||||
例如在以下代码中，输入数据大小为 $n$ ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -181,28 +177,34 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
|
||||
根据以上方法，可以得到算法运行时间为 $6n + 12$ ns ：
|
||||
|
||||
$$
|
||||
1 + 1 + 10 + (1 + 5) \times n = 6n + 12
|
||||
$$
|
||||
|
||||
但实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望将预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
|
||||
|
||||
## 统计时间增长趋势
|
||||
|
||||
「时间复杂度分析」采取了一种不同的方法，其统计的不是算法运行时间，**而是算法运行时间随着数据量变大时的增长趋势**。
|
||||
|
||||
“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` , `B` , `C` 。
|
||||
“时间增长趋势”这个概念比较抽象，我们通过一个例子来加以理解。假设输入数据大小为 $n$ ，给定三个算法函数 `A` 、 `B` 和 `C` ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
```java title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
void algorithm_A(int n) {
|
||||
System.out.println(0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
void algorithm_B(int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
System.out.println(0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
void algorithm_C(int n) {
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
System.out.println(0);
|
||||
@ -213,17 +215,17 @@ $$
|
||||
=== "C++"
|
||||
|
||||
```cpp title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
void algorithm_A(int n) {
|
||||
cout << 0 << endl;
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
void algorithm_B(int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
cout << 0 << endl;
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
void algorithm_C(int n) {
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
cout << 0 << endl;
|
||||
@ -234,14 +236,14 @@ $$
|
||||
=== "Python"
|
||||
|
||||
```python title=""
|
||||
# 算法 A 时间复杂度：常数阶
|
||||
# 算法 A 的时间复杂度：常数阶
|
||||
def algorithm_A(n: int):
|
||||
print(0)
|
||||
# 算法 B 时间复杂度：线性阶
|
||||
# 算法 B 的时间复杂度：线性阶
|
||||
def algorithm_B(n: int):
|
||||
for _ in range(n):
|
||||
print(0)
|
||||
# 算法 C 时间复杂度：常数阶
|
||||
# 算法 C 的时间复杂度：常数阶
|
||||
def algorithm_C(n: int):
|
||||
for _ in range(1000000):
|
||||
print(0)
|
||||
@ -250,17 +252,17 @@ $$
|
||||
=== "Go"
|
||||
|
||||
```go title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
func algorithm_A(n int) {
|
||||
fmt.Println(0)
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
func algorithm_B(n int) {
|
||||
for i := 0; i < n; i++ {
|
||||
fmt.Println(0)
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
func algorithm_C(n int) {
|
||||
for i := 0; i < 1000000; i++ {
|
||||
fmt.Println(0)
|
||||
@ -271,17 +273,17 @@ $$
|
||||
=== "JS"
|
||||
|
||||
```javascript title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
function algorithm_A(n) {
|
||||
console.log(0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
function algorithm_B(n) {
|
||||
for (let i = 0; i < n; i++) {
|
||||
console.log(0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
function algorithm_C(n) {
|
||||
for (let i = 0; i < 1000000; i++) {
|
||||
console.log(0);
|
||||
@ -293,17 +295,17 @@ $$
|
||||
=== "TS"
|
||||
|
||||
```typescript title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
function algorithm_A(n: number): void {
|
||||
console.log(0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
function algorithm_B(n: number): void {
|
||||
for (let i = 0; i < n; i++) {
|
||||
console.log(0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
function algorithm_C(n: number): void {
|
||||
for (let i = 0; i < 1000000; i++) {
|
||||
console.log(0);
|
||||
@ -314,17 +316,17 @@ $$
|
||||
=== "C"
|
||||
|
||||
```c title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
void algorithm_A(int n) {
|
||||
printf("%d", 0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
void algorithm_B(int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
printf("%d", 0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
void algorithm_C(int n) {
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
printf("%d", 0);
|
||||
@ -335,17 +337,17 @@ $$
|
||||
=== "C#"
|
||||
|
||||
```csharp title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
void algorithm_A(int n) {
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
void algorithm_B(int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
Console.WriteLine(0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
void algorithm_C(int n) {
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
Console.WriteLine(0);
|
||||
@ -356,19 +358,19 @@ $$
|
||||
=== "Swift"
|
||||
|
||||
```swift title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
func algorithmA(n: Int) {
|
||||
print(0)
|
||||
}
|
||||
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
func algorithmB(n: Int) {
|
||||
for _ in 0 ..< n {
|
||||
print(0)
|
||||
}
|
||||
}
|
||||
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
func algorithmC(n: Int) {
|
||||
for _ in 0 ..< 1000000 {
|
||||
print(0)
|
||||
@ -385,17 +387,17 @@ $$
|
||||
=== "Dart"
|
||||
|
||||
```dart title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
void algorithmA(int n) {
|
||||
print(0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
void algorithmB(int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
print(0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
void algorithmC(int n) {
|
||||
for (int i = 0; i < 1000000; i++) {
|
||||
print(0);
|
||||
@ -406,17 +408,17 @@ $$
|
||||
=== "Rust"
|
||||
|
||||
```rust title=""
|
||||
// 算法 A 时间复杂度：常数阶
|
||||
// 算法 A 的时间复杂度：常数阶
|
||||
fn algorithm_A(n: i32) {
|
||||
println!("{}", 0);
|
||||
}
|
||||
// 算法 B 时间复杂度：线性阶
|
||||
// 算法 B 的时间复杂度：线性阶
|
||||
fn algorithm_B(n: i32) {
|
||||
for _ in 0..n {
|
||||
println!("{}", 0);
|
||||
}
|
||||
}
|
||||
// 算法 C 时间复杂度：常数阶
|
||||
// 算法 C 的时间复杂度：常数阶
|
||||
fn algorithm_C(n: i32) {
|
||||
for _ in 0..1000000 {
|
||||
println!("{}", 0);
|
||||
@ -430,19 +432,17 @@ $$
|
||||
|
||||
算法 `C` 中的打印操作需要循环 $1000000$ 次，虽然运行时间很长，但它与输入数据大小 $n$ 无关。因此 `C` 的时间复杂度和 `A` 相同，仍为「常数阶」。
|
||||
|
||||
|
||||
|
||||
|
||||
相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？
|
||||
|
||||
**时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
|
||||
|
||||
**时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
|
||||
|
||||
**时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
|
||||
- **时间复杂度能够有效评估算法效率**。例如，算法 `B` 的运行时间呈线性增长，在 $n > 1$ 时比算法 `A` 更慢，在 $n > 1000000$ 时比算法 `C` 更慢。事实上，只要输入数据大小 $n$ 足够大，复杂度为“常数阶”的算法一定优于“线性阶”的算法，这正是时间增长趋势所表达的含义。
|
||||
- **时间复杂度的推算方法更简便**。显然，运行平台和计算操作类型都与算法运行时间的增长趋势无关。因此在时间复杂度分析中，我们可以简单地将所有计算操作的执行时间视为相同的“单位时间”，从而将“计算操作的运行时间的统计”简化为“计算操作的数量的统计”，这样以来估算难度就大大降低了。
|
||||
- **时间复杂度也存在一定的局限性**。例如，尽管算法 `A` 和 `C` 的时间复杂度相同，但实际运行时间差别很大。同样，尽管算法 `B` 的时间复杂度比 `C` 高，但在输入数据大小 $n$ 较小时，算法 `B` 明显优于算法 `C` 。在这些情况下，我们很难仅凭时间复杂度判断算法效率的高低。当然，尽管存在上述问题，复杂度分析仍然是评判算法效率最有效且常用的方法。
|
||||
|
||||
## 函数渐近上界
|
||||
|
||||
给定一个函数 `algorithm()` ：
|
||||
给定一个输入大小为 $n$ 的函数：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -603,15 +603,15 @@ $$
|
||||
}
|
||||
```
|
||||
|
||||
设算法的计算操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
|
||||
设算法的操作数量是一个关于输入数据大小 $n$ 的函数，记为 $T(n)$ ，则以上函数的的操作数量为：
|
||||
|
||||
$$
|
||||
T(n) = 3 + 2n
|
||||
$$
|
||||
|
||||
$T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时间复杂度是线性阶。
|
||||
$T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因此它的时间复杂度是线性阶。
|
||||
|
||||
我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
|
||||
我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 big-$O$ notation」，表示函数 $T(n)$ 的「渐近上界 asymptotic upper bound」。
|
||||
|
||||
时间复杂度分析本质上是计算“操作数量函数 $T(n)$”的渐近上界。接下来，我们来看函数渐近上界的数学定义。
|
||||
|
||||
@ -626,25 +626,25 @@ $T(n)$ 是一次函数，说明时间的增长趋势是线性的，因此其时
|
||||
T(n) = O(f(n))
|
||||
$$
|
||||
|
||||
|
||||
如下图所示，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
|
||||
|
||||
也就是说，计算渐近上界就是寻找一个函数 $f(n)$ ，使得当 $n$ 趋向于无穷大时，$T(n)$ 和 $f(n)$ 处于相同的增长级别，仅相差一个常数项 $c$ 的倍数。
|
||||
|
||||
|
||||
## 推算方法
|
||||
|
||||
渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无需担心。因为在实际使用中，我们只需要掌握推算方法，数学意义可以逐渐领悟。
|
||||
渐近上界的数学味儿有点重，如果你感觉没有完全理解，也无须担心。因为在实际使用中，我们只需要掌握推算方法，数学意义就可以逐渐领悟。
|
||||
|
||||
根据定义，确定 $f(n)$ 之后，我们便可得到时间复杂度 $O(f(n))$ 。那么如何确定渐近上界 $f(n)$ 呢？总体分为两步：首先统计操作数量，然后判断渐近上界。
|
||||
|
||||
### 第一步：统计操作数量
|
||||
|
||||
针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧：
|
||||
针对代码，逐行从上到下计算即可。然而，由于上述 $c \cdot f(n)$ 中的常数项 $c$ 可以取任意大小，**因此操作数量 $T(n)$ 中的各种系数、常数项都可以被忽略**。根据此原则，可以总结出以下计数简化技巧。
|
||||
|
||||
1. **忽略 $T(n)$ 中的常数项**。因为它们都与 $n$ 无关，所以对时间复杂度不产生影响。
|
||||
2. **省略所有系数**。例如，循环 $2n$ 次、$5n + 1$ 次等，都可以简化记为 $n$ 次，因为 $n$ 前面的系数对时间复杂度没有影响。
|
||||
3. **循环嵌套时使用乘法**。总操作数量等于外层循环和内层循环操作数量之积，每一层循环依然可以分别套用上述 `1.` 和 `2.` 技巧。
|
||||
|
||||
以下示例展示了使用上述技巧前、后的统计结果。两者推出的时间复杂度相同，即为 $O(n^2)$ 。
|
||||
以下代码与公式分别展示了使用上述技巧前后的统计结果。两者推出的时间复杂度相同，都为 $O(n^2)$ 。
|
||||
|
||||
$$
|
||||
\begin{aligned}
|
||||
@ -872,7 +872,8 @@ $$
|
||||
**时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
|
||||
|
||||
以下表格展示了一些例子，其中一些夸张的值是为了强调“系数无法撼动阶数”这一结论。当 $n$ 趋于无穷大时，这些常数变得无足轻重。
|
||||
<p align="center"> 表：多项式时间复杂度示例 </p>
|
||||
|
||||
<p align="center"> 表：不同操作数量对应的时间复杂度 </p>
|
||||
|
||||
| 操作数量 $T(n)$ | 时间复杂度 $O(f(n))$ |
|
||||
| ---------------------- | -------------------- |
|
||||
@ -893,17 +894,17 @@ O(1) < O(\log n) < O(n) < O(n \log n) < O(n^2) < O(2^n) < O(n!) \newline
|
||||
\end{aligned}
|
||||
$$
|
||||
|
||||
|
||||
|
||||
|
||||
!!! tip
|
||||
|
||||
部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学习完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
|
||||
部分示例代码需要一些预备知识，包括数组、递归等。如果你遇到不理解的部分，可以在学完后面章节后再回顾。现阶段，请先专注于理解时间复杂度的含义和推算方法。
|
||||
|
||||
### 常数阶 $O(1)$
|
||||
|
||||
常数阶的操作数量与输入数据大小 $n$ 无关，即不随着 $n$ 的变化而变化。
|
||||
|
||||
对于以下算法，尽管操作数量 `size` 可能很大，但由于其与数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ 。
|
||||
对于以下算法，尽管操作数量 `size` 可能很大，但由于其与输入数据大小 $n$ 无关，因此时间复杂度仍为 $O(1)$ ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -979,7 +980,7 @@ $$
|
||||
|
||||
### 线性阶 $O(n)$
|
||||
|
||||
线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。
|
||||
线性阶的操作数量相对于输入数据大小 $n$ 以线性级别增长。线性阶通常出现在单层循环中：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1053,7 +1054,7 @@ $$
|
||||
[class]{}-[func]{linear}
|
||||
```
|
||||
|
||||
遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
|
||||
遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1127,11 +1128,11 @@ $$
|
||||
[class]{}-[func]{array_traversal}
|
||||
```
|
||||
|
||||
值得注意的是，**数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
|
||||
值得注意的是，**输入数据大小 $n$ 需根据输入数据的类型来具体确定**。比如在第一个示例中，变量 $n$ 为输入数据大小；在第二个示例中，数组长度 $n$ 为数据大小。
|
||||
|
||||
### 平方阶 $O(n^2)$
|
||||
|
||||
平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
|
||||
平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ ：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1205,9 +1206,11 @@ $$
|
||||
[class]{}-[func]{quadratic}
|
||||
```
|
||||
|
||||
|
||||
下图对比了常数阶、线性阶和平方阶三种时间复杂度。
|
||||
|
||||
以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。
|
||||
|
||||
|
||||
以冒泡排序为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ ：
|
||||
|
||||
$$
|
||||
O((n - 1) \frac{n}{2}) = O(n^2)
|
||||
@ -1287,9 +1290,7 @@ $$
|
||||
|
||||
### 指数阶 $O(2^n)$
|
||||
|
||||
生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。
|
||||
|
||||
以下代码模拟了细胞分裂的过程。
|
||||
生物学的“细胞分裂”是指数阶增长的典型例子：初始状态为 $1$ 个细胞，分裂一轮后变为 $2$ 个，分裂两轮后变为 $4$ 个，以此类推，分裂 $n$ 轮后有 $2^n$ 个细胞。相关代码如下：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1363,9 +1364,11 @@ $$
|
||||
[class]{}-[func]{exponential}
|
||||
```
|
||||
|
||||
下图展示了细胞分裂的过程。
|
||||
|
||||
|
||||
|
||||
在实际算法中，指数阶常出现于递归函数。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止。
|
||||
在实际算法中，指数阶常出现于递归函数中。例如以下代码，其递归地一分为二，经过 $n$ 次分裂后停止：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1443,7 +1446,7 @@ $$
|
||||
|
||||
### 对数阶 $O(\log n)$
|
||||
|
||||
与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。
|
||||
与指数阶相反，对数阶反映了“每轮缩减到一半”的情况。设输入数据大小为 $n$ ，由于每轮缩减到一半，因此循环次数是 $\log_2 n$ ，即 $2^n$ 的反函数。相关代码如下：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1519,7 +1522,7 @@ $$
|
||||
|
||||
|
||||
|
||||
与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。
|
||||
与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 $\log_2 n$ 的递归树：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1593,13 +1596,11 @@ $$
|
||||
[class]{}-[func]{log_recur}
|
||||
```
|
||||
|
||||
对数阶常出现于基于「分治」的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
|
||||
对数阶常出现于基于分治策略的算法中，体现了“一分为多”和“化繁为简”的算法思想。它增长缓慢，是理想的时间复杂度，仅次于常数阶。
|
||||
|
||||
### 线性对数阶 $O(n \log n)$
|
||||
|
||||
线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
|
||||
|
||||
主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
|
||||
线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。相关代码如下：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1675,6 +1676,8 @@ $$
|
||||
|
||||
|
||||
|
||||
主流排序算法的时间复杂度通常为 $O(n \log n)$ ，例如快速排序、归并排序、堆排序等。
|
||||
|
||||
### 阶乘阶 $O(n!)$
|
||||
|
||||
阶乘阶对应数学上的“全排列”问题。给定 $n$ 个互不重复的元素，求其所有可能的排列方案，方案数量为：
|
||||
@ -1683,7 +1686,7 @@ $$
|
||||
n! = n \times (n - 1) \times (n - 2) \times \cdots \times 2 \times 1
|
||||
$$
|
||||
|
||||
阶乘通常使用递归实现。例如以下代码，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时终止分裂。
|
||||
阶乘通常使用递归实现。例如在以下代码中，第一层分裂出 $n$ 个，第二层分裂出 $n - 1$ 个，以此类推，直至第 $n$ 层时停止分裂：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1759,16 +1762,16 @@ $$
|
||||
|
||||
|
||||
|
||||
请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长地更快，在 $n$ 较大时也是不可接受的。
|
||||
请注意，因为 $n! > 2^n$ ，所以阶乘阶比指数阶增长得更快，在 $n$ 较大时也是不可接受的。
|
||||
|
||||
## 最差、最佳、平均时间复杂度
|
||||
|
||||
**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论：
|
||||
**算法的时间效率往往不是固定的，而是与输入数据的分布有关**。假设输入一个长度为 $n$ 的数组 `nums` ，其中 `nums` 由从 $1$ 至 $n$ 的数字组成，每个数字只出现一次，但元素顺序是随机打乱的，任务目标是返回元素 $1$ 的索引。我们可以得出以下结论。
|
||||
|
||||
- 当 `nums = [?, ?, ..., 1]` ，即当末尾元素是 $1$ 时，需要完整遍历数组，**达到最差时间复杂度 $O(n)$** 。
|
||||
- 当 `nums = [1, ?, ?, ...]` ，即当首个数字为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
|
||||
- 当 `nums = [1, ?, ?, ...]` ，即当首个元素为 $1$ 时，无论数组多长都不需要继续遍历，**达到最佳时间复杂度 $\Omega(1)$** 。
|
||||
|
||||
「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示。
|
||||
「最差时间复杂度」对应函数渐近上界，使用大 $O$ 记号表示。相应地，「最佳时间复杂度」对应函数渐近下界，用 $\Omega$ 记号表示：
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -1889,10 +1892,10 @@ $$
|
||||
|
||||
从上述示例可以看出，最差或最佳时间复杂度只出现于“特殊的数据分布”，这些情况的出现概率可能很小，并不能真实地反映算法运行效率。相比之下，**「平均时间复杂度」可以体现算法在随机输入数据下的运行效率**，用 $\Theta$ 记号来表示。
|
||||
|
||||
对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数则是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
|
||||
对于部分算法，我们可以简单地推算出随机数据分布下的平均情况。比如上述示例，由于输入数组是被打乱的，因此元素 $1$ 出现在任意索引的概率都是相等的，那么算法的平均循环次数就是数组长度的一半 $\frac{n}{2}$ ，平均时间复杂度为 $\Theta(\frac{n}{2}) = \Theta(n)$ 。
|
||||
|
||||
但对于较为复杂的算法，计算平均时间复杂度往往是比较困难的，因为很难分析出在数据分布下的整体数学期望。在这种情况下，我们通常使用最差时间复杂度作为算法效率的评判标准。
|
||||
|
||||
!!! question "为什么很少看到 $\Theta$ 符号？"
|
||||
|
||||
可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示「平均复杂度」，但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。
|
||||
可能由于 $O$ 符号过于朗朗上口，我们常常使用它来表示平均时间复杂度。但从严格意义上看，这种做法并不规范。在本书和其他资料中，若遇到类似“平均时间复杂度 $O(n)$”的表述，请将其直接理解为 $\Theta(n)$ 。
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
- 整数类型 `byte` 占用 $1$ byte = $8$ bits ，可以表示 $2^{8}$ 个数字。
|
||||
- 整数类型 `int` 占用 $4$ bytes = $32$ bits ，可以表示 $2^{32}$ 个数字。
|
||||
|
||||
下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无需硬背，大致理解即可，需要时可以通过查表来回忆。
|
||||
下表列举了各种基本数据类型的占用空间、取值范围和默认值。此表格无须硬背，大致理解即可，需要时可以通过查表来回忆。
|
||||
<p align="center"> 表：基本数据类型的占用空间和取值范围 </p>
|
||||
|
||||
| 类型 | 符号 | 占用空间 | 最小值 | 最大值 | 默认值 |
|
||||
|
||||
@ -82,7 +82,7 @@ $$
|
||||
|
||||
请注意，这并不意味着计算机只能做加法。**通过将加法与一些基本逻辑运算结合，计算机能够实现各种其他的数学运算**。例如，计算减法 $a - b$ 可以转换为计算加法 $a + (-b)$ ；计算乘法和除法可以转换为计算多次加法或减法。
|
||||
|
||||
现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无需特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
|
||||
现在我们可以总结出计算机使用补码的原因：基于补码表示，计算机可以用同样的电路和操作来处理正数和负数的加法，不需要设计特殊的硬件电路来处理减法，并且无须特别处理正负零的歧义问题。这大大简化了硬件设计，提高了运算效率。
|
||||
|
||||
补码的设计非常精妙，因篇幅关系我们就先介绍到这里，建议有兴趣的读者进一步深度了解。
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
|
||||
- **问题可以被分解**：二分查找递归地将原问题（在数组中进行查找）分解为子问题（在数组的一半中进行查找），这是通过比较中间元素和目标元素来实现的。
|
||||
- **子问题是独立的**：在二分查找中，每轮只处理一个子问题，它不受另外子问题的影响。
|
||||
- **子问题的解无需合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
|
||||
- **子问题的解无须合并**：二分查找旨在查找一个特定元素，因此不需要将子问题的解进行合并。当子问题得到解决时，原问题也会同时得到解决。
|
||||
|
||||
分治能够提升搜索效率，本质上是因为暴力搜索每轮只能排除一个选项，**而分治搜索每轮可以排除一半选项**。
|
||||
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
- 分治算法是一种常见的算法设计策略，包括分（划分）和治（合并）两个阶段，通常基于递归实现。
|
||||
- 判断是否是分治算法问题的依据包括：问题能否被分解、子问题是否独立、子问题是否可以被合并。
|
||||
- 归并排序是分治策略的典型应用，其递归地将数组划分为等长的两个子数组，直到只剩一个元素时开始逐层合并，从而完成排序。
|
||||
- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了计算操作数量；另一方面，分治后有利于系统的并行优化。
|
||||
- 引入分治策略往往可以带来算法效率的提升。一方面，分治策略减少了操作数量；另一方面，分治后有利于系统的并行优化。
|
||||
- 分治既可以解决许多算法问题，也广泛应用于数据结构与算法设计中，处处可见其身影。
|
||||
- 相较于暴力搜索，自适应搜索效率更高。时间复杂度为 $O(\log n)$ 的搜索算法通常都是基于分治策略实现的。
|
||||
- 二分查找是分治思想的另一个典型应用，它不包含将子问题的解进行合并的步骤。我们可以通过递归分治实现二分查找。
|
||||
|
||||
@ -186,7 +186,7 @@ $$
|
||||
|
||||
「无后效性」是动态规划能够有效解决问题的重要特性之一，定义为：**给定一个确定的状态，它的未来发展只与当前状态有关，而与当前状态过去所经历过的所有状态无关**。
|
||||
|
||||
以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无需考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
|
||||
以爬楼梯问题为例，给定状态 $i$ ，它会发展出状态 $i+1$ 和状态 $i+2$ ，分别对应跳 $1$ 步和跳 $2$ 步。在做出这两种选择时，我们无须考虑状态 $i$ 之前的状态，它们对状态 $i$ 的未来没有影响。
|
||||
|
||||
然而，如果我们向爬楼梯问题添加一个约束，情况就不一样了。
|
||||
|
||||
|
||||
@ -53,7 +53,7 @@ $$
|
||||
dp[i, j] = \min(dp[i, j-1], dp[i-1, j], dp[i-1, j-1]) + 1
|
||||
$$
|
||||
|
||||
请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无需编辑当前字符**，这种情况下的状态转移方程为：
|
||||
请注意，**当 $s[i-1]$ 和 $t[j-1]$ 相同时，无须编辑当前字符**，这种情况下的状态转移方程为：
|
||||
|
||||
$$
|
||||
dp[i, j] = dp[i-1, j-1]
|
||||
|
||||
@ -356,7 +356,7 @@ $$
|
||||
|
||||
与之相反，**动态规划是一种“从底至顶”的方法**：从最小子问题的解开始，迭代地构建更大子问题的解，直至得到原问题的解。
|
||||
|
||||
由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无需使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。
|
||||
由于动态规划不包含回溯过程，因此只需使用循环迭代实现，无须使用递归。在以下代码中，我们初始化一个数组 `dp` 来存储子问题的解，它起到了记忆化搜索中数组 `mem` 相同的记录作用。
|
||||
|
||||
=== "Java"
|
||||
|
||||
@ -442,7 +442,7 @@ $$
|
||||
|
||||
## 状态压缩
|
||||
|
||||
细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无需使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
|
||||
细心的你可能发现，**由于 $dp[i]$ 只与 $dp[i-1]$ 和 $dp[i-2]$ 有关，因此我们无须使用一个数组 `dp` 来存储所有子问题的解**，而只需两个变量滚动前进即可。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
||||
@ -19,5 +19,5 @@
|
||||
**编辑距离问题**
|
||||
|
||||
- 编辑距离（Levenshtein 距离）用于衡量两个字符串之间的相似度，其定义为从一个字符串到另一个字符串的最小编辑步数，编辑操作包括添加、删除、替换。
|
||||
- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无需编辑当前字符。
|
||||
- 编辑距离问题的状态定义为将 $s$ 的前 $i$ 个字符更改为 $t$ 的前 $j$ 个字符所需的最少编辑步数。当 $s[i] \ne t[j]$ 时，具有三种决策：添加、删除、替换，它们都有相应的剩余子问题。据此便可以找出最优子结构与构建状态转移方程。而当 $s[i] = t[j]$ 时，无须编辑当前字符。
|
||||
- 在编辑距离中，状态依赖于其正上方、正左方、左上方的状态，因此状态压缩后正序或倒序遍历都无法正确地进行状态转移。为此，我们利用一个变量暂存左上方状态，从而转化到与完全背包等价的情况，可以在状态压缩后进行正序遍历。
|
||||
|
||||
@ -464,7 +464,7 @@ $$
|
||||
dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]]
|
||||
$$
|
||||
|
||||
当目标金额为 $0$ 时，无需选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。
|
||||
当目标金额为 $0$ 时，无须选择任何硬币即可凑出目标金额，因此应将首列所有 $dp[i, 0]$ 都初始化为 $1$ 。当无硬币时，无法凑出任何 $>0$ 的目标金额，因此首行所有 $dp[0, a]$ 都等于 $0$ 。
|
||||
|
||||
### 代码实现
|
||||
|
||||
|
||||
@ -129,7 +129,7 @@
|
||||
|
||||
- 如果我们选择通过顶点值来区分不同顶点，那么值重复的顶点将无法被区分。
|
||||
- 如果类似邻接矩阵那样，使用顶点列表索引来区分不同顶点。那么，假设我们想要删除索引为 $i$ 的顶点，则需要遍历整个邻接表，将其中 $> i$ 的索引全部减 $1$ ，这样操作效率较低。
|
||||
- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无需改动其余顶点了。
|
||||
- 因此我们考虑引入顶点类 `Vertex` ，使得每个顶点都是唯一的对象，此时删除顶点时就无须改动其余顶点了。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
||||
@ -55,7 +55,7 @@ $$
|
||||
|
||||
### 代码实现
|
||||
|
||||
在代码中，我们无需通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
|
||||
在代码中，我们无须通过循环来切分整数，而可以利用向下整除运算得到 $3$ 的个数 $a$ ，用取模运算得到余数 $b$ ，此时有：
|
||||
|
||||
$$
|
||||
n = 3 a + b
|
||||
|
||||
@ -12,7 +12,7 @@
|
||||
|
||||
有趣的是，存在一种更高效的建堆方法，其时间复杂度可以达到 $O(n)$ 。我们先将列表所有元素原封不动添加到堆中，然后倒序遍历该堆，依次对每个节点执行“从顶至底堆化”。
|
||||
|
||||
请注意，因为叶节点没有子节点，所以无需堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。
|
||||
请注意，因为叶节点没有子节点，所以无须堆化。在代码实现中，我们从最后一个节点的父节点开始进行堆化。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
||||
@ -526,7 +526,7 @@
|
||||
|
||||
给定元素 `val` ，我们首先将其添加到堆底。添加之后，由于 val 可能大于堆中其他元素，堆的成立条件可能已被破坏。因此，**需要修复从插入节点到根节点的路径上的各个节点**，这个操作被称为「堆化 Heapify」。
|
||||
|
||||
考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无需交换的节点时结束。
|
||||
考虑从入堆节点开始，**从底至顶执行堆化**。具体来说，我们比较插入节点与其父节点的值，如果插入节点更大，则将它们交换。然后继续执行此操作，从底至顶修复堆中的各个节点，直至越过根节点或遇到无须交换的节点时结束。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
@ -661,7 +661,7 @@
|
||||
2. 交换完成后，将堆底从列表中删除（注意，由于已经交换，实际上删除的是原来的堆顶元素）。
|
||||
3. 从根节点开始，**从顶至底执行堆化**。
|
||||
|
||||
顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无需交换的节点时结束。
|
||||
顾名思义，**从顶至底堆化的操作方向与从底至顶堆化相反**，我们将根节点的值与其两个子节点的值进行比较，将最大的子节点与根节点交换；然后循环执行此操作，直到越过叶节点或遇到无须交换的节点时结束。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
在正式探讨算法之前，有一个有趣的事实值得分享：**你已经在不知不觉中学会了许多算法，并习惯将它们应用到日常生活中了**。下面，我将举几个具体例子来证实这一点。
|
||||
|
||||
**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音的英文字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会这样操作：
|
||||
**例一：查阅字典**。在字典里，每个汉字都对应一个拼音，而字典是按照拼音字母顺序排列的。假设我们需要查找一个拼音首字母为 $r$ 的字，通常会按照下图所示的方式实现。
|
||||
|
||||
1. 翻开字典约一半的页数，查看该页首字母是什么，假设首字母为 $m$ 。
|
||||
2. 由于在英文字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
|
||||
3. 不断重复步骤 1-2 ，直至找到拼音首字母为 $r$ 的页码为止。
|
||||
1. 翻开字典约一半的页数，查看该页的首字母是什么，假设首字母为 $m$ 。
|
||||
2. 由于在拼音字母表中 $r$ 位于 $m$ 之后，所以排除字典前半部分，查找范围缩小到后半部分。
|
||||
3. 不断重复步骤 `1.` 和 步骤 `2.` ，直至找到拼音首字母为 $r$ 的页码为止。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
@ -25,9 +25,9 @@
|
||||
=== "<5>"
|
||||
|
||||
|
||||
查阅字典这个小学生必备技能，实际上就是著名的「二分查找」。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」算法。
|
||||
查阅字典这个小学生必备技能，实际上就是著名的二分查找算法。从数据结构的角度，我们可以把字典视为一个已排序的「数组」；从算法的角度，我们可以将上述查字典的一系列操作看作是「二分查找」。
|
||||
|
||||
**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下：
|
||||
**例二：整理扑克**。我们在打牌时，每局都需要整理扑克牌，使其从小到大排列，实现流程如下图所示。
|
||||
|
||||
1. 将扑克牌划分为“有序”和“无序”两部分，并假设初始状态下最左 1 张扑克牌已经有序。
|
||||
2. 在无序部分抽出一张扑克牌，插入至有序部分的正确位置；完成后最左 2 张扑克已经有序。
|
||||
@ -37,9 +37,9 @@
|
||||
|
||||
上述整理扑克牌的方法本质上是「插入排序」算法，它在处理小型数据集时非常高效。许多编程语言的排序库函数中都存在插入排序的身影。
|
||||
|
||||
**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要给我们找 $31$ 元。他会很自然地完成以下思考：
|
||||
**例三：货币找零**。假设我们在超市购买了 $69$ 元的商品，给收银员付了 $100$ 元，则收银员需要找我们 $31$ 元。他会很自然地完成如下图所示的思考。
|
||||
|
||||
1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ , $5$ , $10$ , $20$ 元。
|
||||
1. 可选项是比 $31$ 元面值更小的货币，包括 $1$ 元、$5$ 元、$10$ 元、$20$ 元。
|
||||
2. 从可选项中拿出最大的 $20$ 元，剩余 $31 - 20 = 11$ 元。
|
||||
3. 从剩余可选项中拿出最大的 $10$ 元，剩余 $11 - 10 = 1$ 元。
|
||||
4. 从剩余可选项中拿出最大的 $1$ 元，剩余 $1 - 1 = 0$ 元。
|
||||
@ -53,4 +53,4 @@
|
||||
|
||||
!!! tip
|
||||
|
||||
阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，那么太好了！因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。
|
||||
阅读至此，如果你对数据结构、算法、数组和二分查找等概念仍感到一知半解，请继续往下阅读，因为这正是本书存在的意义。接下来，这本书将引导你一步步深入数据结构与算法的知识殿堂。
|
||||
|
||||
@ -1,9 +1,9 @@
|
||||
# 小结
|
||||
|
||||
- 算法在日常生活中无处不在，并不是遥不可及的高深知识。实际上，我们已经在不知不觉中学会了许多算法，用以解决生活中的大小问题。
|
||||
- 查阅字典的原理与二分查找算法相一致。二分查找体现了分而治之的重要算法思想。
|
||||
- 整理扑克的过程与插入排序算法非常类似。插入排序适合排序小型数据集。
|
||||
- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好选择。
|
||||
- 查阅字典的原理与二分查找算法相一致。二分查找算法体现了分而治之的重要算法思想。
|
||||
- 整理扑克的过程与插入排序算法非常类似。插入排序算法适合排序小型数据集。
|
||||
- 货币找零的步骤本质上是贪心算法，每一步都采取当前看来的最好的选择。
|
||||
- 算法是在有限时间内解决特定问题的一组指令或操作步骤，而数据结构是计算机中组织和存储数据的方式。
|
||||
- 数据结构与算法紧密相连。数据结构是算法的基石，而算法则是发挥数据结构作用的舞台。
|
||||
- 乐高积木对应于数据，积木形状和连接方式代表数据结构，拼装积木的步骤则对应算法。
|
||||
- 我们可以将数据结构与算法类比为拼装积木，积木代表数据，积木的形状和连接方式代表数据结构，拼装积木的步骤则对应算法。
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
## 算法定义
|
||||
|
||||
「算法 Algorithm」是在有限时间内解决特定问题的一组指令或操作步骤。它具有以下特性：
|
||||
「算法 algorithm」是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性：
|
||||
|
||||
- 问题是明确的，包含清晰的输入和输出定义。
|
||||
- 具有可行性，能够在有限步骤、时间和内存空间下完成。
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
## 数据结构定义
|
||||
|
||||
「数据结构 Data Structure」是计算机中组织和存储数据的方式。它的设计目标包括：
|
||||
「数据结构 data structure」是计算机中组织和存储数据的方式，它的设计目标如下：
|
||||
|
||||
- 空间占用尽量减少，节省计算机内存。
|
||||
- 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
|
||||
@ -23,22 +23,23 @@
|
||||
|
||||
## 数据结构与算法的关系
|
||||
|
||||
数据结构与算法高度相关、紧密结合，具体表现在：
|
||||
数据结构与算法高度相关、紧密结合，具体表现在以下几个方面。
|
||||
|
||||
- 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及用于操作数据的方法。
|
||||
- 算法是数据结构发挥的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
|
||||
- 特定算法通常有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
|
||||
- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，通过结合算法才能解决特定问题。
|
||||
- 特定算法通常会有对应最优的数据结构。算法通常可以基于不同的数据结构进行实现，但最终执行效率可能相差很大。
|
||||
|
||||
|
||||
|
||||
数据结构与算法犹如拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
|
||||
数据结构与算法犹如上图所示的拼装积木。一套积木，除了包含许多零件之外，还附有详细的组装说明书。我们按照说明书一步步操作，就能组装出精美的积木模型。
|
||||
|
||||
|
||||
|
||||
两者的详细对应关系如下表所示。
|
||||
|
||||
<p align="center"> 表：将数据结构与算法类比为积木 </p>
|
||||
|
||||
| 数据结构与算法 | 积木 |
|
||||
| 数据结构与算法 | 拼装积木 |
|
||||
| -------------- | ---------------------------------------- |
|
||||
| 输入数据 | 未拼装的积木 |
|
||||
| 数据结构 | 积木组织形式，包括形状、大小、连接方式等 |
|
||||
|
||||
@ -208,7 +208,7 @@
|
||||
二分查找在时间和空间方面都有较好的性能：
|
||||
|
||||
- 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。例如，当数据大小 $n = 2^{20}$ 时，线性查找需要 $2^{20} = 1048576$ 轮循环，而二分查找仅需 $\log_2 2^{20} = 20$ 轮循环。
|
||||
- 二分查找无需额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
|
||||
- 二分查找无须额外空间。相较于需要借助额外空间的搜索算法（例如哈希查找），二分查找更加节省空间。
|
||||
|
||||
然而，二分查找并非适用于所有情况，原因如下：
|
||||
|
||||
|
||||
@ -188,5 +188,5 @@
|
||||
|
||||
代码在此省略，值得注意的有：
|
||||
|
||||
- 给定数组不包含小数，这意味着我们无需关心如何处理相等的情况。
|
||||
- 给定数组不包含小数，这意味着我们无须关心如何处理相等的情况。
|
||||
- 因为该方法引入了小数，所以需要将函数中的变量 `target` 改为浮点数类型。
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
- 「线性搜索」适用于数组和链表等线性数据结构。它从数据结构的一端开始，逐个访问元素，直到找到目标元素或到达另一端仍没有找到目标元素为止。
|
||||
- 「广度优先搜索」和「深度优先搜索」是图和树的两种遍历策略。广度优先搜索从初始节点开始逐层搜索，由近及远地访问各个节点。深度优先搜索是从初始节点开始，沿着一条路径走到头为止，再回溯并尝试其他路径，直到遍历完整个数据结构。
|
||||
|
||||
暴力搜索的优点是简单且通用性好，**无需对数据做预处理和借助额外的数据结构**。
|
||||
暴力搜索的优点是简单且通用性好，**无须对数据做预处理和借助额外的数据结构**。
|
||||
|
||||
然而，**此类算法的时间复杂度为 $O(n)$** ，其中 $n$ 为元素数量，因此在数据量较大的情况下性能较差。
|
||||
|
||||
@ -58,7 +58,7 @@
|
||||
|
||||
**线性搜索**
|
||||
|
||||
- 通用性较好，无需任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
|
||||
- 通用性较好，无须任何数据预处理操作。假如我们仅需查询一次数据，那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
|
||||
- 适用于体量较小的数据，此情况下时间复杂度对效率影响较小。
|
||||
- 适用于数据更新频率较高的场景，因为该方法不需要对数据进行任何额外维护。
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
# 小结
|
||||
|
||||
- 二分查找依赖于数据的有序性，通过循环逐步缩减一半搜索区间来实现查找。它要求输入数据有序，且仅适用于数组或基于数组实现的数据结构。
|
||||
- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无需对数据预处理，但时间复杂度 $O(n)$ 较高。
|
||||
- 暴力搜索通过遍历数据结构来定位数据。线性搜索适用于数组和链表，广度优先搜索和深度优先搜索适用于图和树。此类算法通用性好，无须对数据预处理，但时间复杂度 $O(n)$ 较高。
|
||||
- 哈希查找、树查找和二分查找属于高效搜索方法，可在特定数据结构中快速定位目标元素。此类算法效率高，时间复杂度可达 $O(\log n)$ 甚至 $O(1)$ ，但通常需要借助额外数据结构。
|
||||
- 实际中，我们需要对数据体量、搜索性能要求、数据查询和更新频率等因素进行具体分析，从而选择合适的搜索方法。
|
||||
- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无需范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
|
||||
- 线性搜索适用于小型或频繁更新的数据；二分查找适用于大型、排序的数据；哈希查找适合对查询效率要求较高且无须范围查询的数据；树查找适用于需要维护顺序和支持范围查询的大型动态数据。
|
||||
- 用哈希查找替换线性查找是一种常用的优化运行时间的策略，可将时间复杂度从 $O(n)$ 降低至 $O(1)$ 。
|
||||
|
||||
@ -32,7 +32,7 @@
|
||||
1. 首先，对 $n$ 个元素执行“冒泡”，**将数组的最大元素交换至正确位置**，
|
||||
2. 接下来，对剩余 $n - 1$ 个元素执行“冒泡”，**将第二大元素交换至正确位置**。
|
||||
3. 以此类推，经过 $n - 1$ 轮“冒泡”后，**前 $n - 1$ 大的元素都被交换至正确位置**。
|
||||
4. 仅剩的一个元素必定是最小元素，无需排序，因此数组排序完成。
|
||||
4. 仅剩的一个元素必定是最小元素，无须排序，因此数组排序完成。
|
||||
|
||||
|
||||
|
||||
|
||||
@ -101,7 +101,7 @@
|
||||
|
||||
插入排序的时间复杂度为 $O(n^2)$ ，而我们即将学习的快速排序的时间复杂度为 $O(n \log n)$ 。尽管插入排序的时间复杂度相比快速排序更高，**但在数据量较小的情况下，插入排序通常更快**。
|
||||
|
||||
这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元计算操作数量起到决定性因素。
|
||||
这个结论与线性查找和二分查找的适用情况的结论类似。快速排序这类 $O(n \log n)$ 的算法属于基于分治的排序算法，往往包含更多单元计算操作。而在数据量较小时，$n^2$ 和 $n \log n$ 的数值比较接近，复杂度不占主导作用；每轮中的单元操作数量起到决定性因素。
|
||||
|
||||
实际上，许多编程语言（例如 Java）的内置排序函数都采用了插入排序，大致思路为：对于长数组，采用基于分治的排序算法，例如快速排序；对于短数组，直接使用插入排序。
|
||||
|
||||
|
||||
@ -162,7 +162,7 @@
|
||||
|
||||
归并排序在排序链表时具有显著优势，空间复杂度可以优化至 $O(1)$ ，原因如下：
|
||||
|
||||
- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无需创建辅助链表。
|
||||
- 由于链表仅需改变指针就可实现节点的增删操作，因此合并阶段（将两个短有序链表合并为一个长有序链表）无须创建辅助链表。
|
||||
- 通过使用“迭代划分”替代“递归划分”，可省去递归使用的栈帧空间。
|
||||
|
||||
具体实现细节比较复杂，有兴趣的同学可以查阅相关资料进行学习。
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
2. 选取区间 $[0, n-1]$ 中的最小元素，将其与索引 $0$ 处元素交换。完成后，数组前 1 个元素已排序。
|
||||
3. 选取区间 $[1, n-1]$ 中的最小元素，将其与索引 $1$ 处元素交换。完成后，数组前 2 个元素已排序。
|
||||
4. 以此类推。经过 $n - 1$ 轮选择与交换后，数组前 $n - 1$ 个元素已排序。
|
||||
5. 仅剩的一个元素必定是最大元素，无需排序，因此数组排序完成。
|
||||
5. 仅剩的一个元素必定是最大元素，无须排序，因此数组排序完成。
|
||||
|
||||
=== "<1>"
|
||||
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
**运行效率**：我们期望排序算法的时间复杂度尽量低，且总体操作数量较少（即时间复杂度中的常数项降低）。对于大数据量情况，运行效率显得尤为重要。
|
||||
|
||||
**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无需借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
|
||||
**就地性**：顾名思义，「原地排序」通过在原数组上直接操作实现排序，无须借助额外的辅助数组，从而节省内存。通常情况下，原地排序的数据搬运操作较少，运行速度也更快。
|
||||
|
||||
**稳定性**：「稳定排序」在完成排序后，相等元素在数组中的相对顺序不发生改变。稳定排序是优良特性，也是多级排序场景的必要条件。
|
||||
|
||||
|
||||
@ -388,7 +388,7 @@
|
||||
=== "pop()"
|
||||
|
||||
|
||||
由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无需自行处理数组扩容问题。以下为示例代码。
|
||||
由于入栈的元素可能会源源不断地增加，因此我们可以使用动态数组，这样就无须自行处理数组扩容问题。以下为示例代码。
|
||||
|
||||
=== "Java"
|
||||
|
||||
|
||||
@ -301,7 +301,7 @@
|
||||
|
||||
我们知道，二叉树的中序遍历遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历顺序，而二叉搜索树满足“左子节点 $<$ 根节点 $<$ 右子节点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：**二叉搜索树的中序遍历序列是升序的**。
|
||||
|
||||
利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无需额外排序，非常高效。
|
||||
利用中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，无须额外排序，非常高效。
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user