algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-12-19 07:17:54 +08:00
Code Issues Packages Projects Releases Wiki Activity

Add build script for Go and update Go codes.

Browse Source
This commit is contained in:
krahets
2023-02-09 04:45:06 +08:00
parent 12c085a088
commit e8c78f89f0
39 changed files with 391 additions and 1468 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
docs/chapter_computational_complexity/space_complexity.md
View File

@@ -600,24 +600,7 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 常数阶 */
func spaceConstant(n int) {
// 常量、变量、对象占用 O(1) 空间
const a = 0
b := 0
nums := make([]int, 10000)
ListNode := newNode(0)
// 循环中的变量占用 O(1) 空间
var c int
for i := 0; i < n; i++ {
c = 0
}
// 循环中的函数占用 O(1) 空间
for i := 0; i < n; i++ {
function()
}
fmt.Println(a, b, nums, c, ListNode)
}
[class]{}-[func]{spaceConstant}
```
=== "JavaScript"
@@ -703,21 +686,7 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 线性阶 */
func spaceLinear(n int) {
// 长度为 n 的数组占用 O(n) 空间
_ = make([]int, n)
// 长度为 n 的列表占用 O(n) 空间
var nodes []*node
for i := 0; i < n; i++ {
nodes = append(nodes, newNode(i))
}
// 长度为 n 的哈希表占用 O(n) 空间
m := make(map[int]string, n)
for i := 0; i < n; i++ {
m[i] = strconv.Itoa(i)
}
}
[class]{}-[func]{spaceLinear}
```
=== "JavaScript"
@@ -800,14 +769,7 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 线性阶（递归实现） */
func spaceLinearRecur(n int) {
fmt.Println("递归 n =", n)
if n == 1 {
return
}
spaceLinearRecur(n - 1)
}
[class]{}-[func]{spaceLinearRecur}
```
=== "JavaScript"
@@ -880,14 +842,7 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 平方阶 */
func spaceQuadratic(n int) {
// 矩阵占用 O(n^2) 空间
numMatrix := make([][]int, n)
for i := 0; i < n; i++ {
numMatrix[i] = make([]int, n)
}
}
[class]{}-[func]{spaceQuadratic}
```
=== "JavaScript"
@@ -964,15 +919,7 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 平方阶（递归实现） */
func spaceQuadraticRecur(n int) int {
if n <= 0 {
return 0
}
// 数组 nums 长度为 n, n-1, ..., 2, 1
nums := make([]int, n)
return spaceQuadraticRecur(n - 1)
}
[class]{}-[func]{spaceQuadraticRecur}
```
=== "JavaScript"
@@ -1046,16 +993,7 @@ $$
=== "Go"
```go title="space_complexity.go"
/* 指数阶（建立满二叉树） */
func buildTree(n int) *treeNode {
if n == 0 {
return nil
}
root := newTreeNode(0)
root.left = buildTree(n - 1)
root.right = buildTree(n - 1)
return root
}
[class]{}-[func]{buildTree}
```
=== "JavaScript"

26
docs/chapter_computational_complexity/space_time_tradeoff.md
View File

@@ -51,18 +51,7 @@ comments: true
=== "Go"
```go title="leetcode_two_sum.go"
func twoSumBruteForce(nums []int, target int) []int {
size := len(nums)
// 两层循环，时间复杂度 O(n^2)
for i := 0; i < size-1; i++ {
for j := i + 1; i < size; j++ {
if nums[i]+nums[j] == target {
return []int{i, j}
}
}
}
return nil
}
[class]{}-[func]{twoSumBruteForce}
```
=== "JavaScript"
@@ -144,18 +133,7 @@ comments: true
=== "Go"
```go title="leetcode_two_sum.go"
func twoSumHashTable(nums []int, target int) []int {
// 辅助哈希表，空间复杂度 O(n)
hashTable := map[int]int{}
// 单层循环，时间复杂度 O(n)
for idx, val := range nums {
if preIdx, ok := hashTable[target-val]; ok {
return []int{preIdx, idx}
}
hashTable[val] = idx
}
return nil
}
[class]{}-[func]{twoSumHashTable}
```
=== "JavaScript"

126
docs/chapter_computational_complexity/time_complexity.md
View File

@@ -813,15 +813,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 常数阶 */
func constant(n int) int {
count := 0
size := 100000
for i := 0; i < size; i++ {
count ++
}
return count
}
[class]{}-[func]{constant}
```
=== "JavaScript"
@@ -904,14 +896,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 线性阶 */
func linear(n int) int {
count := 0
for i := 0; i < n; i++ {
count++
}
return count
}
[class]{}-[func]{linear}
```
=== "JavaScript"
@@ -992,15 +977,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 线性阶（遍历数组） */
func arrayTraversal(nums []int) int {
count := 0
// 循环次数与数组长度成正比
for range nums {
count++
}
return count
}
[class]{}-[func]{arrayTraversal}
```
=== "JavaScript"
@@ -1080,17 +1057,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 平方阶 */
func quadratic(n int) int {
count := 0
// 循环次数与数组长度成平方关系
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
count++
}
}
return count
}
[class]{}-[func]{quadratic}
```
=== "JavaScript"
@@ -1182,24 +1149,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 平方阶（冒泡排序） */
func bubbleSort(nums []int) int {
count := 0 // 计数器
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for i := len(nums) - 1; i > 0; i-- {
// 内循环：冒泡操作
for j := 0; j < i; j++ {
if nums[j] > nums[j+1] {
// 交换 nums[j] 与 nums[j + 1]
tmp := nums[j]
nums[j] = nums[j+1]
nums[j+1] = tmp
count += 3 // 元素交换包含 3 个单元操作
}
}
}
return count
}
[class]{}-[func]{bubbleSort}
```
=== "JavaScript"
@@ -1305,19 +1255,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 指数阶（循环实现）*/
func exponential(n int) int {
count, base := 0, 1
// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
for i := 0; i < n; i++ {
for j := 0; j < base; j++ {
count++
}
base *= 2
}
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
return count
}
[class]{}-[func]{exponential}
```
=== "JavaScript"
@@ -1411,13 +1349,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 指数阶（递归实现）*/
func expRecur(n int) int {
if n == 1 {
return 1
}
return expRecur(n-1) + expRecur(n-1) + 1
}
[class]{}-[func]{expRecur}
```
=== "JavaScript"
@@ -1493,15 +1425,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 对数阶（循环实现）*/
func logarithmic(n float64) int {
count := 0
for n > 1 {
n = n / 2
count++
}
return count
}
[class]{}-[func]{logarithmic}
```
=== "JavaScript"
@@ -1586,13 +1510,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 对数阶（递归实现）*/
func logRecur(n float64) int {
if n <= 1 {
return 0
}
return logRecur(n/2) + 1
}
[class]{}-[func]{logRecur}
```
=== "JavaScript"
@@ -1667,18 +1585,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 线性对数阶 */
func linearLogRecur(n float64) int {
if n <= 1 {
return 1
}
count := linearLogRecur(n/2) +
linearLogRecur(n/2)
for i := 0.0; i < n; i++ {
count++
}
return count
}
[class]{}-[func]{linearLogRecur}
```
=== "JavaScript"
@@ -1772,18 +1679,7 @@ $$
=== "Go"
```go title="time_complexity.go"
/* 阶乘阶（递归实现） */
func factorialRecur(n int) int {
if n == 0 {
return 1
}
count := 0
// 从 1 个分裂出 n 个
for i := 0; i < n; i++ {
count += factorialRecur(n - 1)
}
return count
}
[class]{}-[func]{factorialRecur}
```
=== "JavaScript"