xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-25 12:06:27 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #220 from Reanon/bugfix/fix-go-code-style

Browse source 
style(go): fix go code style
This commit is contained in:
Yudong Jin 2023-01-09 02:16:12 +08:00 committed by GitHub
commit 5c943471c7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
30 changed files with 412 additions and 380 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
codes/go/chapter_array_and_linkedlist/my_list.go
View file

@ -5,7 +5,7 @@
package chapter_array_and_linkedlist package chapter_array_and_linkedlist
/* 列表类简易实现 */ /* 列表类简易实现 */
type MyList struct { type myList struct {
numsCapacity int numsCapacity int
nums []int nums []int
numsSize int numsSize int
@ -13,8 +13,8 @@ type MyList struct {
} }
/* 构造函数 */ /* 构造函数 */
func newMyList() *MyList { func newMyList() *myList {
return &MyList{ return &myList{
numsCapacity: 10, // 列表容量 numsCapacity: 10, // 列表容量
nums: make([]int, 10), // 数组（存储列表元素） nums: make([]int, 10), // 数组（存储列表元素）
numsSize: 0, // 列表长度（即当前元素数量） numsSize: 0, // 列表长度（即当前元素数量）
@ -23,17 +23,17 @@ func newMyList() *MyList {
} }
/* 获取列表长度（即当前元素数量） */ /* 获取列表长度（即当前元素数量） */
func (l *MyList) size() int { func (l *myList) size() int {
return l.numsSize return l.numsSize
} }
/* 获取列表容量 */ /* 获取列表容量 */
func (l *MyList) capacity() int { func (l *myList) capacity() int {
return l.numsCapacity return l.numsCapacity
} }
/* 访问元素 */ /* 访问元素 */
func (l *MyList) get(index int) int { func (l *myList) get(index int) int {
// 索引如果越界则抛出异常，下同 // 索引如果越界则抛出异常，下同
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
@ -42,7 +42,7 @@ func (l *MyList) get(index int) int {
} }
/* 更新元素 */ /* 更新元素 */
func (l *MyList) set(num, index int) { func (l *myList) set(num, index int) {
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
} }
@ -50,7 +50,7 @@ func (l *MyList) set(num, index int) {
} }
/* 尾部添加元素 */ /* 尾部添加元素 */
func (l *MyList) add(num int) { func (l *myList) add(num int) {
// 元素数量超出容量时，触发扩容机制 // 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity { if l.numsSize == l.numsCapacity {
l.extendCapacity() l.extendCapacity()
@ -61,7 +61,7 @@ func (l *MyList) add(num int) {
} }
/* 中间插入元素 */ /* 中间插入元素 */
func (l *MyList) insert(num, index int) { func (l *myList) insert(num, index int) {
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
} }
@ -79,7 +79,7 @@ func (l *MyList) insert(num, index int) {
} }
/* 删除元素 */ /* 删除元素 */
func (l *MyList) remove(index int) int { func (l *myList) remove(index int) int {
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
} }
@ -95,7 +95,7 @@ func (l *MyList) remove(index int) int {
} }
/* 列表扩容 */ /* 列表扩容 */
func (l *MyList) extendCapacity() { func (l *myList) extendCapacity() {
// 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组 // 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...) l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
// 更新列表容量 // 更新列表容量
@ -103,7 +103,7 @@ func (l *MyList) extendCapacity() {
} }
/* 返回有效长度的列表 */ /* 返回有效长度的列表 */
func (l *MyList) toArray() []int { func (l *myList) toArray() []int {
// 仅转换有效长度范围内的列表元素 // 仅转换有效长度范围内的列表元素
return l.nums[:l.numsSize] return l.nums[:l.numsSize]
} }

32
codes/go/chapter_computational_complexity/space_complexity.go
View file

@ -9,31 +9,31 @@ import (
"strconv" "strconv"
) )
/* Node 结构体 */ /* 结构体 */
type Node struct { type node struct {
val int val int
next *Node next *node
} }
/* TreeNode 二叉树 */ /* treeNode 二叉树 */
type TreeNode struct { type treeNode struct {
val int val int
left *TreeNode left *treeNode
right *TreeNode right *treeNode
} }
/* 创建 Node 结构体 */ /* 创建 node 结构体 */
func newNode(val int) *Node { func newNode(val int) *node {
return &Node{val: val} return &node{val: val}
} }
/* 创建 TreeNode 结构体 */ /* 创建 treeNode 结构体 */
func newTreeNode(val int) *TreeNode { func newTreeNode(val int) *treeNode {
return &TreeNode{val: val} return &treeNode{val: val}
} }
/* 输出二叉树 */ /* 输出二叉树 */
func printTree(root *TreeNode) { func printTree(root *treeNode) {
if root == nil { if root == nil {
return return
} }
@ -72,7 +72,7 @@ func spaceLinear(n int) {
// 长度为 n 的数组占用 O(n) 空间 // 长度为 n 的数组占用 O(n) 空间
_ = make([]int, n) _ = make([]int, n)
// 长度为 n 的列表占用 O(n) 空间 // 长度为 n 的列表占用 O(n) 空间
var nodes []*Node var nodes []*node
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
nodes = append(nodes, newNode(i)) nodes = append(nodes, newNode(i))
} }
@ -112,7 +112,7 @@ func spaceQuadraticRecur(n int) int {
} }
/* 指数阶（建立满二叉树） */ /* 指数阶（建立满二叉树） */
func buildTree(n int) *TreeNode { func buildTree(n int) *treeNode {
if n == 0 { if n == 0 {
return nil return nil
} }

32
codes/go/chapter_hashing/array_hash_map.go
View file

@ -7,30 +7,30 @@ package chapter_hashing
import "fmt" import "fmt"
/* 键值对 int->String */ /* 键值对 int->String */
type Entry struct { type entry struct {
key int key int
val string val string
} }
/* 基于数组简易实现的哈希表 */ /* 基于数组简易实现的哈希表 */
type ArrayHashMap struct { type arrayHashMap struct {
bucket []*Entry bucket []*entry
} }
func newArrayHashMap() *ArrayHashMap { func newArrayHashMap() *arrayHashMap {
// 初始化一个长度为 100 的桶（数组） // 初始化一个长度为 100 的桶（数组）
bucket := make([]*Entry, 100) bucket := make([]*entry, 100)
return &ArrayHashMap{bucket: bucket} return &arrayHashMap{bucket: bucket}
} }
/* 哈希函数 */ /* 哈希函数 */
func (a *ArrayHashMap) hashFunc(key int) int { func (a *arrayHashMap) hashFunc(key int) int {
index := key % 100 index := key % 100
return index return index
} }
/* 查询操作 */ /* 查询操作 */
func (a *ArrayHashMap) get(key int) string { func (a *arrayHashMap) get(key int) string {
index := a.hashFunc(key) index := a.hashFunc(key)
pair := a.bucket[index] pair := a.bucket[index]
if pair == nil { if pair == nil {
@ -40,22 +40,22 @@ func (a *ArrayHashMap) get(key int) string {
} }
/* 添加操作 */ /* 添加操作 */
func (a *ArrayHashMap) put(key int, val string) { func (a *arrayHashMap) put(key int, val string) {
pair := &Entry{key: key, val: val} pair := &entry{key: key, val: val}
index := a.hashFunc(key) index := a.hashFunc(key)
a.bucket[index] = pair a.bucket[index] = pair
} }
/* 删除操作 */ /* 删除操作 */
func (a *ArrayHashMap) remove(key int) { func (a *arrayHashMap) remove(key int) {
index := a.hashFunc(key) index := a.hashFunc(key)
// 置为 nil ，代表删除 // 置为 nil ，代表删除
a.bucket[index] = nil a.bucket[index] = nil
} }
/* 获取所有键对 */ /* 获取所有键对 */
func (a *ArrayHashMap) entrySet() []*Entry { func (a *arrayHashMap) entrySet() []*entry {
var pairs []*Entry var pairs []*entry
for _, pair := range a.bucket { for _, pair := range a.bucket {
if pair != nil { if pair != nil {
pairs = append(pairs, pair) pairs = append(pairs, pair)
@ -65,7 +65,7 @@ func (a *ArrayHashMap) entrySet() []*Entry {
} }
/* 获取所有键 */ /* 获取所有键 */
func (a *ArrayHashMap) keySet() []int { func (a *arrayHashMap) keySet() []int {
var keys []int var keys []int
for _, pair := range a.bucket { for _, pair := range a.bucket {
if pair != nil { if pair != nil {
@ -76,7 +76,7 @@ func (a *ArrayHashMap) keySet() []int {
} }
/* 获取所有值 */ /* 获取所有值 */
func (a *ArrayHashMap) valueSet() []string { func (a *arrayHashMap) valueSet() []string {
var values []string var values []string
for _, pair := range a.bucket { for _, pair := range a.bucket {
if pair != nil { if pair != nil {
@ -87,7 +87,7 @@ func (a *ArrayHashMap) valueSet() []string {
} }
/* 打印哈希表 */ /* 打印哈希表 */
func (a *ArrayHashMap) print() { func (a *arrayHashMap) print() {
for _, pair := range a.bucket { for _, pair := range a.bucket {
if pair != nil { if pair != nil {
fmt.Println(pair.key, "->", pair.val) fmt.Println(pair.key, "->", pair.val)

3
codes/go/chapter_searching/hashing_search_test.go
View file

@ -6,8 +6,9 @@ package chapter_searching
import ( import (
"fmt" "fmt"
. "github.com/krahets/hello-algo/pkg"
"testing" "testing"
. "github.com/krahets/hello-algo/pkg"
) )
func TestHashingSearch(t *testing.T) { func TestHashingSearch(t *testing.T) {

12
codes/go/chapter_sorting/merge_sort.go
View file

@ -8,25 +8,25 @@ package chapter_sorting
// 左子数组区间 [left, mid] // 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right] // 右子数组区间 [mid + 1, right]
func merge(nums []int, left, mid, right int) { func merge(nums []int, left, mid, right int) {
// 初始化辅助数组 借助 copy模块 // 初始化辅助数组 借助 copy 模块
tmp := make([]int, right-left+1) tmp := make([]int, right-left+1)
for i := left; i <= right; i++ { for i := left; i <= right; i++ {
tmp[i-left] = nums[i] tmp[i-left] = nums[i]
} }
// 左子数组的起始索引和结束索引 // 左子数组的起始索引和结束索引
left_start, left_end := left-left, mid-left leftStart, leftEnd := left-left, mid-left
// 右子数组的起始索引和结束索引 // 右子数组的起始索引和结束索引
right_start, right_end := mid+1-left, right-left rightStart, rightEnd := mid+1-left, right-left
// i, j 分别指向左子数组、右子数组的首元素 // i, j 分别指向左子数组、右子数组的首元素
i, j := left_start, right_start i, j := leftStart, rightStart
// 通过覆盖原数组 nums 来合并左子数组和右子数组 // 通过覆盖原数组 nums 来合并左子数组和右子数组
for k := left; k <= right; k++ { for k := left; k <= right; k++ {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if i > left_end { if i > leftEnd {
nums[k] = tmp[j] nums[k] = tmp[j]
j++ j++
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if j > right_end || tmp[i] <= tmp[j] { } else if j > rightEnd || tmp[i] <= tmp[j] {
nums[k] = tmp[i] nums[k] = tmp[i]
i++ i++
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++

20
codes/go/chapter_sorting/quick_sort.go
View file

@ -5,16 +5,16 @@
package chapter_sorting package chapter_sorting
// 快速排序 // 快速排序
type QuickSort struct{} type quickSort struct{}
// 快速排序（中位基准数优化） // 快速排序（中位基准数优化）
type QuickSortMedian struct{} type quickSortMedian struct{}
// 快速排序（尾递归优化） // 快速排序（尾递归优化）
type QuickSortTailCall struct{} type quickSortTailCall struct{}
/* 哨兵划分 */ /* 哨兵划分 */
func (q *QuickSort) partition(nums []int, left, right int) int { func (q *quickSort) partition(nums []int, left, right int) int {
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
i, j := left, right i, j := left, right
for i < j { for i < j {
@ -33,7 +33,7 @@ func (q *QuickSort) partition(nums []int, left, right int) int {
} }
/* 快速排序 */ /* 快速排序 */
func (q *QuickSort) quickSort(nums []int, left, right int) { func (q *quickSort) quickSort(nums []int, left, right int) {
// 子数组长度为 1 时终止递归 // 子数组长度为 1 时终止递归
if left >= right { if left >= right {
return return
@ -46,7 +46,7 @@ func (q *QuickSort) quickSort(nums []int, left, right int) {
} }
/* 选取三个元素的中位数 */ /* 选取三个元素的中位数 */
func (q *QuickSortMedian) medianThree(nums []int, left, mid, right int) int { func (q *quickSortMedian) medianThree(nums []int, left, mid, right int) int {
if (nums[left] > nums[mid]) != (nums[left] > nums[right]) { if (nums[left] > nums[mid]) != (nums[left] > nums[right]) {
return left return left
} else if (nums[mid] < nums[left]) != (nums[mid] > nums[right]) { } else if (nums[mid] < nums[left]) != (nums[mid] > nums[right]) {
@ -56,7 +56,7 @@ func (q *QuickSortMedian) medianThree(nums []int, left, mid, right int) int {
} }
/* 哨兵划分（三数取中值）*/ /* 哨兵划分（三数取中值）*/
func (q *QuickSortMedian) partition(nums []int, left, right int) int { func (q *quickSortMedian) partition(nums []int, left, right int) int {
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
med := q.medianThree(nums, left, (left+right)/2, right) med := q.medianThree(nums, left, (left+right)/2, right)
// 将中位数交换至数组最左端 // 将中位数交换至数组最左端
@ -79,7 +79,7 @@ func (q *QuickSortMedian) partition(nums []int, left, right int) int {
} }
/* 快速排序 */ /* 快速排序 */
func (q *QuickSortMedian) quickSort(nums []int, left, right int) { func (q *quickSortMedian) quickSort(nums []int, left, right int) {
// 子数组长度为 1 时终止递归 // 子数组长度为 1 时终止递归
if left >= right { if left >= right {
return return
@ -92,7 +92,7 @@ func (q *QuickSortMedian) quickSort(nums []int, left, right int) {
} }
/* 哨兵划分 */ /* 哨兵划分 */
func (q *QuickSortTailCall) partition(nums []int, left, right int) int { func (q *quickSortTailCall) partition(nums []int, left, right int) int {
// 以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
i, j := left, right i, j := left, right
for i < j { for i < j {
@ -111,7 +111,7 @@ func (q *QuickSortTailCall) partition(nums []int, left, right int) int {
} }
/* 快速排序（尾递归优化）*/ /* 快速排序（尾递归优化）*/
func (q *QuickSortTailCall) quickSort(nums []int, left, right int) { func (q *quickSortTailCall) quickSort(nums []int, left, right int) {
// 子数组长度为 1 时终止 // 子数组长度为 1 时终止
for left < right { for left < right {
// 哨兵划分操作 // 哨兵划分操作

6
codes/go/chapter_sorting/quick_sort_test.go
View file

@ -11,7 +11,7 @@ import (
// 快速排序 // 快速排序
func TestQuickSort(t *testing.T) { func TestQuickSort(t *testing.T) {
q := QuickSort{} q := quickSort{}
nums := []int{4, 1, 3, 1, 5, 2} nums := []int{4, 1, 3, 1, 5, 2}
q.quickSort(nums, 0, len(nums)-1) q.quickSort(nums, 0, len(nums)-1)
fmt.Println("快速排序完成后 nums = ", nums) fmt.Println("快速排序完成后 nums = ", nums)
@ -19,7 +19,7 @@ func TestQuickSort(t *testing.T) {
// 快速排序（中位基准数优化） // 快速排序（中位基准数优化）
func TestQuickSortMedian(t *testing.T) { func TestQuickSortMedian(t *testing.T) {
q := QuickSortMedian{} q := quickSortMedian{}
nums := []int{4, 1, 3, 1, 5, 2} nums := []int{4, 1, 3, 1, 5, 2}
q.quickSort(nums, 0, len(nums)-1) q.quickSort(nums, 0, len(nums)-1)
fmt.Println("快速排序（中位基准数优化）完成后 nums = ", nums) fmt.Println("快速排序（中位基准数优化）完成后 nums = ", nums)
@ -27,7 +27,7 @@ func TestQuickSortMedian(t *testing.T) {
// 快速排序（尾递归优化） // 快速排序（尾递归优化）
func TestQuickSortTailCall(t *testing.T) { func TestQuickSortTailCall(t *testing.T) {
q := QuickSortTailCall{} q := quickSortTailCall{}
nums := []int{4, 1, 3, 1, 5, 2} nums := []int{4, 1, 3, 1, 5, 2}
q.quickSort(nums, 0, len(nums)-1) q.quickSort(nums, 0, len(nums)-1)
fmt.Println("快速排序（尾递归优化）完成后 nums = ", nums) fmt.Println("快速排序（尾递归优化）完成后 nums = ", nums)

38
codes/go/chapter_stack_and_queue/array_queue.go
View file

@ -5,16 +5,16 @@
package chapter_stack_and_queue package chapter_stack_and_queue
/* 基于环形数组实现的队列 */ /* 基于环形数组实现的队列 */
type ArrayQueue struct { type arrayQueue struct {
data []int // 用于存储队列元素的数组 data []int // 用于存储队列元素的数组
capacity int // 队列容量（即最多容量的元素个数） capacity int // 队列容量（即最多容量的元素个数）
front int // 头指针，指向队首 front int // 头指针，指向队首
rear int // 尾指针，指向队尾 + 1 rear int // 尾指针，指向队尾 + 1
} }
// NewArrayQueue 基于环形数组实现的队列 // newArrayQueue 基于环形数组实现的队列
func NewArrayQueue(capacity int) *ArrayQueue { func newArrayQueue(capacity int) *arrayQueue {
return &ArrayQueue{ return &arrayQueue{
data: make([]int, capacity), data: make([]int, capacity),
capacity: capacity, capacity: capacity,
front: 0, front: 0,
@ -22,21 +22,21 @@ func NewArrayQueue(capacity int) *ArrayQueue {
} }
} }
// Size 获取队列的长度 // size 获取队列的长度
func (q *ArrayQueue) Size() int { func (q *arrayQueue) size() int {
size := (q.capacity + q.rear - q.front) % q.capacity size := (q.capacity + q.rear - q.front) % q.capacity
return size return size
} }
// IsEmpty 判断队列是否为空 // isEmpty 判断队列是否为空
func (q *ArrayQueue) IsEmpty() bool { func (q *arrayQueue) isEmpty() bool {
return q.rear-q.front == 0 return q.rear-q.front == 0
} }
// Offer 入队 // offer 入队
func (q *ArrayQueue) Offer(v int) { func (q *arrayQueue) offer(v int) {
// 当 rear == capacity 表示队列已满 // 当 rear == capacity 表示队列已满
if q.Size() == q.capacity { if q.size() == q.capacity {
return return
} }
// 尾结点后添加 // 尾结点后添加
@ -45,9 +45,9 @@ func (q *ArrayQueue) Offer(v int) {
q.rear = (q.rear + 1) % q.capacity q.rear = (q.rear + 1) % q.capacity
} }
// Poll 出队 // poll 出队
func (q *ArrayQueue) Poll() any { func (q *arrayQueue) poll() any {
if q.IsEmpty() { if q.isEmpty() {
return nil return nil
} }
v := q.data[q.front] v := q.data[q.front]
@ -56,9 +56,9 @@ func (q *ArrayQueue) Poll() any {
return v return v
} }
// Peek 访问队首元素 // peek 访问队首元素
func (q *ArrayQueue) Peek() any { func (q *arrayQueue) peek() any {
if q.IsEmpty() { if q.isEmpty() {
return nil return nil
} }
v := q.data[q.front] v := q.data[q.front]
@ -66,6 +66,6 @@ func (q *ArrayQueue) Peek() any {
} }
// 获取 Slice 用于打印 // 获取 Slice 用于打印
func (s *ArrayQueue) toSlice() []int { func (q *arrayQueue) toSlice() []int {
return s.data[s.front:s.rear] return q.data[q.front:q.rear]
} }

36
codes/go/chapter_stack_and_queue/array_stack.go
View file

@ -5,47 +5,47 @@
package chapter_stack_and_queue package chapter_stack_and_queue
/* 基于数组实现的栈 */ /* 基于数组实现的栈 */
type ArrayStack struct { type arrayStack struct {
data []int // 数据 data []int // 数据
} }
func NewArrayStack() *ArrayStack { func newArrayStack() *arrayStack {
return &ArrayStack{ return &arrayStack{
// 设置栈的长度为 0，容量为 16 // 设置栈的长度为 0，容量为 16
data: make([]int, 0, 16), data: make([]int, 0, 16),
} }
} }
// Size 栈的长度 // size 栈的长度
func (s *ArrayStack) Size() int { func (s *arrayStack) size() int {
return len(s.data) return len(s.data)
} }
// IsEmpty 栈是否为空 // isEmpty 栈是否为空
func (s *ArrayStack) IsEmpty() bool { func (s *arrayStack) isEmpty() bool {
return s.Size() == 0 return s.size() == 0
} }
// Push 入栈 // push 入栈
func (s *ArrayStack) Push(v int) { func (s *arrayStack) push(v int) {
// 切片会自动扩容 // 切片会自动扩容
s.data = append(s.data, v) s.data = append(s.data, v)
} }
// Pop 出栈 // pop 出栈
func (s *ArrayStack) Pop() any { func (s *arrayStack) pop() any {
// 弹出栈前，先判断是否为空 // 弹出栈前，先判断是否为空
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
val := s.Peek() val := s.peek()
s.data = s.data[:len(s.data)-1] s.data = s.data[:len(s.data)-1]
return val return val
} }
// Peek 获取栈顶元素 // peek 获取栈顶元素
func (s *ArrayStack) Peek() any { func (s *arrayStack) peek() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
val := s.data[len(s.data)-1] val := s.data[len(s.data)-1]
@ -53,6 +53,6 @@ func (s *ArrayStack) Peek() any {
} }
// 获取 Slice 用于打印 // 获取 Slice 用于打印
func (s *ArrayStack) toSlice() []int { func (s *arrayStack) toSlice() []int {
return s.data return s.data
} }

30
codes/go/chapter_stack_and_queue/deque_test.go
View file

@ -51,48 +51,48 @@ func TestDeque(t *testing.T) {
func TestLinkedListDeque(t *testing.T) { func TestLinkedListDeque(t *testing.T) {
// 初始化队列 // 初始化队列
deque := NewLinkedListDeque() deque := newLinkedListDeque()
// 元素入队 // 元素入队
deque.OfferLast(2) deque.offerLast(2)
deque.OfferLast(5) deque.offerLast(5)
deque.OfferLast(4) deque.offerLast(4)
deque.OfferFirst(3) deque.offerFirst(3)
deque.OfferFirst(1) deque.offerFirst(1)
fmt.Print("队列 deque = ") fmt.Print("队列 deque = ")
PrintList(deque.toList()) PrintList(deque.toList())
// 访问队首元素 // 访问队首元素
front := deque.PeekFirst() front := deque.peekFirst()
fmt.Println("队首元素 front =", front) fmt.Println("队首元素 front =", front)
rear := deque.PeekLast() rear := deque.peekLast()
fmt.Println("队尾元素 rear =", rear) fmt.Println("队尾元素 rear =", rear)
// 元素出队 // 元素出队
pollFirst := deque.PollFirst() pollFirst := deque.pollFirst()
fmt.Print("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ") fmt.Print("队首出队元素 pollFirst = ", pollFirst, "，队首出队后 deque = ")
PrintList(deque.toList()) PrintList(deque.toList())
pollLast := deque.PollLast() pollLast := deque.pollLast()
fmt.Print("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ") fmt.Print("队尾出队元素 pollLast = ", pollLast, "，队尾出队后 deque = ")
PrintList(deque.toList()) PrintList(deque.toList())
// 获取队的长度 // 获取队的长度
size := deque.Size() size := deque.size()
fmt.Println("队的长度 size =", size) fmt.Println("队的长度 size =", size)
// 判断是否为空 // 判断是否为空
isEmpty := deque.IsEmpty() isEmpty := deque.isEmpty()
fmt.Println("队是否为空 =", isEmpty) fmt.Println("队是否为空 =", isEmpty)
} }
// BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro // BenchmarkArrayQueue 67.92 ns/op in Mac M1 Pro
func BenchmarkLinkedListDeque(b *testing.B) { func BenchmarkLinkedListDeque(b *testing.B) {
stack := NewLinkedListDeque() stack := newLinkedListDeque()
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.OfferLast(777) stack.offerLast(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.PollFirst() stack.pollFirst()
} }
} }

52
codes/go/chapter_stack_and_queue/linkedlist_deque.go
View file

@ -8,31 +8,31 @@ import (
"container/list" "container/list"
) )
// LinkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈 // linkedListDeque 基于链表实现的双端队列, 使用内置包 list 来实现栈
type LinkedListDeque struct { type linkedListDeque struct {
data *list.List data *list.List
} }
// NewLinkedListDeque 初始化双端队列 // newLinkedListDeque 初始化双端队列
func NewLinkedListDeque() *LinkedListDeque { func newLinkedListDeque() *linkedListDeque {
return &LinkedListDeque{ return &linkedListDeque{
data: list.New(), data: list.New(),
} }
} }
// OfferFirst 队首元素入队 // offerFirst 队首元素入队
func (s *LinkedListDeque) OfferFirst(value any) { func (s *linkedListDeque) offerFirst(value any) {
s.data.PushFront(value) s.data.PushFront(value)
} }
// OfferLast 队尾元素入队 // offerLast 队尾元素入队
func (s *LinkedListDeque) OfferLast(value any) { func (s *linkedListDeque) offerLast(value any) {
s.data.PushBack(value) s.data.PushBack(value)
} }
// PollFirst 队首元素出队 // pollFirst 队首元素出队
func (s *LinkedListDeque) PollFirst() any { func (s *linkedListDeque) pollFirst() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Front() e := s.data.Front()
@ -40,9 +40,9 @@ func (s *LinkedListDeque) PollFirst() any {
return e.Value return e.Value
} }
// PollLast 队尾元素出队 // pollLast 队尾元素出队
func (s *LinkedListDeque) PollLast() any { func (s *linkedListDeque) pollLast() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Back() e := s.data.Back()
@ -50,35 +50,35 @@ func (s *LinkedListDeque) PollLast() any {
return e.Value return e.Value
} }
// PeekFirst 访问队首元素 // peekFirst 访问队首元素
func (s *LinkedListDeque) PeekFirst() any { func (s *linkedListDeque) peekFirst() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Front() e := s.data.Front()
return e.Value return e.Value
} }
// PeekLast 访问队尾元素 // peekLast 访问队尾元素
func (s *LinkedListDeque) PeekLast() any { func (s *linkedListDeque) peekLast() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Back() e := s.data.Back()
return e.Value return e.Value
} }
// Size 获取队列的长度 // size 获取队列的长度
func (s *LinkedListDeque) Size() int { func (s *linkedListDeque) size() int {
return s.data.Len() return s.data.Len()
} }
// IsEmpty 判断队列是否为空 // isEmpty 判断队列是否为空
func (s *LinkedListDeque) IsEmpty() bool { func (s *linkedListDeque) isEmpty() bool {
return s.data.Len() == 0 return s.data.Len() == 0
} }
// 获取 List 用于打印 // 获取 List 用于打印
func (s *LinkedListDeque) toList() *list.List { func (s *linkedListDeque) toList() *list.List {
return s.data return s.data
} }

34
codes/go/chapter_stack_and_queue/linkedlist_queue.go
View file

@ -9,26 +9,26 @@ import (
) )
/* 基于链表实现的队列 */ /* 基于链表实现的队列 */
type LinkedListQueue struct { type linkedListQueue struct {
// 使用内置包 list 来实现队列 // 使用内置包 list 来实现队列
data *list.List data *list.List
} }
// NewLinkedListQueue 初始化链表 // newLinkedListQueue 初始化链表
func NewLinkedListQueue() *LinkedListQueue { func newLinkedListQueue() *linkedListQueue {
return &LinkedListQueue{ return &linkedListQueue{
data: list.New(), data: list.New(),
} }
} }
// Offer 入队 // offer 入队
func (s *LinkedListQueue) Offer(value any) { func (s *linkedListQueue) offer(value any) {
s.data.PushBack(value) s.data.PushBack(value)
} }
// Poll 出队 // poll 出队
func (s *LinkedListQueue) Poll() any { func (s *linkedListQueue) poll() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Front() e := s.data.Front()
@ -36,26 +36,26 @@ func (s *LinkedListQueue) Poll() any {
return e.Value return e.Value
} }
// Peek 访问队首元素 // peek 访问队首元素
func (s *LinkedListQueue) Peek() any { func (s *linkedListQueue) peek() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Front() e := s.data.Front()
return e.Value return e.Value
} }
// Size 获取队列的长度 // size 获取队列的长度
func (s *LinkedListQueue) Size() int { func (s *linkedListQueue) size() int {
return s.data.Len() return s.data.Len()
} }
// IsEmpty 判断队列是否为空 // isEmpty 判断队列是否为空
func (s *LinkedListQueue) IsEmpty() bool { func (s *linkedListQueue) isEmpty() bool {
return s.data.Len() == 0 return s.data.Len() == 0
} }
// 获取 List 用于打印 // 获取 List 用于打印
func (s *LinkedListQueue) toList() *list.List { func (s *linkedListQueue) toList() *list.List {
return s.data return s.data
} }

34
codes/go/chapter_stack_and_queue/linkedlist_stack.go
View file

@ -9,26 +9,26 @@ import (
) )
/* 基于链表实现的栈 */ /* 基于链表实现的栈 */
type LinkedListStack struct { type linkedListStack struct {
// 使用内置包 list 来实现栈 // 使用内置包 list 来实现栈
data *list.List data *list.List
} }
// NewLinkedListStack 初始化链表 // newLinkedListStack 初始化链表
func NewLinkedListStack() *LinkedListStack { func newLinkedListStack() *linkedListStack {
return &LinkedListStack{ return &linkedListStack{
data: list.New(), data: list.New(),
} }
} }
// Push 入栈 // push 入栈
func (s *LinkedListStack) Push(value int) { func (s *linkedListStack) push(value int) {
s.data.PushBack(value) s.data.PushBack(value)
} }
// Pop 出栈 // pop 出栈
func (s *LinkedListStack) Pop() any { func (s *linkedListStack) pop() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Back() e := s.data.Back()
@ -36,26 +36,26 @@ func (s *LinkedListStack) Pop() any {
return e.Value return e.Value
} }
// Peek 访问栈顶元素 // peek 访问栈顶元素
func (s *LinkedListStack) Peek() any { func (s *linkedListStack) peek() any {
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
e := s.data.Back() e := s.data.Back()
return e.Value return e.Value
} }
// Size 获取栈的长度 // size 获取栈的长度
func (s *LinkedListStack) Size() int { func (s *linkedListStack) size() int {
return s.data.Len() return s.data.Len()
} }
// IsEmpty 判断栈是否为空 // isEmpty 判断栈是否为空
func (s *LinkedListStack) IsEmpty() bool { func (s *linkedListStack) isEmpty() bool {
return s.data.Len() == 0 return s.data.Len() == 0
} }
// 获取 List 用于打印 // 获取 List 用于打印
func (s *LinkedListStack) toList() *list.List { func (s *linkedListStack) toList() *list.List {
return s.data return s.data
} }

52
codes/go/chapter_stack_and_queue/queue_test.go
View file

@ -48,87 +48,87 @@ func TestQueue(t *testing.T) {
func TestArrayQueue(t *testing.T) { func TestArrayQueue(t *testing.T) {
// 初始化队列，使用队列的通用接口 // 初始化队列，使用队列的通用接口
capacity := 10 capacity := 10
queue := NewArrayQueue(capacity) queue := newArrayQueue(capacity)
// 元素入队 // 元素入队
queue.Offer(1) queue.offer(1)
queue.Offer(3) queue.offer(3)
queue.Offer(2) queue.offer(2)
queue.Offer(5) queue.offer(5)
queue.Offer(4) queue.offer(4)
fmt.Print("队列 queue = ") fmt.Print("队列 queue = ")
PrintSlice(queue.toSlice()) PrintSlice(queue.toSlice())
// 访问队首元素 // 访问队首元素
peek := queue.Peek() peek := queue.peek()
fmt.Println("队首元素 peek =", peek) fmt.Println("队首元素 peek =", peek)
// 元素出队 // 元素出队
poll := queue.Poll() poll := queue.poll()
fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ") fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ")
PrintSlice(queue.toSlice()) PrintSlice(queue.toSlice())
// 获取队的长度 // 获取队的长度
size := queue.Size() size := queue.size()
fmt.Println("队的长度 size =", size) fmt.Println("队的长度 size =", size)
// 判断是否为空 // 判断是否为空
isEmpty := queue.IsEmpty() isEmpty := queue.isEmpty()
fmt.Println("队是否为空 =", isEmpty) fmt.Println("队是否为空 =", isEmpty)
} }
func TestLinkedListQueue(t *testing.T) { func TestLinkedListQueue(t *testing.T) {
// 初始化队 // 初始化队
queue := NewLinkedListQueue() queue := newLinkedListQueue()
// 元素入队 // 元素入队
queue.Offer(1) queue.offer(1)
queue.Offer(3) queue.offer(3)
queue.Offer(2) queue.offer(2)
queue.Offer(5) queue.offer(5)
queue.Offer(4) queue.offer(4)
fmt.Print("队列 queue = ") fmt.Print("队列 queue = ")
PrintList(queue.toList()) PrintList(queue.toList())
// 访问队首元素 // 访问队首元素
peek := queue.Peek() peek := queue.peek()
fmt.Println("队首元素 peek =", peek) fmt.Println("队首元素 peek =", peek)
// 元素出队 // 元素出队
poll := queue.Poll() poll := queue.poll()
fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ") fmt.Print("出队元素 poll = ", poll, ", 出队后 queue = ")
PrintList(queue.toList()) PrintList(queue.toList())
// 获取队的长度 // 获取队的长度
size := queue.Size() size := queue.size()
fmt.Println("队的长度 size =", size) fmt.Println("队的长度 size =", size)
// 判断是否为空 // 判断是否为空
isEmpty := queue.IsEmpty() isEmpty := queue.isEmpty()
fmt.Println("队是否为空 =", isEmpty) fmt.Println("队是否为空 =", isEmpty)
} }
// BenchmarkArrayQueue 8 ns/op in Mac M1 Pro // BenchmarkArrayQueue 8 ns/op in Mac M1 Pro
func BenchmarkArrayQueue(b *testing.B) { func BenchmarkArrayQueue(b *testing.B) {
capacity := 1000 capacity := 1000
stack := NewArrayQueue(capacity) stack := newArrayQueue(capacity)
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Offer(777) stack.offer(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Poll() stack.poll()
} }
} }
// BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro // BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro
func BenchmarkLinkedQueue(b *testing.B) { func BenchmarkLinkedQueue(b *testing.B) {
stack := NewLinkedListQueue() stack := newLinkedListQueue()
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Offer(777) stack.offer(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Poll() stack.poll()
} }
} }

52
codes/go/chapter_stack_and_queue/stack_test.go
View file

@ -46,85 +46,85 @@ func TestStack(t *testing.T) {
func TestArrayStack(t *testing.T) { func TestArrayStack(t *testing.T) {
// 初始化栈, 使用接口承接 // 初始化栈, 使用接口承接
stack := NewArrayStack() stack := newArrayStack()
// 元素入栈 // 元素入栈
stack.Push(1) stack.push(1)
stack.Push(3) stack.push(3)
stack.Push(2) stack.push(2)
stack.Push(5) stack.push(5)
stack.Push(4) stack.push(4)
fmt.Print("栈 stack = ") fmt.Print("栈 stack = ")
PrintSlice(stack.toSlice()) PrintSlice(stack.toSlice())
// 访问栈顶元素 // 访问栈顶元素
peek := stack.Peek() peek := stack.peek()
fmt.Println("栈顶元素 peek =", peek) fmt.Println("栈顶元素 peek =", peek)
// 元素出栈 // 元素出栈
pop := stack.Pop() pop := stack.pop()
fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ") fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ")
PrintSlice(stack.toSlice()) PrintSlice(stack.toSlice())
// 获取栈的长度 // 获取栈的长度
size := stack.Size() size := stack.size()
fmt.Println("栈的长度 size =", size) fmt.Println("栈的长度 size =", size)
// 判断是否为空 // 判断是否为空
isEmpty := stack.IsEmpty() isEmpty := stack.isEmpty()
fmt.Println("栈是否为空 =", isEmpty) fmt.Println("栈是否为空 =", isEmpty)
} }
func TestLinkedListStack(t *testing.T) { func TestLinkedListStack(t *testing.T) {
// 初始化栈 // 初始化栈
stack := NewLinkedListStack() stack := newLinkedListStack()
// 元素入栈 // 元素入栈
stack.Push(1) stack.push(1)
stack.Push(3) stack.push(3)
stack.Push(2) stack.push(2)
stack.Push(5) stack.push(5)
stack.Push(4) stack.push(4)
fmt.Print("栈 stack = ") fmt.Print("栈 stack = ")
PrintList(stack.toList()) PrintList(stack.toList())
// 访问栈顶元素 // 访问栈顶元素
peek := stack.Peek() peek := stack.peek()
fmt.Println("栈顶元素 peek =", peek) fmt.Println("栈顶元素 peek =", peek)
// 元素出栈 // 元素出栈
pop := stack.Pop() pop := stack.pop()
fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ") fmt.Print("出栈元素 pop = ", pop, ", 出栈后 stack = ")
PrintList(stack.toList()) PrintList(stack.toList())
// 获取栈的长度 // 获取栈的长度
size := stack.Size() size := stack.size()
fmt.Println("栈的长度 size =", size) fmt.Println("栈的长度 size =", size)
// 判断是否为空 // 判断是否为空
isEmpty := stack.IsEmpty() isEmpty := stack.isEmpty()
fmt.Println("栈是否为空 =", isEmpty) fmt.Println("栈是否为空 =", isEmpty)
} }
// BenchmarkArrayStack 8 ns/op in Mac M1 Pro // BenchmarkArrayStack 8 ns/op in Mac M1 Pro
func BenchmarkArrayStack(b *testing.B) { func BenchmarkArrayStack(b *testing.B) {
stack := NewArrayStack() stack := newArrayStack()
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Push(777) stack.push(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Pop() stack.pop()
} }
} }
// BenchmarkLinkedListStack 65.02 ns/op in Mac M1 Pro // BenchmarkLinkedListStack 65.02 ns/op in Mac M1 Pro
func BenchmarkLinkedListStack(b *testing.B) { func BenchmarkLinkedListStack(b *testing.B) {
stack := NewLinkedListStack() stack := newLinkedListStack()
// use b.N for looping // use b.N for looping
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Push(777) stack.push(777)
} }
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
stack.Pop() stack.pop()
} }
} }

24
codes/go/chapter_tree/binary_search_tree.go
View file

@ -10,26 +10,26 @@ import (
. "github.com/krahets/hello-algo/pkg" . "github.com/krahets/hello-algo/pkg"
) )
type BinarySearchTree struct { type binarySearchTree struct {
root *TreeNode root *TreeNode
} }
func NewBinarySearchTree(nums []int) *BinarySearchTree { func newBinarySearchTree(nums []int) *binarySearchTree {
// sorting array // sorting array
sort.Ints(nums) sort.Ints(nums)
root := buildBinarySearchTree(nums, 0, len(nums)-1) root := buildBinarySearchTree(nums, 0, len(nums)-1)
return &BinarySearchTree{ return &binarySearchTree{
root: root, root: root,
} }
} }
/* 获取根结点 */ /* 获取根结点 */
func (bst *BinarySearchTree) GetRoot() *TreeNode { func (bst *binarySearchTree) getRoot() *TreeNode {
return bst.root return bst.root
} }
/* 获取中序遍历的下一个结点 */ /* 获取中序遍历的下一个结点 */
func (bst *BinarySearchTree) GetInOrderNext(node *TreeNode) *TreeNode { func (bst *binarySearchTree) getInOrderNext(node *TreeNode) *TreeNode {
if node == nil { if node == nil {
return node return node
} }
@ -41,7 +41,7 @@ func (bst *BinarySearchTree) GetInOrderNext(node *TreeNode) *TreeNode {
} }
/* 查找结点 */ /* 查找结点 */
func (bst *BinarySearchTree) Search(num int) *TreeNode { func (bst *binarySearchTree) search(num int) *TreeNode {
node := bst.root node := bst.root
// 循环查找，越过叶结点后跳出 // 循环查找，越过叶结点后跳出
for node != nil { for node != nil {
@ -61,7 +61,7 @@ func (bst *BinarySearchTree) Search(num int) *TreeNode {
} }
/* 插入结点 */ /* 插入结点 */
func (bst *BinarySearchTree) Insert(num int) *TreeNode { func (bst *binarySearchTree) insert(num int) *TreeNode {
cur := bst.root cur := bst.root
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if cur == nil { if cur == nil {
@ -92,7 +92,7 @@ func (bst *BinarySearchTree) Insert(num int) *TreeNode {
} }
/* 删除结点 */ /* 删除结点 */
func (bst *BinarySearchTree) Remove(num int) *TreeNode { func (bst *binarySearchTree) remove(num int) *TreeNode {
cur := bst.root cur := bst.root
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if cur == nil { if cur == nil {
@ -136,10 +136,10 @@ func (bst *BinarySearchTree) Remove(num int) *TreeNode {
// 子结点数为 2 // 子结点数为 2
} else { } else {
// 获取中序遍历中待删除结点 cur 的下一个结点 // 获取中序遍历中待删除结点 cur 的下一个结点
next := bst.GetInOrderNext(cur) next := bst.getInOrderNext(cur)
temp := next.Val temp := next.Val
// 递归删除结点 next // 递归删除结点 next
bst.Remove(next.Val) bst.remove(next.Val)
// 将 next 的值复制给 cur // 将 next 的值复制给 cur
cur.Val = temp cur.Val = temp
} }
@ -160,7 +160,7 @@ func buildBinarySearchTree(nums []int, left, right int) *TreeNode {
return root return root
} }
// Print binary search tree // print binary search tree
func (bst *BinarySearchTree) Print() { func (bst *binarySearchTree) print() {
PrintTree(bst.root) PrintTree(bst.root)
} }

24
codes/go/chapter_tree/binary_search_tree_test.go
View file

@ -11,31 +11,31 @@ import (
func TestBinarySearchTree(t *testing.T) { func TestBinarySearchTree(t *testing.T) {
nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
bst := NewBinarySearchTree(nums) bst := newBinarySearchTree(nums)
fmt.Println("\n初始化的二叉树为:") fmt.Println("\n初始化的二叉树为:")
bst.Print() bst.print()
// 获取根结点 // 获取根结点
node := bst.GetRoot() node := bst.getRoot()
fmt.Println("\n二叉树的根结点为:", node.Val) fmt.Println("\n二叉树的根结点为:", node.Val)
// 查找结点 // 查找结点
node = bst.Search(5) node = bst.search(5)
fmt.Println("\n查找到的结点对象为", node, "，结点值 =", node.Val) fmt.Println("\n查找到的结点对象为", node, "，结点值 =", node.Val)
// 插入结点 // 插入结点
node = bst.Insert(16) node = bst.insert(16)
fmt.Println("\n插入结点后 16 的二叉树为:") fmt.Println("\n插入结点后 16 的二叉树为:")
bst.Print() bst.print()
// 删除结点 // 删除结点
bst.Remove(1) bst.remove(1)
fmt.Println("\n删除结点 1 后的二叉树为:") fmt.Println("\n删除结点 1 后的二叉树为:")
bst.Print() bst.print()
bst.Remove(2) bst.remove(2)
fmt.Println("\n删除结点 2 后的二叉树为:") fmt.Println("\n删除结点 2 后的二叉树为:")
bst.Print() bst.print()
bst.Remove(4) bst.remove(4)
fmt.Println("\n删除结点 4 后的二叉树为:") fmt.Println("\n删除结点 4 后的二叉树为:")
bst.Print() bst.print()
} }

2
codes/go/chapter_tree/binary_tree_bfs_test.go
View file

@ -14,7 +14,7 @@ import (
func TestLevelOrder(t *testing.T) { func TestLevelOrder(t *testing.T) {
/* 初始化二叉树 */ /* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数 // 这里借助了一个从数组直接生成二叉树的函数
root := ArrToTree([]int{1, 2, 3, 4, 5, 6, 7}) root := ArrToTree([]any{1, 2, 3, 4, 5, 6, 7})
fmt.Println("\n初始化二叉树: ") fmt.Println("\n初始化二叉树: ")
PrintTree(root) PrintTree(root)

2
codes/go/chapter_tree/binary_tree_dfs_test.go
View file

@ -14,7 +14,7 @@ import (
func TestPreInPostOrderTraversal(t *testing.T) { func TestPreInPostOrderTraversal(t *testing.T) {
/* 初始化二叉树 */ /* 初始化二叉树 */
// 这里借助了一个从数组直接生成二叉树的函数 // 这里借助了一个从数组直接生成二叉树的函数
root := ArrToTree([]int{1, 2, 3, 4, 5, 6, 7}) root := ArrToTree([]any{1, 2, 3, 4, 5, 6, 7})
fmt.Println("\n初始化二叉树: ") fmt.Println("\n初始化二叉树: ")
PrintTree(root) PrintTree(root)

4
codes/go/pkg/print_utils.go
View file

@ -76,7 +76,7 @@ func printTreeHelper(root *TreeNode, prev *trunk, isLeft bool) {
printTreeHelper(root.Left, trunk, false) printTreeHelper(root.Left, trunk, false)
} }
// trunk Help to Print tree structure // trunk Help to print tree structure
type trunk struct { type trunk struct {
prev *trunk prev *trunk
str string str string
@ -103,4 +103,4 @@ func PrintMap[K comparable, V any](m map[K]V) {
for key, value := range m { for key, value := range m {
fmt.Println(key, "->", value) fmt.Println(key, "->", value)
} }
} }

17
codes/go/pkg/tree_node.go
View file

@ -25,11 +25,12 @@ func NewTreeNode(v int) *TreeNode {
} }
// ArrToTree Generate a binary tree given an array // ArrToTree Generate a binary tree given an array
func ArrToTree(arr []int) *TreeNode { func ArrToTree(arr []any) *TreeNode {
if len(arr) <= 0 { if len(arr) <= 0 {
return nil return nil
} }
root := NewTreeNode(arr[0]) // TreeNode only accept integer value for now.
root := NewTreeNode(arr[0].(int))
// Let container.list as queue // Let container.list as queue
queue := list.New() queue := list.New()
queue.PushBack(root) queue.PushBack(root)
@ -39,13 +40,17 @@ func ArrToTree(arr []int) *TreeNode {
node := queue.Remove(queue.Front()).(*TreeNode) node := queue.Remove(queue.Front()).(*TreeNode)
i++ i++
if i < len(arr) { if i < len(arr) {
node.Left = NewTreeNode(arr[i]) if arr[i] != nil {
queue.PushBack(node.Left) node.Left = NewTreeNode(arr[i].(int))
queue.PushBack(node.Left)
}
} }
i++ i++
if i < len(arr) { if i < len(arr) {
node.Right = NewTreeNode(arr[i]) if arr[i] != nil {
queue.PushBack(node.Right) node.Right = NewTreeNode(arr[i].(int))
queue.PushBack(node.Right)
}
} }
} }
return root return root

2
codes/go/pkg/tree_node_test.go
View file

@ -10,7 +10,7 @@ import (
) )
func TestTreeNode(t *testing.T) { func TestTreeNode(t *testing.T) {
arr := []int{2, 3, 5, 6, 7} arr := []any{1, 2, 3, nil, 5, 6, nil}
node := ArrToTree(arr) node := ArrToTree(arr)
// print tree // print tree

25
docs/chapter_array_and_linkedlist/list.md
View file

@ -864,7 +864,7 @@ comments: true
```go title="my_list.go" ```go title="my_list.go"
/* 列表类简易实现 */ /* 列表类简易实现 */
type MyList struct { type myList struct {
numsCapacity int numsCapacity int
nums []int nums []int
numsSize int numsSize int
@ -872,8 +872,8 @@ comments: true
} }
/* 构造函数 */ /* 构造函数 */
func newMyList() *MyList { func newMyList() *myList {
return &MyList{ return &myList{
numsCapacity: 10, // 列表容量 numsCapacity: 10, // 列表容量
nums: make([]int, 10), // 数组（存储列表元素） nums: make([]int, 10), // 数组（存储列表元素）
numsSize: 0, // 列表长度（即当前元素数量） numsSize: 0, // 列表长度（即当前元素数量）
@ -882,17 +882,17 @@ comments: true
} }
/* 获取列表长度（即当前元素数量） */ /* 获取列表长度（即当前元素数量） */
func (l *MyList) size() int { func (l *myList) size() int {
return l.numsSize return l.numsSize
} }
/* 获取列表容量 */ /* 获取列表容量 */
func (l *MyList) capacity() int { func (l *myList) capacity() int {
return l.numsCapacity return l.numsCapacity
} }
/* 访问元素 */ /* 访问元素 */
func (l *MyList) get(index int) int { func (l *myList) get(index int) int {
// 索引如果越界则抛出异常，下同 // 索引如果越界则抛出异常，下同
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
@ -901,7 +901,7 @@ comments: true
} }
/* 更新元素 */ /* 更新元素 */
func (l *MyList) set(num, index int) { func (l *myList) set(num, index int) {
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
} }
@ -909,7 +909,7 @@ comments: true
} }
/* 尾部添加元素 */ /* 尾部添加元素 */
func (l *MyList) add(num int) { func (l *myList) add(num int) {
// 元素数量超出容量时，触发扩容机制 // 元素数量超出容量时，触发扩容机制
if l.numsSize == l.numsCapacity { if l.numsSize == l.numsCapacity {
l.extendCapacity() l.extendCapacity()
@ -920,7 +920,7 @@ comments: true
} }
/* 中间插入元素 */ /* 中间插入元素 */
func (l *MyList) insert(num, index int) { func (l *myList) insert(num, index int) {
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
} }
@ -938,20 +938,23 @@ comments: true
} }
/* 删除元素 */ /* 删除元素 */
func (l *MyList) Remove(index int) { func (l *myList) remove(index int) int {
if index >= l.numsSize { if index >= l.numsSize {
panic("索引越界") panic("索引越界")
} }
num := l.nums[index]
// 索引 i 之后的元素都向前移动一位 // 索引 i 之后的元素都向前移动一位
for j := index; j < l.numsSize-1; j++ { for j := index; j < l.numsSize-1; j++ {
l.nums[j] = l.nums[j+1] l.nums[j] = l.nums[j+1]
} }
// 更新元素数量 // 更新元素数量
l.numsSize-- l.numsSize--
// 返回被删除元素
return num
} }
/* 列表扩容 */ /* 列表扩容 */
func (l *MyList) extendCapacity() { func (l *myList) extendCapacity() {
// 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组 // 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...) l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
// 更新列表容量 // 更新列表容量

16
docs/chapter_computational_complexity/space_complexity.md
View file

@ -103,14 +103,14 @@ comments: true
```go title="" ```go title=""
/* 结构体 */ /* 结构体 */
type Node struct { type node struct {
val int val int
next *Node next *node
} }
/* 创建 Node 结构体 */ /* 创建 node 结构体 */
func newNode(val int) *Node { func newNode(val int) *node {
return &Node{val: val} return &node{val: val}
} }
/* 函数 */ /* 函数 */
@ -687,7 +687,7 @@ $$
// 长度为 n 的数组占用 O(n) 空间 // 长度为 n 的数组占用 O(n) 空间
_ = make([]int, n) _ = make([]int, n)
// 长度为 n 的列表占用 O(n) 空间 // 长度为 n 的列表占用 O(n) 空间
var nodes []*Node var nodes []*node
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
nodes = append(nodes, newNode(i)) nodes = append(nodes, newNode(i))
} }
@ -1108,7 +1108,7 @@ $$
```go title="space_complexity.go" ```go title="space_complexity.go"
/* 指数阶（建立满二叉树） */ /* 指数阶（建立满二叉树） */
func buildTree(n int) *TreeNode { func buildTree(n int) *treeNode {
if n == 0 { if n == 0 {
return nil return nil
} }

24
docs/chapter_hashing/hash_map.md
View file

@ -524,30 +524,30 @@ $$
```go title="array_hash_map.go" ```go title="array_hash_map.go"
/* 键值对 int->String */ /* 键值对 int->String */
type Entry struct { type entry struct {
key int key int
val string val string
} }
/* 基于数组简易实现的哈希表 */ /* 基于数组简易实现的哈希表 */
type ArrayHashMap struct { type arrayHashMap struct {
bucket []*Entry bucket []*entry
} }
func newArrayHashMap() *ArrayHashMap { func newArrayHashMap() *arrayHashMap {
// 初始化一个长度为 100 的桶（数组） // 初始化一个长度为 100 的桶（数组）
bucket := make([]*Entry, 100) bucket := make([]*entry, 100)
return &ArrayHashMap{bucket: bucket} return &arrayHashMap{bucket: bucket}
} }
/* 哈希函数 */ /* 哈希函数 */
func (a *ArrayHashMap) hashFunc(key int) int { func (a *arrayHashMap) hashFunc(key int) int {
index := key % 100 index := key % 100
return index return index
} }
/* 查询操作 */ /* 查询操作 */
func (a *ArrayHashMap) get(key int) string { func (a *arrayHashMap) get(key int) string {
index := a.hashFunc(key) index := a.hashFunc(key)
pair := a.bucket[index] pair := a.bucket[index]
if pair == nil { if pair == nil {
@ -557,16 +557,16 @@ $$
} }
/* 添加操作 */ /* 添加操作 */
func (a *ArrayHashMap) put(key int, val string) { func (a *arrayHashMap) put(key int, val string) {
pair := &Entry{key: key, val: val} pair := &entry{key: key, val: val}
index := a.hashFunc(key) index := a.hashFunc(key)
a.bucket[index] = pair a.bucket[index] = pair
} }
/* 删除操作 */ /* 删除操作 */
func (a *ArrayHashMap) remove(key int) { func (a *arrayHashMap) remove(key int) {
index := a.hashFunc(key) index := a.hashFunc(key)
// 置为空字符，代表删除 // 置为 nil ，代表删除
a.bucket[index] = nil a.bucket[index] = nil
} }
``` ```

19
docs/chapter_sorting/merge_sort.md
View file

@ -201,36 +201,35 @@ comments: true
右子数组区间 [mid + 1, right] 右子数组区间 [mid + 1, right]
*/ */
func merge(nums []int, left, mid, right int) { func merge(nums []int, left, mid, right int) {
// 初始化辅助数组 借助 copy模块 // 初始化辅助数组 借助 copy 模块
tmp := make([]int, right-left+1) tmp := make([]int, right-left+1)
for i := left; i <= right; i++ { for i := left; i <= right; i++ {
tmp[i-left] = nums[i] tmp[i-left] = nums[i]
} }
// 左子数组的起始索引和结束索引 // 左子数组的起始索引和结束索引
left_start, left_end := left-left, mid-left leftStart, leftEnd := left-left, mid-left
// 右子数组的起始索引和结束索引 // 右子数组的起始索引和结束索引
right_start, right_end := mid+1-left, right-left rightStart, rightEnd := mid+1-left, right-left
// i, j 分别指向左子数组、右子数组的首元素 // i, j 分别指向左子数组、右子数组的首元素
i, j := left_start, right_start i, j := leftStart, rightStart
// 通过覆盖原数组 nums 来合并左子数组和右子数组 // 通过覆盖原数组 nums 来合并左子数组和右子数组
for k := left; k <= right; k++ { for k := left; k <= right; k++ {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++ // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if i > left_end { if i > leftEnd {
nums[k] = tmp[j] nums[k] = tmp[j]
j++ j++
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++ // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
} else if j > right_end || tmp[i] <= tmp[j] { } else if j > rightEnd || tmp[i] <= tmp[j] {
nums[k] = tmp[i] nums[k] = tmp[i]
i++ i++
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++ // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
} else { } else {
nums[k] = tmp[j] nums[k] = tmp[j]
j++ j++
} }
} }
} }
/* 归并排序 */
func mergeSort(nums []int, left, right int) { func mergeSort(nums []int, left, right int) {
// 终止条件 // 终止条件
if left >= right { if left >= right {

10
docs/chapter_sorting/quick_sort.md
View file

@ -111,21 +111,21 @@ comments: true
```go title="quick_sort.go" ```go title="quick_sort.go"
/* 哨兵划分 */ /* 哨兵划分 */
func partition(nums []int, left, right int) int { func partition(nums []int, left, right int) int {
//以 nums[left] 作为基准数 // 以 nums[left] 作为基准数
i, j := left, right i, j := left, right
for i < j { for i < j {
for i < j && nums[j] >= nums[left] { for i < j && nums[j] >= nums[left] {
j-- //从右向左找首个小于基准数的元素 j-- // 从右向左找首个小于基准数的元素
} }
for i < j && nums[i] <= nums[left] { for i < j && nums[i] <= nums[left] {
i++ //从左向右找首个大于基准数的元素 i++ // 从左向右找首个大于基准数的元素
} }
//元素交换 //元素交换
nums[i], nums[j] = nums[j], nums[i] nums[i], nums[j] = nums[j], nums[i]
} }
//将基准数交换至两子数组的分界线 // 将基准数交换至两子数组的分界线
nums[i], nums[left] = nums[left], nums[i] nums[i], nums[left] = nums[left], nums[i]
return i //返回基准数的索引 return i // 返回基准数的索引
} }
``` ```

78
docs/chapter_stack_and_queue/queue.md
View file

@ -404,43 +404,49 @@ comments: true
```go title="linkedlist_queue.go" ```go title="linkedlist_queue.go"
/* 基于链表实现的队列 */ /* 基于链表实现的队列 */
type LinkedListQueue struct { type linkedListQueue struct {
// 使用内置包 list 来实现队列 // 使用内置包 list 来实现队列
data *list.List data *list.List
} }
// NewLinkedListQueue 初始化链表
func NewLinkedListQueue() *LinkedListQueue { // newLinkedListQueue 初始化链表
return &LinkedListQueue{ func newLinkedListQueue() *linkedListQueue {
return &linkedListQueue{
data: list.New(), data: list.New(),
} }
} }
// Offer 入队
func (s *LinkedListQueue) Offer(value any) { // offer 入队
func (s *linkedListQueue) offer(value any) {
s.data.PushBack(value) s.data.PushBack(value)
} }
// Poll 出队
func (s *LinkedListQueue) Poll() any { // poll 出队
if s.IsEmpty() { func (s *linkedListQueue) poll() any {
if s.isEmpty() {
return nil return nil
} }
e := s.data.Front() e := s.data.Front()
s.data.Remove(e) s.data.Remove(e)
return e.Value return e.Value
} }
// Peek 访问队首元素
func (s *LinkedListQueue) Peek() any { // peek 访问队首元素
if s.IsEmpty() { func (s *linkedListQueue) peek() any {
if s.isEmpty() {
return nil return nil
} }
e := s.data.Front() e := s.data.Front()
return e.Value return e.Value
} }
// Size 获取队列的长度
func (s *LinkedListQueue) Size() int { // size 获取队列的长度
func (s *linkedListQueue) size() int {
return s.data.Len() return s.data.Len()
} }
// IsEmpty 判断队列是否为空
func (s *LinkedListQueue) IsEmpty() bool { // isEmpty 判断队列是否为空
func (s *linkedListQueue) isEmpty() bool {
return s.data.Len() == 0 return s.data.Len() == 0
} }
``` ```
@ -805,34 +811,38 @@ comments: true
```go title="array_queue.go" ```go title="array_queue.go"
/* 基于环形数组实现的队列 */ /* 基于环形数组实现的队列 */
type ArrayQueue struct { type arrayQueue struct {
data []int // 用于存储队列元素的数组 data []int // 用于存储队列元素的数组
capacity int // 队列容量（即最多容量的元素个数） capacity int // 队列容量（即最多容量的元素个数）
front int // 头指针，指向队首 front int // 头指针，指向队首
rear int // 尾指针，指向队尾 + 1 rear int // 尾指针，指向队尾 + 1
} }
// NewArrayQueue 基于环形数组实现的队列
func NewArrayQueue(capacity int) *ArrayQueue { // newArrayQueue 基于环形数组实现的队列
return &ArrayQueue{ func newArrayQueue(capacity int) *arrayQueue {
return &arrayQueue{
data: make([]int, capacity), data: make([]int, capacity),
capacity: capacity, capacity: capacity,
front: 0, front: 0,
rear: 0, rear: 0,
} }
} }
// Size 获取队列的长度
func (q *ArrayQueue) Size() int { // size 获取队列的长度
func (q *arrayQueue) size() int {
size := (q.capacity + q.rear - q.front) % q.capacity size := (q.capacity + q.rear - q.front) % q.capacity
return size return size
} }
// IsEmpty 判断队列是否为空
func (q *ArrayQueue) IsEmpty() bool { // isEmpty 判断队列是否为空
func (q *arrayQueue) isEmpty() bool {
return q.rear-q.front == 0 return q.rear-q.front == 0
} }
// Offer 入队
func (q *ArrayQueue) Offer(v int) { // offer 入队
func (q *arrayQueue) offer(v int) {
// 当 rear == capacity 表示队列已满 // 当 rear == capacity 表示队列已满
if q.Size() == q.capacity { if q.size() == q.capacity {
return return
} }
// 尾结点后添加 // 尾结点后添加
@ -840,9 +850,10 @@ comments: true
// 尾指针向后移动一位，越过尾部后返回到数组头部 // 尾指针向后移动一位，越过尾部后返回到数组头部
q.rear = (q.rear + 1) % q.capacity q.rear = (q.rear + 1) % q.capacity
} }
// Poll 出队
func (q *ArrayQueue) Poll() any { // poll 出队
if q.IsEmpty() { func (q *arrayQueue) poll() any {
if q.isEmpty() {
return nil return nil
} }
v := q.data[q.front] v := q.data[q.front]
@ -850,9 +861,10 @@ comments: true
q.front = (q.front + 1) % q.capacity q.front = (q.front + 1) % q.capacity
return v return v
} }
// Peek 访问队首元素
func (q *ArrayQueue) Peek() any { // peek 访问队首元素
if q.IsEmpty() { func (q *arrayQueue) peek() any {
if q.isEmpty() {
return nil return nil
} }
v := q.data[q.front] v := q.data[q.front]

78
docs/chapter_stack_and_queue/stack.md
View file

@ -378,43 +378,49 @@ comments: true
```go title="linkedlist_stack.go" ```go title="linkedlist_stack.go"
/* 基于链表实现的栈 */ /* 基于链表实现的栈 */
type LinkedListStack struct { type linkedListStack struct {
// 使用内置包 list 来实现栈 // 使用内置包 list 来实现栈
data *list.List data *list.List
} }
// NewLinkedListStack 初始化链表
func NewLinkedListStack() *LinkedListStack { // newLinkedListStack 初始化链表
return &LinkedListStack{ func newLinkedListStack() *linkedListStack {
return &linkedListStack{
data: list.New(), data: list.New(),
} }
} }
// Push 入栈
func (s *LinkedListStack) Push(value int) { // push 入栈
func (s *linkedListStack) push(value int) {
s.data.PushBack(value) s.data.PushBack(value)
} }
// Pop 出栈
func (s *LinkedListStack) Pop() any { // pop 出栈
if s.IsEmpty() { func (s *linkedListStack) pop() any {
if s.isEmpty() {
return nil return nil
} }
e := s.data.Back() e := s.data.Back()
s.data.Remove(e) s.data.Remove(e)
return e.Value return e.Value
} }
// Peek 访问栈顶元素
func (s *LinkedListStack) Peek() any { // peek 访问栈顶元素
if s.IsEmpty() { func (s *linkedListStack) peek() any {
if s.isEmpty() {
return nil return nil
} }
e := s.data.Back() e := s.data.Back()
return e.Value return e.Value
} }
// Size 获取栈的长度
func (s *LinkedListStack) Size() int { // size 获取栈的长度
func (s *linkedListStack) size() int {
return s.data.Len() return s.data.Len()
} }
// IsEmpty 判断栈是否为空
func (s *LinkedListStack) IsEmpty() bool { // isEmpty 判断栈是否为空
func (s *linkedListStack) isEmpty() bool {
return s.data.Len() == 0 return s.data.Len() == 0
} }
``` ```
@ -716,41 +722,47 @@ comments: true
```go title="array_stack.go" ```go title="array_stack.go"
/* 基于数组实现的栈 */ /* 基于数组实现的栈 */
type ArrayStack struct { type arrayStack struct {
data []int // 数据 data []int // 数据
} }
func NewArrayStack() *ArrayStack {
return &ArrayStack{ func newArrayStack() *arrayStack {
return &arrayStack{
// 设置栈的长度为 0，容量为 16 // 设置栈的长度为 0，容量为 16
data: make([]int, 0, 16), data: make([]int, 0, 16),
} }
} }
// Size 栈的长度
func (s *ArrayStack) Size() int { // size 栈的长度
func (s *arrayStack) size() int {
return len(s.data) return len(s.data)
} }
// IsEmpty 栈是否为空
func (s *ArrayStack) IsEmpty() bool { // isEmpty 栈是否为空
return s.Size() == 0 func (s *arrayStack) isEmpty() bool {
return s.size() == 0
} }
// Push 入栈
func (s *ArrayStack) Push(v int) { // push 入栈
func (s *arrayStack) push(v int) {
// 切片会自动扩容 // 切片会自动扩容
s.data = append(s.data, v) s.data = append(s.data, v)
} }
// Pop 出栈
func (s *ArrayStack) Pop() any { // pop 出栈
func (s *arrayStack) pop() any {
// 弹出栈前，先判断是否为空 // 弹出栈前，先判断是否为空
if s.IsEmpty() { if s.isEmpty() {
return nil return nil
} }
val := s.Peek() val := s.peek()
s.data = s.data[:len(s.data)-1] s.data = s.data[:len(s.data)-1]
return val return val
} }
// Peek 获取栈顶元素
func (s *ArrayStack) Peek() any { // peek 获取栈顶元素
if s.IsEmpty() { func (s *arrayStack) peek() any {
if s.isEmpty() {
return nil return nil
} }
val := s.data[len(s.data)-1] val := s.data[len(s.data)-1]

10
docs/chapter_tree/binary_search_tree.md
View file

@ -103,7 +103,7 @@ comments: true
```go title="binary_search_tree.go" ```go title="binary_search_tree.go"
/* 查找结点 */ /* 查找结点 */
func (bst *BinarySearchTree) Search(num int) *TreeNode { func (bst *binarySearchTree) search(num int) *TreeNode {
node := bst.root node := bst.root
// 循环查找，越过叶结点后跳出 // 循环查找，越过叶结点后跳出
for node != nil { for node != nil {
@ -299,7 +299,7 @@ comments: true
```go title="binary_search_tree.go" ```go title="binary_search_tree.go"
/* 插入结点 */ /* 插入结点 */
func (bst *BinarySearchTree) Insert(num int) *TreeNode { func (bst *binarySearchTree) insert(num int) *TreeNode {
cur := bst.root cur := bst.root
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if cur == nil { if cur == nil {
@ -609,7 +609,7 @@ comments: true
```go title="binary_search_tree.go" ```go title="binary_search_tree.go"
/* 删除结点 */ /* 删除结点 */
func (bst *BinarySearchTree) Remove(num int) *TreeNode { func (bst *binarySearchTree) remove(num int) *TreeNode {
cur := bst.root cur := bst.root
// 若树为空，直接提前返回 // 若树为空，直接提前返回
if cur == nil { if cur == nil {
@ -653,10 +653,10 @@ comments: true
// 子结点数为 2 // 子结点数为 2
} else { } else {
// 获取中序遍历中待删除结点 cur 的下一个结点 // 获取中序遍历中待删除结点 cur 的下一个结点
next := bst.GetInOrderNext(cur) next := bst.getInOrderNext(cur)
temp := next.Val temp := next.Val
// 递归删除结点 next // 递归删除结点 next
bst.Remove(next.Val) bst.remove(next.Val)
// 将 next 的值复制给 cur // 将 next 的值复制给 cur
cur.Val = temp cur.Val = temp
} }