doc(code): modify go code in docs

2024-12-24 20:06:28 +08:00 · 2023-01-08 20:29:13 +08:00 · 2023-01-08 20:29:13 +08:00 · 0243957015
commit 0243957015
parent 33e2c4f4d3
8 changed files with 143 additions and 117 deletions
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@ -864,7 +864,7 @@ comments: true

    ```go title="my_list.go"
    /* 列表类简易实现 */
-    type MyList struct {
+    type myList struct {
        numsCapacity int
        nums         []int
        numsSize     int
@ -872,8 +872,8 @@ comments: true
    }

    /* 构造函数 */
-    func newMyList() *MyList {
-        return &MyList{
+    func newMyList() *myList {
+        return &myList{
            numsCapacity: 10,              // 列表容量
            nums:         make([]int, 10), // 数组（存储列表元素）
            numsSize:     0,               // 列表长度（即当前元素数量）
@ -882,17 +882,17 @@ comments: true
    }

    /* 获取列表长度（即当前元素数量） */
-    func (l *MyList) size() int {
+    func (l *myList) size() int {
        return l.numsSize
    }

    /*  获取列表容量 */
-    func (l *MyList) capacity() int {
+    func (l *myList) capacity() int {
        return l.numsCapacity
    }

    /* 访问元素 */
-    func (l *MyList) get(index int) int {
+    func (l *myList) get(index int) int {
        // 索引如果越界则抛出异常，下同
        if index >= l.numsSize {
            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 {
            panic("索引越界")
        }
@ -909,7 +909,7 @@ comments: true
    }

    /* 尾部添加元素 */
-    func (l *MyList) add(num int) {
+    func (l *myList) add(num int) {
        // 元素数量超出容量时，触发扩容机制
        if l.numsSize == l.numsCapacity {
            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 {
            panic("索引越界")
        }
@ -938,20 +938,23 @@ comments: true
    }

    /* 删除元素 */
-    func (l *MyList) Remove(index int) {
+    func (l *myList) remove(index int) int {
        if index >= l.numsSize {
            panic("索引越界")
        }
+        num := l.nums[index]
        // 索引 i 之后的元素都向前移动一位
        for j := index; j < l.numsSize-1; j++ {
            l.nums[j] = l.nums[j+1]
        }
        // 更新元素数量
        l.numsSize--
+        // 返回被删除元素
+        return num
    }

    /* 列表扩容 */
-    func (l *MyList) extendCapacity() {
+    func (l *myList) extendCapacity() {
        // 新建一个长度为 self.__size 的数组，并将原数组拷贝到新数组
        l.nums = append(l.nums, make([]int, l.numsCapacity*(l.extendRatio-1))...)
        // 更新列表容量
--- a/docs/chapter_computational_complexity/space_complexity.md
+++ b/docs/chapter_computational_complexity/space_complexity.md
@ -103,14 +103,14 @@ comments: true

    ```go title=""
    /* 结构体 */
-    type Node struct {
+    type node struct {
        val  int
-        next *Node
+        next *node
    }
-    
-    /* 创建 Node 结构体 */
-    func newNode(val int) *Node {
-        return &Node{val: val}
+
+    /* 创建 node 结构体  */
+    func newNode(val int) *node {
+        return &node{val: val}
    }
    
    /* 函数 */
@ -687,7 +687,7 @@ $$
        // 长度为 n 的数组占用 O(n) 空间
        _ = make([]int, n)
        // 长度为 n 的列表占用 O(n) 空间
-        var nodes []*Node
+        var nodes []*node
        for i := 0; i < n; i++ {
            nodes = append(nodes, newNode(i))
        }
@ -1108,7 +1108,7 @@ $$

    ```go title="space_complexity.go"
    /* 指数阶（建立满二叉树） */
-    func buildTree(n int) *TreeNode {
+    func buildTree(n int) *treeNode {
        if n == 0 {
            return nil
        }
--- a/docs/chapter_hashing/hash_map.md
+++ b/docs/chapter_hashing/hash_map.md
@ -524,30 +524,30 @@ $$

    ```go title="array_hash_map.go"
    /* 键值对 int->String */
-    type Entry struct {
+    type entry struct {
        key int
        val string
    }

    /* 基于数组简易实现的哈希表 */
-    type ArrayHashMap struct {
-        bucket []*Entry
+    type arrayHashMap struct {
+        bucket []*entry
    }

-    func newArrayHashMap() *ArrayHashMap {
+    func newArrayHashMap() *arrayHashMap {
        // 初始化一个长度为 100 的桶（数组）
-        bucket := make([]*Entry, 100)
-        return &ArrayHashMap{bucket: bucket}
+        bucket := make([]*entry, 100)
+        return &arrayHashMap{bucket: bucket}
    }

    /* 哈希函数 */
-    func (a *ArrayHashMap) hashFunc(key int) int {
+    func (a *arrayHashMap) hashFunc(key int) int {
        index := key % 100
        return index
    }

    /* 查询操作 */
-    func (a *ArrayHashMap) get(key int) string {
+    func (a *arrayHashMap) get(key int) string {
        index := a.hashFunc(key)
        pair := a.bucket[index]
        if pair == nil {
@ -557,16 +557,16 @@ $$
    }

    /* 添加操作 */
-    func (a *ArrayHashMap) put(key int, val string) {
-        pair := &Entry{key: key, val: val}
+    func (a *arrayHashMap) put(key int, val string) {
+        pair := &entry{key: key, val: val}
        index := a.hashFunc(key)
        a.bucket[index] = pair
    }

    /* 删除操作 */
-    func (a *ArrayHashMap) remove(key int) {
+    func (a *arrayHashMap) remove(key int) {
        index := a.hashFunc(key)
-        // 置为空字符，代表删除
+        // 置为 nil ，代表删除
        a.bucket[index] = nil
    }
    ```
--- a/docs/chapter_sorting/merge_sort.md
+++ b/docs/chapter_sorting/merge_sort.md
@ -201,36 +201,35 @@ comments: true
        右子数组区间 [mid + 1, right]
    */
    func merge(nums []int, left, mid, right int) {
-        // 初始化辅助数组 借助 copy模块
+        // 初始化辅助数组 借助 copy 模块
        tmp := make([]int, right-left+1)
        for i := left; i <= right; 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 := left_start, right_start
+        i, j := leftStart, rightStart
        // 通过覆盖原数组 nums 来合并左子数组和右子数组
        for k := left; k <= right; k++ {
            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
-            if i > left_end {
+            if i > leftEnd {
                nums[k] = tmp[j]
                j++
-            // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
-            } else if j > right_end || tmp[i] <= tmp[j] {
+                // 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if j > rightEnd || tmp[i] <= tmp[j] {
                nums[k] = tmp[i]
                i++
-            // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+                // 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
            } else {
                nums[k] = tmp[j]
                j++
            }
        }
    }
-    
-    /* 归并排序 */
+
    func mergeSort(nums []int, left, right int) {
        // 终止条件
        if left >= right {
--- a/docs/chapter_sorting/quick_sort.md
+++ b/docs/chapter_sorting/quick_sort.md
@ -111,21 +111,21 @@ comments: true
    ```go title="quick_sort.go"
    /* 哨兵划分 */
    func partition(nums []int, left, right int) int {
-        //以 nums[left] 作为基准数
+        // 以 nums[left] 作为基准数
        i, j := left, right
        for i < j {
            for i < j && nums[j] >= nums[left] {
-                j-- //从右向左找首个小于基准数的元素
+                j-- // 从右向左找首个小于基准数的元素
            }
            for i < j && nums[i] <= nums[left] {
-                i++ //从左向右找首个大于基准数的元素
+                i++ // 从左向右找首个大于基准数的元素
            }
            //元素交换
            nums[i], nums[j] = nums[j], nums[i]
        }
-        //将基准数交换至两子数组的分界线
+        // 将基准数交换至两子数组的分界线
        nums[i], nums[left] = nums[left], nums[i]
-        return i //返回基准数的索引
+        return i // 返回基准数的索引
    }
    ```

--- a/docs/chapter_stack_and_queue/queue.md
+++ b/docs/chapter_stack_and_queue/queue.md
@ -404,43 +404,49 @@ comments: true

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

    ```go title="array_queue.go"
    /* 基于环形数组实现的队列 */
-    type ArrayQueue struct {
+    type arrayQueue struct {
        data     []int // 用于存储队列元素的数组
        capacity int   // 队列容量（即最多容量的元素个数）
        front    int   // 头指针，指向队首
        rear     int   // 尾指针，指向队尾 + 1
    }
-    // NewArrayQueue 基于环形数组实现的队列
-    func NewArrayQueue(capacity int) *ArrayQueue {
-        return &ArrayQueue{
+
+    // newArrayQueue 基于环形数组实现的队列
+    func newArrayQueue(capacity int) *arrayQueue {
+        return &arrayQueue{
            data:     make([]int, capacity),
            capacity: capacity,
            front:    0,
            rear:     0,
        }
    }
-    // Size 获取队列的长度
-    func (q *ArrayQueue) Size() int {
+
+    // size 获取队列的长度
+    func (q *arrayQueue) size() int {
        size := (q.capacity + q.rear - q.front) % q.capacity
        return size
    }
-    // IsEmpty 判断队列是否为空
-    func (q *ArrayQueue) IsEmpty() bool {
+
+    // isEmpty 判断队列是否为空
+    func (q *arrayQueue) isEmpty() bool {
        return q.rear-q.front == 0
    }
-    // Offer 入队
-    func (q *ArrayQueue) Offer(v int) {
+
+    // offer 入队
+    func (q *arrayQueue) offer(v int) {
        // 当 rear == capacity 表示队列已满
-        if q.Size() == q.capacity {
+        if q.size() == q.capacity {
            return
        }
        // 尾结点后添加
@ -840,9 +850,10 @@ comments: true
        // 尾指针向后移动一位，越过尾部后返回到数组头部
        q.rear = (q.rear + 1) % q.capacity
    }
-    // Poll 出队
-    func (q *ArrayQueue) Poll() any {
-        if q.IsEmpty() {
+
+    // poll 出队
+    func (q *arrayQueue) poll() any {
+        if q.isEmpty() {
            return nil
        }
        v := q.data[q.front]
@ -850,9 +861,10 @@ comments: true
        q.front = (q.front + 1) % q.capacity
        return v
    }
-    // Peek 访问队首元素
-    func (q *ArrayQueue) Peek() any {
-        if q.IsEmpty() {
+
+    // peek 访问队首元素
+    func (q *arrayQueue) peek() any {
+        if q.isEmpty() {
            return nil
        }
        v := q.data[q.front]
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@ -378,43 +378,49 @@ comments: true

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

    ```go title="array_stack.go"
    /* 基于数组实现的栈 */
-    type ArrayStack struct {
+    type arrayStack struct {
        data []int // 数据
    }
-    func NewArrayStack() *ArrayStack {
-        return &ArrayStack{
+
+    func newArrayStack() *arrayStack {
+        return &arrayStack{
            // 设置栈的长度为 0，容量为 16
            data: make([]int, 0, 16),
        }
    }
-    // Size 栈的长度
-    func (s *ArrayStack) Size() int {
+
+    // size 栈的长度
+    func (s *arrayStack) size() int {
        return len(s.data)
    }
-    // IsEmpty 栈是否为空
-    func (s *ArrayStack) IsEmpty() bool {
-        return s.Size() == 0
+
+    // isEmpty 栈是否为空
+    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)
    }
-    // Pop 出栈
-    func (s *ArrayStack) Pop() any {
+
+    // pop 出栈
+    func (s *arrayStack) pop() any {
        // 弹出栈前，先判断是否为空
-        if s.IsEmpty() {
+        if s.isEmpty() {
            return nil
        }
-        val := s.Peek()
+        val := s.peek()
        s.data = s.data[:len(s.data)-1]
        return val
    }
-    // Peek 获取栈顶元素
-    func (s *ArrayStack) Peek() any {
-        if s.IsEmpty() {
+
+    // peek 获取栈顶元素
+    func (s *arrayStack) peek() any {
+        if s.isEmpty() {
            return nil
        }
        val := s.data[len(s.data)-1]
--- a/docs/chapter_tree/binary_search_tree.md
+++ b/docs/chapter_tree/binary_search_tree.md
@ -103,7 +103,7 @@ comments: true

    ```go title="binary_search_tree.go"
    /* 查找结点 */
-    func (bst *BinarySearchTree) Search(num int) *TreeNode {
+    func (bst *binarySearchTree) search(num int) *TreeNode {
        node := bst.root
        // 循环查找，越过叶结点后跳出
        for node != nil {
@ -299,7 +299,7 @@ comments: true

    ```go title="binary_search_tree.go"
    /* 插入结点 */
-    func (bst *BinarySearchTree) Insert(num int) *TreeNode {
+    func (bst *binarySearchTree) insert(num int) *TreeNode {
        cur := bst.root
        // 若树为空，直接提前返回
        if cur == nil {
@ -609,7 +609,7 @@ comments: true

    ```go title="binary_search_tree.go"
    /* 删除结点 */
-    func (bst *BinarySearchTree) Remove(num int) *TreeNode {
+    func (bst *binarySearchTree) remove(num int) *TreeNode {
        cur := bst.root
        // 若树为空，直接提前返回
        if cur == nil {
@ -653,10 +653,10 @@ comments: true
            // 子结点数为 2
        } else {
            // 获取中序遍历中待删除结点 cur 的下一个结点
-            next := bst.GetInOrderNext(cur)
+            next := bst.getInOrderNext(cur)
            temp := next.Val
            // 递归删除结点 next
-            bst.Remove(next.Val)
+            bst.remove(next.Val)
            // 将 next 的值复制给 cur
            cur.Val = temp
        }