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

doc(code): modify go code in docs

Browse source
This commit is contained in:
reanon 2023-01-08 20:29:13 +08:00
parent 33e2c4f4d3
commit 0243957015
8 changed files with 143 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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