doc: update doc for algorithm package

docs/algorithm.md

@@ -60,22 +60,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.BubbleSort(intSlice, comparator)
@@ -85,8 +85,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="InsertionSort">InsertionSort</span>
 <p>Sort slice with insertion sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -105,36 +103,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
+type people struct {
+    Name string
+    Age  int
+}
+
+// PeopleAageComparator sort people slice by age field
+type peopleAgeComparator struct{}
+
+// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+    p1, _ := v1.(people)
+    p2, _ := v2.(people)
+
+    //ascending order
+    if p1.Age < p2.Age {
+        return -1
+    } else if p1.Age > p2.Age {
+        return 1
+    }
+    return 0
+
+    //decending order
+    // if p1.Age > p2.Age {
+    // 	return -1
+    // } else if p1.Age < p2.Age {
+    // 	return 1
+    // }
+}
+
 func main() {
-    type people struct {
-        Name string
-        Age  int
-    }
-
-    // PeopleAageComparator sort people slice by age field
-    type peopleAgeComparator struct{}
-
-    // Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
-    func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
-        p1, _ := v1.(people)
-        p2, _ := v2.(people)
-
-        //ascending order
-        if p1.Age < p2.Age {
-            return -1
-        } else if p1.Age > p2.Age {
-            return 1
-        }
-        return 0
-
-        //decending order
-        // if p1.Age > p2.Age {
-        // 	return -1
-        // } else if p1.Age < p2.Age {
-        // 	return 1
-        // }
-    }
-
     var peoples = []people{
         {Name: "a", Age: 20},
         {Name: "b", Age: 10},
@@ -151,7 +149,6 @@ func main() {
 
 
 
-
 ### <span id="SelectionSort">SelectionSort</span>
 <p>Sort slice with selection sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -170,22 +167,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.SelectionSort(intSlice, comparator)
@@ -195,8 +192,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="ShellSort">ShellSort</span>
 <p>Sort slice with shell sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -215,22 +210,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.ShellSort(intSlice, comparator)
@@ -240,8 +235,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="QuickSort">QuickSort</span>
 <p>Sort slice with quick sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -260,22 +253,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.QuickSort(intSlice, comparator)
@@ -285,8 +278,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="HeapSort">HeapSort</span>
 <p>Sort slice with heap sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -305,22 +296,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.HeapSort(intSlice, comparator)
@@ -330,8 +321,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="MergeSort">MergeSort</span>
 <p>Sort slice with merge sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -350,22 +339,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.MergeSort(intSlice, comparator)
@@ -375,7 +364,6 @@ func main() {
 ```
 
 
-
 ### <span id="CountSort">CountSort</span>
 <p>Sort slice with count sort algorithm. Param comparator should implements lancetconstraints.Comparator.</p>
 
@@ -394,22 +382,23 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+type intComparator struct{}
-        val1, _ := v1.(int)
-        val2, _ := v2.(int)
 
-        //ascending order
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        if val1 < val2 {
+    val1, _ := v1.(int)
-            return -1
+    val2, _ := v2.(int)
-        } else if val1 > val2 {
+
-            return 1
+    //ascending order
-        }
+    if val1 < val2 {
-        return 0
+        return -1
+    } else if val1 > val2 {
+        return 1
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     sortedSlice := algorithm.CountSort(intSlice, comparator)
@@ -419,8 +408,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="BinarySearch">BinarySearch</span>
 <p>BinarySearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
 
@@ -439,22 +426,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
     foundIndex := algorithm.BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
@@ -465,8 +452,6 @@ func main() {
 }
 ```
 
-
-
 ### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
 <p>BinaryIterativeSearch search for target within a sorted slice, recursive call itself. If a target is found, the index of the target is returned. Else the function return -1.</p>
 
@@ -485,22 +470,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
     foundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
@@ -512,15 +497,13 @@ func main() {
 ```
 
 
-
-
 ### <span id="LinearSearch">LinearSearch</span>
-<p>LinearSearch Simple linear search algorithm that iterates over all elements of an slice. If a target is found, the index of the target is returned. Else the function return -1.</p>
+<p>return the index of target in slice base on equal function.If a target is found, the index of the target is returned. Else the function return -1.</p>
 
 <b>Signature:</b>
 
 ```go
-func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int
+func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 <b>Example:</b>
 
@@ -533,34 +516,25 @@ import (
 )
 
 func main() {
-    type intComparator struct{}
+    numbers := []int{3, 4, 5, 3, 2, 1}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+	equalFunc := func(a, b int) bool {
-        val1, _ := v1.(int)
+		return a == b
-        val2, _ := v2.(int)
+	}
 
-        //ascending order
+	result1 := algorithm.LinearSearch(numbers, 3, equalFunc)
-        if val1 < val2 {
+	result2 := algorithm.LinearSearch(numbers, 6, equalFunc)
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
-    }
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+	fmt.Println(result1)
-    comparator := &intComparator{}
+	fmt.Println(result2)
-    foundIndex := algorithm.LinearSearch(intSlice, 5, comparator)
-    fmt.Println(foundIndex) //2
 
-    notFoundIndex := algorithm.LinearSearch(sortedNumbers, 0, comparator)
+	// Output:
-    fmt.Println(notFoundIndex) //-1
+	// 0
+	// -1
 }
 ```
 
 
-
-
 ### <span id="LRUCache">LRUCache</span>
 <p>LRUCache implements mem cache with lru.</p>
 

docs/algorithm_zh-CN.md

@@ -40,8 +40,6 @@ import (
 
 ## 文档
 
-
-
 ### <span id="BubbleSort">BubbleSort</span>
 <p>冒泡排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -60,33 +58,31 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.BubbleSort(intSlice, comparator)
 
     fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
+
 ```
 
-
-
-
 ### <span id="InsertionSort">InsertionSort</span>
 <p>插入排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -105,36 +101,36 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
+type people struct {
+    Name string
+    Age  int
+}
+
+// PeopleAageComparator sort people slice by age field
+type peopleAgeComparator struct{}
+
+// Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
+func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
+    p1, _ := v1.(people)
+    p2, _ := v2.(people)
+
+    //ascending order
+    if p1.Age < p2.Age {
+        return -1
+    } else if p1.Age > p2.Age {
+        return 1
+    }
+    return 0
+
+    //decending order
+    // if p1.Age > p2.Age {
+    // 	return -1
+    // } else if p1.Age < p2.Age {
+    // 	return 1
+    // }
+}
+
 func main() {
-    type people struct {
-        Name string
-        Age  int
-    }
-
-    // PeopleAageComparator sort people slice by age field
-    type peopleAgeComparator struct{}
-
-    // Compare implements github.com/duke-git/lancet/lancetconstraints/constraints.go/Comparator
-    func (pc *peopleAgeComparator) Compare(v1 any, v2 any) int {
-        p1, _ := v1.(people)
-        p2, _ := v2.(people)
-
-        //ascending order
-        if p1.Age < p2.Age {
-            return -1
-        } else if p1.Age > p2.Age {
-            return 1
-        }
-        return 0
-
-        //decending order
-        // if p1.Age > p2.Age {
-        // 	return -1
-        // } else if p1.Age < p2.Age {
-        // 	return 1
-        // }
-    }
-
     var peoples = []people{
         {Name: "a", Age: 20},
         {Name: "b", Age: 10},
@@ -145,13 +141,10 @@ func main() {
     comparator := &peopleAgeComparator{}
     algorithm.InsertionSort(peoples, comparator)
 
-    fmt.Println(intSlice) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
+    fmt.Println(peoples) //[{d 8} {b 10} {c 17} {a 20} {e 28}]
 }
 ```
 
-
-
-
 ### <span id="SelectionSort">SelectionSort</span>
 <p>选择排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -170,22 +163,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.SelectionSort(intSlice, comparator)
@@ -194,9 +187,6 @@ func main() {
 }
 ```
 
-
-
-
 ### <span id="ShellSort">ShellSort</span>
 <p>希尔排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -215,22 +205,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.ShellSort(intSlice, comparator)
@@ -240,8 +230,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="QuickSort">QuickSort</span>
 <p>快速排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -260,22 +248,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.QuickSort(intSlice, comparator)
@@ -285,8 +273,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="HeapSort">HeapSort</span>
 <p>堆排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -305,33 +291,31 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.HeapSort(intSlice, comparator)
 
     fmt.Println(intSlice) //[]int{1, 2, 3, 4, 5, 6}
 }
+
 ```
 
-
-
-
 ### <span id="MergeSort">MergeSort</span>
 <p>归并排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -350,22 +334,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     algorithm.MergeSort(intSlice, comparator)
@@ -375,7 +359,6 @@ func main() {
 ```
 
 
-
 ### <span id="CountSort">CountSort</span>
 <p>计数排序，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -394,22 +377,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     intSlice := []int{2, 1, 5, 3, 6, 4}
     comparator := &intComparator{}
     sortedSlice := algorithm.CountSort(intSlice, comparator)
@@ -419,8 +402,6 @@ func main() {
 ```
 
 
-
-
 ### <span id="BinarySearch">BinarySearch</span>
 <p>二分递归查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
 
@@ -439,22 +420,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
     foundIndex := algorithm.BinarySearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
@@ -463,8 +444,8 @@ func main() {
     notFoundIndex := algorithm.BinarySearch(sortedNumbers, 9, 0, len(sortedNumbers)-1, comparator)
     fmt.Println(notFoundIndex) //-1
 }
-```
 
+```
 
 
 ### <span id="BinaryIterativeSearch">BinaryIterativeSearch</span>
@@ -485,22 +466,22 @@ import (
     "github.com/duke-git/lancet/v2/algorithm"
 )
 
-func main() {
+type intComparator struct{}
-    type intComparator struct{}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+func (c *intComparator) Compare(v1 any, v2 any) int {
-        val1, _ := v1.(int)
+    val1, _ := v1.(int)
-        val2, _ := v2.(int)
+    val2, _ := v2.(int)
 
-        //ascending order
+    //ascending order
-        if val1 < val2 {
+    if val1 < val2 {
-            return -1
+        return -1
-        } else if val1 > val2 {
+    } else if val1 > val2 {
-            return 1
+        return 1
-        }
-        return 0
     }
+    return 0
+}
 
+func main() {
     var sortedNumbers = []int{1, 2, 3, 4, 5, 6, 7, 8}
     comparator := &intComparator{}
     foundIndex := algorithm.BinaryIterativeSearch(sortedNumbers, 5, 0, len(sortedNumbers)-1, comparator)
@@ -515,12 +496,12 @@ func main() {
 
 
 ### <span id="LinearSearch">LinearSearch</span>
-<p>线性查找，返回元素索引，未找到元素返回-1，参数comparator需要实现包lancetconstraints.Comparator</p>
+<p>基于传入的相等函数线性查找元素，返回元素索引，未找到元素返回-1</p>
 
 <b>函数签名:</b>
 
 ```go
-func LinearSearch[T any](slice []T, target T, comparator lancetconstraints.Comparator) int
+func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 <b>Example:</b>
 
@@ -533,34 +514,25 @@ import (
 )
 
 func main() {
-    type intComparator struct{}
+    numbers := []int{3, 4, 5, 3, 2, 1}
 
-    func (c *intComparator) Compare(v1 any, v2 any) int {
+	equalFunc := func(a, b int) bool {
-        val1, _ := v1.(int)
+		return a == b
-        val2, _ := v2.(int)
+	}
 
-        //ascending order
+	result1 := algorithm.LinearSearch(numbers, 3, equalFunc)
-        if val1 < val2 {
+	result2 := algorithm.LinearSearch(numbers, 6, equalFunc)
-            return -1
-        } else if val1 > val2 {
-            return 1
-        }
-        return 0
-    }
 
-    intSlice := []int{2, 1, 5, 3, 6, 4}
+	fmt.Println(result1)
-    comparator := &intComparator{}
+	fmt.Println(result2)
-    foundIndex := algorithm.LinearSearch(intSlice, 5, comparator)
-    fmt.Println(foundIndex) //2
 
-    notFoundIndex := algorithm.LinearSearch(sortedNumbers, 0, comparator)
+	// Output:
-    fmt.Println(notFoundIndex) //-1
+	// 0
+	// -1
 }
 ```
 
 
-
-
 ### <span id="LRUCache">LRUCache</span>
 <p>lru实现缓存</p>