fuhouyin/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs(array): reduce understanding cost

Browse Source 
- 去除了并行测试；
- 基于 Java 代码样例，统一了命名风格；
- 基于 Go link 模块代码样例，统一了测试用例风格；
- 我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以降低理解成本，利于我们将关注点放在数据结构与算法上。
This commit is contained in:
龚国玮 2022-12-28 10:46:12 +08:00
parent b1be0aab15
commit f0c3bf5766
3 changed files with 58 additions and 170 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
codes/go/chapter_array_and_linkedlist/array.go
View File

@ -5,23 +5,24 @@ import (
"math/rand" "math/rand"
) )
// ExpectSize 预期大小。 在 Go 中，声明数组长度必须是常量表达式， /**
// 所以这里我们约定，扩展后的长度为 6 我们将 Go 中的 Slice 切片看作 Array 数组，降低理解成本，
const ExpectSize = 6 有利于我们将关注点放在数据结构与算法上。
*/
/* 随机返回一个数组元素 */ /* 随机返回一个数组元素 */
func randomAccess(nums [5]int) (ans int) { func randomAccess(nums []int) (randomNum int) {
// 在区间 [0, nums.length) 中随机抽取一个数字 // 在区间 [0, nums.length) 中随机抽取一个数字
randomIndex := rand.Intn(len(nums)) randomIndex := rand.Intn(len(nums))
// 获取并返回随机元素 // 获取并返回随机元素
ans = nums[randomIndex] randomNum = nums[randomIndex]
return return
} }
/* 扩展数组长度 */ /* 扩展数组长度 */
func extend(nums [5]int) [ExpectSize]int { func extend(nums []int, enlarge int) []int {
// 初始化一个扩展长度后的数组 // 初始化一个扩展长度后的数组
var res [ExpectSize]int res := make([]int, len(nums)+enlarge)
// 将原数组中的所有元素复制到新数组 // 将原数组中的所有元素复制到新数组
for i := 0; i < len(nums); i++ { for i := 0; i < len(nums); i++ {
res[i] = nums[i] res[i] = nums[i]
@ -31,7 +32,7 @@ func extend(nums [5]int) [ExpectSize]int {
} }
/* 在数组的索引 index 处插入元素 num */ /* 在数组的索引 index 处插入元素 num */
func insert(nums *[5]int, num int, index int) { func insert(nums []int, num int, index int) {
// 把索引 index 以及之后的所有元素向后移动一位 // 把索引 index 以及之后的所有元素向后移动一位
// 如果超出了数组长度，会被直接舍弃 // 如果超出了数组长度，会被直接舍弃
for i := len(nums) - 1; i > index; i-- { for i := len(nums) - 1; i > index; i-- {
@ -42,11 +43,7 @@ func insert(nums *[5]int, num int, index int) {
} }
/* 删除索引 index 处元素 */ /* 删除索引 index 处元素 */
func remove(nums *[5]int, index int) { func remove(nums []int, index int) {
// 越界检查
if index >= len(nums) {
return
}
// 把索引 index 之后的所有元素向前移动一位 // 把索引 index 之后的所有元素向前移动一位
for i := index; i < len(nums); i++ { for i := index; i < len(nums); i++ {
if i+1 >= len(nums) { if i+1 >= len(nums) {
@ -58,7 +55,7 @@ func remove(nums *[5]int, index int) {
} }
/* 遍历数组 */ /* 遍历数组 */
func traverse(nums [5]int) { func traverse(nums []int) {
var count int var count int
// 通过索引遍历数组 // 通过索引遍历数组
for i := 0; i < len(nums); i++ { for i := 0; i < len(nums); i++ {
@ -71,11 +68,11 @@ func traverse(nums [5]int) {
} }
/* 在数组中查找指定元素 */ /* 在数组中查找指定元素 */
func find(nums [5]int, target int) (ans int) { func find(nums []int, target int) (index int) {
ans = -1 index = -1
for i := 0; i < len(nums); i++ { for i := 0; i < len(nums); i++ {
if nums[i] == target { if nums[i] == target {
ans = i index = i
break break
} }
} }

162
codes/go/chapter_array_and_linkedlist/array_test.go
View File

@ -1,145 +1,43 @@
package chapter_array_and_linkedlist package chapter_array_and_linkedlist
/**
我们将 Go 中的 Slice 切片看作 Array 数组。因为这样可以
降低理解成本，利于我们将关注点放在数据结构与算法上。
*/
import ( import (
"reflect" "fmt"
"testing" "testing"
) )
func TestInitArray(t *testing.T) { /* Driver Code */
t.Parallel() func TestArray(t *testing.T) {
var arr [5]int /* 初始化数组 */
for _, v := range arr { var arr []int
if v != 0 { fmt.Println("数组 arr = ", arr)
t.Fatalf("array init exception") nums := []int{1, 3, 2, 5, 4}
} fmt.Println("数组 nums = ", nums)
}
}
func TestRandomAccess(t *testing.T) { /* 随机访问 */
t.Parallel() randomNum := randomAccess(nums)
min, max := 1, 5 fmt.Println("在 nums 中获取随机元素 ", randomNum)
nums := [5]int{min, 2, 3, 4, max}
ans := randomAccess(nums)
if ans < min || ans > max {
t.Fatalf("Expected range is greater than min: %v and less than max: %v, got ans: %v", min, max, ans)
}
}
func TestExtend(t *testing.T) { /* 长度扩展 */
t.Parallel() nums = extend(nums, 3)
nums := [5]int{1, 2, 3, 4, 5} fmt.Println("将数组长度扩展至 8 ，得到 nums = ", nums)
newNums := extend(nums)
if len(newNums) != ExpectSize {
t.Fatalf("Expected len: %v, got: %v", ExpectSize, len(nums))
}
}
func TestInsert(t *testing.T) { /* 插入元素 */
t.Parallel() insert(nums, 6, 3)
nums := [5]int{1, 2, 3, 4, 5} fmt.Println("在索引 3 处插入数字 6 ，得到 nums = ", nums)
insert(&nums, 5, 0)
if nums[0] != 5 {
t.Fatalf("Expected index[0] val: 5, got: %v", nums[0])
}
}
func TestRemove(t *testing.T) { /* 删除元素 */
t.Parallel() remove(nums, 2)
type fields struct { fmt.Println("删除索引 2 处的元素，得到 nums = ", nums)
index int
after [5]int
before [5]int
}
tests := []struct { /* 遍历数组 */
name string
fields fields
}{
{
name: "remove index[0]",
fields: struct {
index int
after [5]int
before [5]int
}{
index: 0,
after: [5]int{2, 3, 4, 5, 0},
before: [5]int{1, 2, 3, 4, 5},
},
},
{
name: "remove end",
fields: struct {
index int
after [5]int
before [5]int
}{
index: 4,
after: [5]int{1, 2, 3, 4, 0},
before: [5]int{1, 2, 3, 4, 5},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
v := tt.fields
remove(&v.before, v.index)
if !reflect.DeepEqual(v.before, v.after) {
t.Errorf("remove(&v.before, v.index) = %v, want %v", v.before, v.after)
}
})
}
}
func TestTraverse(t *testing.T) {
t.Parallel()
nums := [5]int{1, 2, 3, 4, 5}
traverse(nums) traverse(nums)
}
/* 查找元素 */
func TestFind(t *testing.T) { index := find(nums, 3)
t.Parallel() fmt.Println("在 nums 中查找元素 3 ，得到索引 = ", index)
type fields struct {
target int
nums [5]int
}
tests := []struct {
name string
fields fields
want int
}{
{
name: "element exists",
fields: struct {
target int
nums [5]int
}{
target: 1,
nums: [5]int{1, 2, 3, 4, 5},
},
want: 0,
},
{
name: "element does not exist",
fields: struct {
target int
nums [5]int
}{
target: 6,
nums: [5]int{1, 2, 3, 4, 5},
},
want: -1,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
v := tt.fields
if got := find(v.nums, v.target); got != tt.want {
t.Errorf("find(v.nums, v.target) = %v, want %v", got, tt.want)
}
})
}
} }

35
docs/chapter_array_and_linkedlist/array.md
View File

@ -44,8 +44,8 @@ comments: true
```go title="array.go" ```go title="array.go"
/* 初始化数组 */ /* 初始化数组 */
var arr [5]int // {0, 0, 0, 0, 0} var arr []int
nums := [5]int{1, 3, 2, 5, 4} nums := []int{1, 3, 2, 5, 4}
``` ```
=== "JavaScript" === "JavaScript"
@ -136,11 +136,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```go title="array.go" ```go title="array.go"
/* 随机返回一个数组元素 */ /* 随机返回一个数组元素 */
func randomAccess(nums [5]int) (ans int) { func randomAccess(nums [5]int) (randomNum int) {
// 在区间 [0, nums.length) 中随机抽取一个数字 // 在区间 [0, nums.length) 中随机抽取一个数字
randomIndex := rand.Intn(len(nums)) randomIndex := rand.Intn(len(nums))
// 获取并返回随机元素 // 获取并返回随机元素
ans = nums[randomIndex] randomNum = nums[randomIndex]
return return
} }
``` ```
@ -245,13 +245,10 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
=== "Go" === "Go"
```go title="array.go" ```go title="array.go"
// 在 Go 中，声明数组长度必须是常量表达式， /* 扩展数组长度 */
// 所以这里我们约定，扩展后的长度为 6 func extend(nums []int, enlarge int) []int {
const expectSize = 6
// 扩展数组长度
func extend(nums [5]int) [expectSize]int {
// 初始化一个扩展长度后的数组 // 初始化一个扩展长度后的数组
var res [expectSize]int res := make([]int, len(nums)+enlarge)
// 将原数组中的所有元素复制到新数组 // 将原数组中的所有元素复制到新数组
for i := 0; i < len(nums); i++ { for i := 0; i < len(nums); i++ {
res[i] = nums[i] res[i] = nums[i]
@ -393,7 +390,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```go title="array.go" ```go title="array.go"
/* 在数组的索引 index 处插入元素 num */ /* 在数组的索引 index 处插入元素 num */
func insert(nums [5]int, num int, index int) { func insert(nums []int, num int, index int) {
// 把索引 index 以及之后的所有元素向后移动一位 // 把索引 index 以及之后的所有元素向后移动一位
// 如果超出了数组长度，会被直接舍弃 // 如果超出了数组长度，会被直接舍弃
for i := len(nums) - 1; i > index; i-- { for i := len(nums) - 1; i > index; i-- {
@ -404,11 +401,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
} }
/* 删除索引 index 处元素 */ /* 删除索引 index 处元素 */
func remove(nums [5]int, index int) { func remove(nums []int, index int) {
// 越界检查
if index >= len(nums) {
return
}
// 把索引 index 之后的所有元素向前移动一位 // 把索引 index 之后的所有元素向前移动一位
for i := index; i < len(nums); i++ { for i := index; i < len(nums); i++ {
if i+1 >= len(nums) { if i+1 >= len(nums) {
@ -547,7 +540,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```go title="array.go" ```go title="array.go"
/* 遍历数组 */ /* 遍历数组 */
func traverse(nums [5]int) { func traverse(nums []int) {
var count int var count int
// 通过索引遍历数组 // 通过索引遍历数组
for i := 0; i < len(nums); i++ { for i := 0; i < len(nums); i++ {
@ -555,7 +548,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
} }
// 直接遍历数组 // 直接遍历数组
for index, val := range nums { for index, val := range nums {
fmt.Printf("index:%d value:%d\n", index, val) fmt.Printf("index:%v value:%v\n", index, val)
} }
} }
``` ```
@ -663,11 +656,11 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
```go title="array.go" ```go title="array.go"
/* 在数组中查找指定元素 */ /* 在数组中查找指定元素 */
func find(nums [5]int, target int) (ans int){ func find(nums []int, target int) (index int) {
ans = -1 index = -1
for i := 0; i < len(nums); i++ { for i := 0; i < len(nums); i++ {
if nums[i] == target { if nums[i] == target {
ans = i index = i
break break
} }
} }