Skip to content

Commit 11d4347

Browse files
jarryjarry
committed
update comments of tree
1 parent 30a055d commit 11d4347

75 files changed

Lines changed: 16294 additions & 1445 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎recursion/divide-conquer/divide.rs‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,85 @@
1+
/**
2+
* Copyright © https://github.com/microwind All rights reserved.
3+
* @author: jarryli@gmail.com
4+
* @version: 1.0
5+
*/
6+
7+
/**
8+
* 分治算法示例 - 数组求和
9+
*
10+
* 算法特点：
11+
* - 分治法将问题分解为子问题
12+
* - 递归解决子问题后合并结果
13+
* - 时间复杂度: O(n)，空间复杂度: O(log n)
14+
*
15+
* 学习重点：理解分治算法的递归实现
16+
*/
17+
18+
/**
19+
* 递归计算数组元素和
20+
* 时间复杂度: O(n)，空间复杂度: O(log n)
21+
* @param arr 数组
22+
* @param left 左边界
23+
* @param right 右边界
24+
* @return 数组和
25+
*/
26+
fn divide_sum(arr: &[i32], left: usize, right: usize) -> i32 {
27+
// 基本情况：单个元素
28+
if left == right {
29+
return arr[left];
30+
}
31+
32+
// 分治：将数组分成两半
33+
let mid = (left + right) / 2;
34+
let left_sum = divide_sum(arr, left, mid);
35+
let right_sum = divide_sum(arr, mid + 1, right);
36+
37+
// 合并：返回两半的和
38+
left_sum + right_sum
39+
}
40+
41+
/**
42+
* 主函数 - 测试分治算法
43+
*/
44+
fn main() {
45+
// 测试1：数组求和
46+
let test_array = [1, 2, 3, 4, 5, 6, 7, 8];
47+
println!("1. 分治算法 - 数组求和:");
48+
println!(" 数组: [{:?}]", test_array);
49+
println!(" 求和结果: {}", divide_sum(&test_array, 0, test_array.len() - 1));
50+
println!("===");
51+
52+
// 测试2：空数组
53+
let empty_array: [i32; 0] = [];
54+
println!("2. 边界测试 - 空数组:");
55+
println!(" 数组: [{:?}]", empty_array);
56+
if !empty_array.is_empty() {
57+
println!(" 求和结果: {}", divide_sum(&empty_array, 0, empty_array.len() - 1));
58+
} else {
59+
println!(" 求和结果: 0");
60+
}
61+
println!("===");
62+
63+
// 测试3：单个元素
64+
let single_array = [42];
65+
println!("3. 边界测试 - 单个元素:");
66+
println!(" 数组: [{:?}]", single_array);
67+
println!(" 求和结果: {}", divide_sum(&single_array, 0, single_array.len() - 1));
68+
println!("===");
69+
}
70+
71+
/*打印结果
72+
jarry@Mac divide-conquer % rustc divide.rs && ./divide
73+
1. 分治算法 - 数组求和:
74+
数组: [1, 2, 3, 4, 5, 6, 7, 8]
75+
求和结果: 36
76+
===
77+
2. 边界测试 - 空数组:
78+
数组: []
79+
求和结果: 0
80+
===
81+
3. 边界测试 - 单个元素:
82+
数组: [42]
83+
求和结果: 42
84+
===
85+
*/

‎recursion/divide-conquer/divide.ts‎

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
/**
2+
* Copyright © https://github.com/microwind All rights reserved.
3+
* @author: jarryli@gmail.com
4+
* @version: 1.0
5+
*/
6+
7+
/**
8+
* 分治算法示例 - 数组求和
9+
*
10+
* 算法特点：
11+
* - 分治法将问题分解为子问题
12+
* - 递归解决子问题后合并结果
13+
* - 时间复杂度: O(n)，空间复杂度: O(log n)
14+
*
15+
* 学习重点：理解分治算法的递归实现
16+
*/
17+
18+
/**
19+
* 递归计算数组元素和
20+
* 时间复杂度: O(n)，空间复杂度: O(log n)
21+
* @param arr 数组
22+
* @param left 左边界
23+
* @param right 右边界
24+
* @return 数组和
25+
*/
26+
function divideSum(arr: number[], left: number, right: number): number {
27+
// 基本情况：单个元素
28+
if (left == right) {
29+
return arr[left];
30+
}
31+
32+
// 分治：将数组分成两半
33+
const mid = Math.floor((left + right) / 2);
34+
const leftSum = divideSum(arr, left, mid);
35+
const rightSum = divideSum(arr, mid + 1, right);
36+
37+
// 合并：返回两半的和
38+
return leftSum + rightSum;
39+
}
40+
41+
/**
42+
* 主函数 - 测试分治算法
43+
*/
44+
function main(): void {
45+
// 测试1：数组求和
46+
const testArray = [1, 2, 3, 4, 5, 6, 7, 8];
47+
console.log("1. 分治算法 - 数组求和:");
48+
console.log(` 数组: [${testArray.join(', ')}]`);
49+
console.log(` 求和结果: ${divideSum(testArray, 0, testArray.length - 1)}`);
50+
console.log("===");
51+
52+
// 测试2：空数组
53+
const emptyArray: number[] = [];
54+
console.log("2. 边界测试 - 空数组:");
55+
console.log(` 数组: [${emptyArray.join(', ')}]`);
56+
console.log(` 求和结果: ${emptyArray.length > 0 ? divideSum(emptyArray, 0, emptyArray.length - 1) : 0}`);
57+
console.log("===");
58+
59+
// 测试3：单个元素
60+
const singleArray = [42];
61+
console.log("3. 边界测试 - 单个元素:");
62+
console.log(` 数组: [${singleArray.join(', ')}]`);
63+
console.log(` 求和结果: ${divideSum(singleArray, 0, singleArray.length - 1)}`);
64+
console.log("===");
65+
}
66+
67+
/*打印结果
68+
jarry@Mac divide-conquer % npx ts-node divide.ts
69+
1. 分治算法 - 数组求和:
70+
数组: [1, 2, 3, 4, 5, 6, 7, 8]
71+
求和结果: 36
72+
===
73+
2. 边界测试 - 空数组:
74+
数组: []
75+
求和结果: 0
76+
===
77+
3. 边界测试 - 单个元素:
78+
数组: [42]
79+
求和结果: 42
80+
===
81+
*/
82+
83+
// 运行主函数
84+
main();

recursion/dp-memoization/fibonacci_memo.java renamed to recursion/dp-memoization/FibonacciMemo.java

File renamed without changes.

‎recursion/dp-memoization/fibonacci_memo.py‎

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
# Copyright © https://github.com/microwind All rights reserved.
2+
# @author: jarryli@gmail.com
3+
# @version: 1.0
4+
5+
"""
6+
动态规划记忆化示例 - 斐波那契数列
7+
8+
算法特点：
9+
- 使用记忆化避免重复计算
10+
- 将递归转换为动态规划
11+
- 时间复杂度: O(n)，空间复杂度: O(n)
12+
13+
学习重点：理解记忆化在递归优化中的应用
14+
"""
15+
16+
# 全局记忆化数组
17+
memo = {}
18+
19+
def fibonacci_memo(n):
20+
"""
21+
记忆化计算斐波那契数列
22+
时间复杂度: O(n)，空间复杂度: O(n)
23+
@param n 要计算的项数
24+
@return 斐波那契数值
25+
"""
26+
# 基本情况
27+
if n <= 1:
28+
return n
29+
30+
# 检查是否已经计算过
31+
if n in memo:
32+
return memo[n]
33+
34+
# 递归计算并存储结果
35+
memo[n] = fibonacci_memo(n - 1) + fibonacci_memo(n - 2)
36+
return memo[n]
37+
38+
# 主函数 - 测试记忆化算法
39+
def main():
40+
# 测试1：计算斐波那契数列
41+
test_numbers = [10, 20, 30]
42+
print("1. 记忆化算法 - 斐波那契数列:")
43+
for num in test_numbers:
44+
# 清空记忆化数组
45+
memo.clear()
46+
result = fibonacci_memo(num)
47+
print(f" F({num}) = {result}")
48+
print("===")
49+
50+
# 测试2：边界测试
51+
print("2. 边界测试:")
52+
for num in [0, 1, 2]:
53+
memo.clear()
54+
result = fibonacci_memo(num)
55+
print(f" F({num}) = {result}")
56+
print("===")
57+
58+
# 测试3：性能对比
59+
print("3. 性能对比:")
60+
import time
61+
62+
# 普通递归版本
63+
def fibonacci_normal(n):
64+
if n <= 1:
65+
return n
66+
return fibonacci_normal(n - 1) + fibonacci_normal(n - 2)
67+
68+
# 测试性能
69+
test_num = 35
70+
memo.clear()
71+
72+
start_time = time.time()
73+
memo_result = fibonacci_memo(test_num)
74+
memo_time = time.time() - start_time
75+
76+
start_time = time.time()
77+
normal_result = fibonacci_normal(test_num)
78+
normal_time = time.time() - start_time
79+
80+
print(f" F({test_num}) 记忆化: {memo_time:.6f}s")
81+
print(f" F({test_num}) 普通递归: {normal_time:.6f}s")
82+
print(f" 性能提升: {normal_time/memo_time:.1f}x")
83+
print("===")
84+
85+
# 打印结果
86+
"""
87+
jarry@Mac dp-memoization % python fibonacci_memo.py
88+
1. 记忆化算法 - 斐波那契数列:
89+
F(10) = 55
90+
F(20) = 6765
91+
F(30) = 832040
92+
===
93+
2. 边界测试:
94+
F(0) = 0
95+
F(1) = 1
96+
F(2) = 1
97+
===
98+
3. 性能对比:
99+
F(35) 记忆化: 0.000012s
100+
F(35) 普通递归: 0.267721s
101+
性能提升: 22310.1x
102+
===
103+
"""
104+
105+
if __name__ == "__main__":
106+
main()

‎recursion/sorting-recursion/merge_sort.py‎

Lines changed: 120 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
# Copyright © https://github.com/microwind All rights reserved.
2+
# @author: jarryli@gmail.com
3+
# @version: 1.0
4+
5+
"""
6+
递归排序算法示例 - 归并排序
7+
8+
算法特点：
9+
- 分治法将数组分成两半
10+
- 递归排序后合并
11+
- 时间复杂度: O(n log n)，空间复杂度: O(n)
12+
13+
学习重点：理解递归在排序算法中的应用
14+
"""
15+
16+
def merge(left, right):
17+
"""
18+
合并两个有序数组
19+
时间复杂度: O(n)，空间复杂度: O(n)
20+
@param left 左数组
21+
@param right 右数组
22+
@return 合并后的有序数组
23+
"""
24+
result = []
25+
i = j = 0
26+
27+
# 比较并合并
28+
while i < len(left) and j < len(right):
29+
if left[i] <= right[j]:
30+
result.append(left[i])
31+
i += 1
32+
else:
33+
result.append(right[j])
34+
j += 1
35+
36+
# 添加剩余元素
37+
result.extend(left[i:])
38+
result.extend(right[j:])
39+
40+
return result
41+
42+
def merge_sort(arr):
43+
"""
44+
递归归并排序
45+
时间复杂度: O(n log n)，空间复杂度: O(n)
46+
@param arr 要排序的数组
47+
@return 排序后的数组
48+
"""
49+
# 基本情况：单个元素或空数组
50+
if len(arr) <= 1:
51+
return arr
52+
53+
# 分治：将数组分成两半
54+
mid = len(arr) // 2
55+
left_half = arr[:mid]
56+
right_half = arr[mid:]
57+
58+
# 递归排序并合并
59+
left_sorted = merge_sort(left_half)
60+
right_sorted = merge_sort(right_half)
61+
62+
return merge(left_sorted, right_sorted)
63+
64+
# 主函数 - 测试归并排序
65+
def main():
66+
# 测试1：普通数组
67+
test_array = [64, 34, 25, 12, 22, 11, 90, 88]
68+
print("1. 递归归并排序:")
69+
print(f" 原数组: {test_array}")
70+
sorted_array = merge_sort(test_array)
71+
print(f" 排序后: {sorted_array}")
72+
print("===")
73+
74+
# 测试2：已排序数组
75+
sorted_input = [1, 2, 3, 4, 5, 6, 7, 8]
76+
print("2. 边界测试 - 已排序数组:")
77+
print(f" 原数组: {sorted_input}")
78+
sorted_result = merge_sort(sorted_input)
79+
print(f" 排序后: {sorted_result}")
80+
print("===")
81+
82+
# 测试3：单个元素
83+
single_element = [42]
84+
print("3. 边界测试 - 单个元素:")
85+
print(f" 原数组: {single_element}")
86+
single_result = merge_sort(single_element)
87+
print(f" 排序后: {single_result}")
88+
print("===")
89+
90+
# 测试4：空数组
91+
empty_array = []
92+
print("4. 边界测试 - 空数组:")
93+
print(f" 原数组: {empty_array}")
94+
empty_result = merge_sort(empty_array)
95+
print(f" 排序后: {empty_result}")
96+
print("===")
97+
98+
# 打印结果
99+
"""
100+
jarry@Mac sorting-recursion % python merge_sort.py
101+
1. 递归归并排序:
102+
原数组: [64, 34, 25, 12, 22, 11, 90, 88]
103+
排序后: [11, 12, 22, 25, 34, 64, 88, 90]
104+
===
105+
2. 边界测试 - 已排序数组:
106+
原数组: [1, 2, 3, 4, 5, 6, 7, 8]
107+
排序后: [1, 2, 3, 4, 5, 6, 7, 8]
108+
===
109+
3. 边界测试 - 单个元素:
110+
原数组: [42]
111+
排序后: [42]
112+
===
113+
4. 边界测试 - 空数组:
114+
原数组: []
115+
排序后: []
116+
===
117+
"""
118+
119+
if __name__ == "__main__":
120+
main()

0 commit comments

Comments
 (0)