Fix "函数" and "方法"

codes/c/chapter_tree/avl_tree.c

@@ -111,7 +111,7 @@ TreeNode *rotate(TreeNode *node) {
     return node;
 }
 
-/* 递归插入节点（辅助方法） */
+/* 递归插入节点（辅助函数） */
 TreeNode *insertHelper(TreeNode *node, int val) {
     if (node == NULL) {
         return newTreeNode(val);
@@ -138,7 +138,7 @@ void insert(aVLTree *tree, int val) {
     tree->root = insertHelper(tree->root, val);
 }
 
-/* 递归删除节点（辅助方法） */
+/* 递归删除节点（辅助函数） */
 TreeNode *removeHelper(TreeNode *node, int val) {
     TreeNode *child, *grandChild;
     if (node == NULL) {

codes/go/chapter_array_and_linkedlist/array_test.go

@@ -21,7 +21,7 @@ func TestArray(t *testing.T) {
 	fmt.Println("数组 arr =", arr)
 	// 在 Go 中，指定长度时（[5]int）为数组，不指定长度时（[]int）为切片
 	// 由于 Go 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
-	// 为了方便实现扩容 extend() 方法，以下将切片（Slice）看作数组（Array）
+	// 为了方便实现扩容 extend() 函数，以下将切片（Slice）看作数组（Array）
 	nums := []int{1, 3, 2, 5, 4}
 	fmt.Println("数组 nums =", nums)
 

codes/go/chapter_array_and_linkedlist/my_list.go

@@ -12,7 +12,7 @@ type myList struct {
 	extendRatio  int
 }
 
-/* 构造方法 */
+/* 构造函数 */
 func newMyList() *myList {
 	return &myList{
 		numsCapacity: 10,              // 列表容量

codes/go/chapter_graph/graph_adjacency_list.go

@@ -18,7 +18,7 @@ type graphAdjList struct {
 	adjList map[Vertex][]Vertex
 }
 
-/* 构造方法 */
+/* 构造函数 */
 func newGraphAdjList(edges [][]Vertex) *graphAdjList {
 	g := &graphAdjList{
 		adjList: make(map[Vertex][]Vertex),

codes/go/chapter_graph/graph_adjacency_matrix.go

@@ -14,7 +14,7 @@ type graphAdjMat struct {
 	adjMat [][]int
 }
 
-/* 构造方法 */
+/* 构造函数 */
 func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
 	// 添加顶点
 	n := len(vertices)

codes/go/chapter_heap/heap.go

@@ -8,14 +8,14 @@ package chapter_heap
 // 实现 heap.Interface 需要同时实现 sort.Interface
 type intHeap []any
 
-// Push heap.Interface 的方法，实现推入元素到堆
+// Push heap.Interface 的函数，实现推入元素到堆
 func (h *intHeap) Push(x any) {
 	// Push 和 Pop 使用 pointer receiver 作为参数
 	// 因为它们不仅会对切片的内容进行调整，还会修改切片的长度。
 	*h = append(*h, x.(int))
 }
 
-// Pop heap.Interface 的方法，实现弹出堆顶元素
+// Pop heap.Interface 的函数，实现弹出堆顶元素
 func (h *intHeap) Pop() any {
 	// 待出堆元素存放在最后
 	last := (*h)[len(*h)-1]
@@ -23,18 +23,18 @@ func (h *intHeap) Pop() any {
 	return last
 }
 
-// Len sort.Interface 的方法
+// Len sort.Interface 的函数
 func (h *intHeap) Len() int {
 	return len(*h)
 }
 
-// Less sort.Interface 的方法
+// Less sort.Interface 的函数
 func (h *intHeap) Less(i, j int) bool {
 	// 如果实现小顶堆，则需要调整为小于号
 	return (*h)[i].(int) > (*h)[j].(int)
 }
 
-// Swap sort.Interface 的方法
+// Swap sort.Interface 的函数
 func (h *intHeap) Swap(i, j int) {
 	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
 }

codes/go/chapter_heap/heap_test.go

@@ -13,14 +13,14 @@ import (
 )
 
 func testPush(h *intHeap, val int) {
-	// 调用 heap.Interface 的方法，来添加元素
+	// 调用 heap.Interface 的函数，来添加元素
 	heap.Push(h, val)
 	fmt.Printf("\n元素 %d 入堆后 \n", val)
 	PrintHeap(*h)
 }
 
 func testPop(h *intHeap) {
-	// 调用 heap.Interface 的方法，来移除元素
+	// 调用 heap.Interface 的函数，来移除元素
 	val := heap.Pop(h)
 	fmt.Printf("\n堆顶元素 %d 出堆后 \n", val)
 	PrintHeap(*h)

codes/go/chapter_heap/my_heap.go

@@ -15,14 +15,14 @@ type maxHeap struct {
 	data []any
 }
 
-/* 构造方法，建立空堆 */
+/* 构造函数，建立空堆 */
 func newHeap() *maxHeap {
 	return &maxHeap{
 		data: make([]any, 0),
 	}
 }
 
-/* 构造方法，根据切片建堆 */
+/* 构造函数，根据切片建堆 */
 func newMaxHeap(nums []any) *maxHeap {
 	// 将列表元素原封不动添加进堆
 	h := &maxHeap{data: nums}

codes/go/chapter_tree/avl_tree.go

@@ -111,7 +111,7 @@ func (t *aVLTree) insert(val int) {
 	t.root = t.insertHelper(t.root, val)
 }
 
-/* 递归插入节点（辅助方法） */
+/* 递归插入节点（辅助函数） */
 func (t *aVLTree) insertHelper(node *TreeNode, val int) *TreeNode {
 	if node == nil {
 		return NewTreeNode(val)
@@ -138,7 +138,7 @@ func (t *aVLTree) remove(val int) {
 	t.root = t.removeHelper(t.root, val)
 }
 
-/* 递归删除节点（辅助方法） */
+/* 递归删除节点（辅助函数） */
 func (t *aVLTree) removeHelper(node *TreeNode, val int) *TreeNode {
 	if node == nil {
 		return nil

codes/go/pkg/vertex.go

@@ -9,7 +9,7 @@ type Vertex struct {
 	Val int
 }
 
-// NewVertex 构造方法
+// NewVertex 构造函数
 func NewVertex(val int) Vertex {
 	return Vertex{
 		Val: val,