CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-27 03:50:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

Polish the chapter

Browse Source 
introduction, computational complexity.
This commit is contained in:
krahets
2023-08-20 14:51:39 +08:00
parent 5fb728b3d6
commit 2626de8d0b
87 changed files with 375 additions and 371 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
codes/c/chapter_computational_complexity/time_complexity.c
View File

@@ -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) {

4
codes/c/chapter_heap/my_heap.c
View File

@@ -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;
}

2
codes/c/chapter_sorting/heap_sort.c
View File

@@ -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;
}

2
codes/c/chapter_tree/avl_tree.c
View File

@@ -107,7 +107,7 @@ TreeNode *rotate(TreeNode *node) {
return leftRotate(node);
}
}
// 平衡树，无需旋转，直接返回
// 平衡树，无须旋转，直接返回
return node;
}