feat(Go-Tool)：

2021/02/23:删除linq包使用示例，修改二进制工具与单测类，修改lomuto划分，修改前缀树与单测类，修改时间比较工具

util/bitOperation/BitTool.go

@@ -13,7 +13,8 @@ import (
 //判断num的二进制表示某个位置是否为1
 func JudgeOneWithPosition(num int, position int) bool {
 	if position < 1 {
-		panic(fmt.Sprintf("输入有误：Position不能小于1，当前出入的Position为%d", position))
+		panic(fmt.Sprintf("输入有误：Position不能小于1，"+
+			"当前出入的Position为%d", position))
 	}
 	return num&(1<<uint(position-1)) != 0
 }
@@ -30,16 +31,17 @@ func JudgeIfOdd(num int) bool {
 
 //判断一个数的二进制形式是否只有一个位置为1,这个方法可以用来判断是不是2的n次方
 func JudgeOnlyOneBitWithOne(num int) bool {
-	//解析：num & (num -1) 当num为2的N次方的时候, 2N次方 & (2N次方 - 1) ，因为做了最高位的右移（2N次方只有一个1，2N次方-1除了2N次方的那一个1的位置为0，其他都为1）
-	//所以&的结果就是 0 ，而0 & 2N次方一定是0，所以如果结果是0，那么一定是2N次方，只有一个位置有1
-	//那么 num & (num -1) 当num不是2的N次方的时候,他的结果原来有1的最高位置，一定为1，所以再和num进行 & 操作的时候,结果也一定是大于0，所以不止一个1
-	return num&(num&(num-1)) == 0
+	if num == 0 {
+		return false
+	}
+	return num&(num-1) == 0
 }
 
 //设置num的某一个位置为1，如果原来就是1的话，就不发生变化
 func SetOneByPosition(num int, position int) int {
 	if position < 1 {
-		panic(fmt.Sprintf("输入有误：Position不能小于1，当前出入的Position为%d", position))
+		panic(fmt.Sprintf("输入有误：Position不能小于1，"+
+			"当前出入的Position为%d", position))
 	}
 	return num | (1 << uint(position-1))
 }
@@ -52,7 +54,8 @@ func JudgeWithEqualSymbol(num1 int, num2 int) bool {
 //设置某一个数num的二进制Position位为0
 func SetZeroBuPosition(num int, position int) int {
 	if position < 1 {
-		panic(fmt.Sprintf("输入有误：Position不能小于1，当前出入的Position为%d", position))
+		panic(fmt.Sprintf("输入有误：Position不能小于1，"+
+			"当前出入的Position为%d", position))
 	}
 	return num &^ (1 << uint(position-1))
 }

util/bitOperation/BitTool_test.go

@@ -102,12 +102,9 @@ func TestJudgeIfEven(t *testing.T) {
 
 func TestJudgeOnlyOneBitWithOne(t *testing.T) {
 	fmt.Println("判断二进制表示是不是只有一个位为1")
-	fmt.Println(JudgeOnlyOneBitWithOne(1))
-	fmt.Println(JudgeOnlyOneBitWithOne(2))
-	fmt.Println(JudgeOnlyOneBitWithOne(3))
-	fmt.Println(JudgeOnlyOneBitWithOne(4))
-	fmt.Println(JudgeOnlyOneBitWithOne(56))
-	fmt.Println(JudgeOnlyOneBitWithOne(64))
+	for i := 0; i <= 32; i++ {
+		fmt.Println(fmt.Sprintf("%d是不是2的n次方，结果为%v", i, JudgeOnlyOneBitWithOne(i)))
+	}
 	fmt.Println()
 	fmt.Println(JudgeOnlyOneBitWithOne(-1))
 	fmt.Println(JudgeOnlyOneBitWithOne(-2))

util/bitStore/BitStoreTool.go

@@ -73,10 +73,25 @@ func (bitStore *BitStore) ReceiveByGear(gear int) ([]int, map[int]bool) {
 	bitStore.checkIfReceive(gear)                      //校验是否被领取了
 	length := bitStore.dynamicGrowth(gear)             //数组进行动态增长
 	position := bitStore.getGearPosition(gear, length) //获取档位在数组中的位数位置
-	bitStore.GearPickList[length-1] = bitStore.GearPickList[length-1] + (1 << uint(position))
+	bitStore.GearPickList[length-1] = bitStore.GearPickList[length-1] | (1 << uint(position))
 	return bitStore.GearPickList, bitStore.FindAllGearMap()
 }
 
+//设置某一档位为未领取
+func (bitStore *BitStore) UnReceiveByGear(gear int) ([]int, map[int]bool) {
+	bitStore.checkIfUnReceive(gear)                    //检验是否被领取
+	length := bitStore.dynamicGrowth(gear)             //数组进行动态增长
+	position := bitStore.getGearPosition(gear, length) //获取档位在数组中的位数位置
+	bitStore.GearPickList[length-1] = bitStore.GearPickList[length-1] - (1 << uint(position))
+	return bitStore.GearPickList, bitStore.FindAllGearMap()
+}
+
+func (bitStore *BitStore) checkIfUnReceive(gear int) {
+	if !bitStore.IsGearReceive(gear) {
+		panic("当前档位未领取，不可重置")
+	}
+}
+
 //判断档位是否正确
 func (bitStore *BitStore) checkGearRight(gear int) {
 	if gear > bitStore.MaxGear {
@@ -91,7 +106,7 @@ func (bitStore *BitStore) getGearListLength(gear int) int {
 
 //获取档位所在的二进制位置
 func (bitStore *BitStore) getGearPosition(gear, length int) int {
-	return gear - realBit*(length-1) - 1
+	return (gear - 1) - realBit*(length-1)
 }
 
 func (bitStore *BitStore) getSizeOrInit() int {
@@ -115,7 +130,8 @@ func (bitStore *BitStore) shortListDeal(listSize, length int) map[int]bool {
 	resultMap := make(map[int]bool, 0)
 	for i := 0; i < listSize; i++ {
 		for j := 0; j < realBit; j++ {
-			resultMap[i*realBit+j+1] = (bitStore.GearPickList[i] & (1 << uint(j))) > 0
+			resultMap[i*realBit+j+1] =
+				(bitStore.GearPickList[i] & (1 << uint(j))) > 0
 		}
 	}
 	for i := listSize; i < length; i++ {

util/linqUse/DataInit.go

@@ -1,127 +0,0 @@
-/*
- *  @Author : huangzj
- *  @Time : 2020/11/12 14:04
- *  @Description：
- */
-
-package linqUse
-
-import "time"
-
-type Book struct {
-	Name        string
-	Author      string
-	Money       float64
-	WordsNum    int
-	PublishTime time.Time
-}
-
-func MakeBook() []Book {
-	bookList := make([]Book, 0)
-	bookList = append(bookList, Book{
-		Name:        "Go语言",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Effective Java",
-		Author:      "Java",
-		Money:       78,
-		WordsNum:    9000,
-		PublishTime: time.Date(2020, 2, 15, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Java语言",
-		Author:      "Java",
-		Money:       50,
-		WordsNum:    3000,
-		PublishTime: time.Date(2020, 2, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Lua语言",
-		Author:      "Lua",
-		Money:       75,
-		WordsNum:    45000,
-		PublishTime: time.Date(2020, 1, 10, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "React语言",
-		Author:      "React",
-		Money:       99,
-		WordsNum:    14500,
-		PublishTime: time.Date(2020, 7, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Red语言",
-		Author:      "Red",
-		Money:       28,
-		WordsNum:    880,
-		PublishTime: time.Date(2019, 4, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "JavaScript语言",
-		Author:      "JavaScript",
-		Money:       81,
-		WordsNum:    3776,
-		PublishTime: time.Date(2019, 5, 17, 10, 0, 0, 0, time.Local),
-	})
-	return bookList
-}
-
-func MakeBook1() []Book {
-	bookList := make([]Book, 0)
-	bookList = append(bookList, Book{
-		Name:        "Go语言",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Effective Java",
-		Author:      "Java",
-		Money:       78,
-		WordsNum:    9000,
-		PublishTime: time.Date(2020, 2, 15, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Go语言(第二版)",
-		Author:      "Go",
-		Money:       50,
-		WordsNum:    3000,
-		PublishTime: time.Date(2020, 2, 1, 10, 0, 0, 0, time.Local),
-	})
-	return bookList
-}
-func MakeBook2() []Book {
-	bookList := make([]Book, 0)
-	bookList = append(bookList, Book{
-		Name:        "Go语言",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})
-	return bookList
-}
-
-func MakeBook3() []Book {
-	bookList := make([]Book, 0)
-	bookList = append(bookList, Book{
-		Name:        "Go语言",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList = append(bookList, Book{
-		Name:        "Go语言(第三版)",
-		Author:      "Go",
-		Money:       50,
-		WordsNum:    3000,
-		PublishTime: time.Date(2020, 2, 1, 10, 0, 0, 0, time.Local),
-	})
-	return bookList
-}

util/linqUse/DataInit2.go

@@ -1,57 +0,0 @@
-/*
- *  @Author : huangzj
- *  @Time : 2020/11/24 16:17
- *  @Description：
- */
-
-package linqUse
-
-type Person struct {
-	Name string //拥有者的名字
-}
-
-type Pet struct {
-	Name      string //动物的名字
-	OwnerName string //拥有者的名字
-}
-
-type Man struct {
-	Name string //拥有者的名字
-	Pets []Pets //宠物们
-}
-
-type Pets struct {
-	Name string //动物的名字
-}
-
-func MakeInnerData() []Man {
-	man := make([]Man, 0)
-	man = append(man, Man{
-		Name: "康康",
-		Pets: []Pets{{Name: "康康的狗"}, {Name: "康康的猫"}},
-	})
-	man = append(man, Man{
-		Name: "老施",
-		Pets: []Pets{{Name: "老施的🐟"}, {Name: "老施的鸟"}},
-	})
-	man = append(man, Man{
-		Name: "小明",
-		Pets: []Pets{{Name: "小明的🐖"}, {Name: "小明的狗"}},
-	})
-
-	return man
-}
-
-func MakeJoinData() ([]Person, []Pet) {
-	kangkang := Person{Name: "爱吃合合乐的康康"}
-	laoshi := Person{Name: "老施"}
-	xiaoming := Person{Name: "不要催-小明"}
-	expect := Person{Name: "我是没有宠物的人"}
-
-	dog := Pet{Name: "康康的狗", OwnerName: kangkang.Name}
-	cat := Pet{Name: "康康的猫", OwnerName: kangkang.Name}
-	fish := Pet{Name: "老施的🐟", OwnerName: laoshi.Name}
-	pig := Pet{Name: "小明的🐖", OwnerName: xiaoming.Name}
-
-	return []Person{kangkang, laoshi, xiaoming, expect}, []Pet{dog, cat, fish, pig}
-}

util/linqUse/FuncSet.go

@@ -1,41 +0,0 @@
-/*
- *  @Author : huangzj
- *  @Time : 2020/11/12 14:43
- *  @Description：测试方法集合
- */
-
-package linqUse
-
-import "time"
-
-//书籍发布时间是否早于--.--.--
-var PublishTimeBeforeFunc = func(thisBook interface{}) bool {
-	if thisBook.(Book).PublishTime.Before(time.Date(2019, 1, 1, 0, 0, 0, 0, time.Local)) {
-		return true
-	}
-	return false
-}
-
-//书籍发布时间是否晚于--.--.--
-var PublishTimeAfterFunc = func(thisBook interface{}) bool {
-	if thisBook.(Book).PublishTime.After(time.Date(2018, 1, 1, 0, 0, 0, 0, time.Local)) {
-		return true
-	}
-	return false
-}
-
-//书籍发布时间是否晚于--.--.--
-var PublishTimeAfterFunc2 = func(thisBook interface{}) bool {
-	if thisBook.(Book).PublishTime.After(time.Date(2021, 1, 1, 0, 0, 0, 0, time.Local)) {
-		return true
-	}
-	return false
-}
-
-//自定义聚合操作方法
-var AggregateFunc = func(first interface{}, second interface{}) interface{} {
-	if first.(Book).PublishTime.Before(second.(Book).PublishTime) {
-		return first
-	}
-	return second
-}

util/linqUse/LinqUse_test.go

@@ -1,531 +0,0 @@
-/*
- *  @Author : huangzj
- *  @Time : 2020/11/12 10:52
- *  @Description：这边是linq包的使用操作，为之后的使用做一些示例
- *  包引用命令： go get github.com/ahmetb/go-linq
- *  示例参考地址：https://godoc.org/github.com/ahmetb/go-linq#
- *  在Idea中对应方法名上使用 Shift+F1 组合键操作可以直接跳转到方法对应的地址
- */
-
-package linqUse
-
-import (
-	"Go-Tool/util/timed"
-	"fmt"
-	"github.com/ahmetb/go-linq"
-	"strconv"
-	"testing"
-	"time"
-)
-
-func Test(t *testing.T) {
-
-	Aggregate() //自定义聚合操作
-
-	All() //判断数组的所有元素是否都满足条件
-
-	Where() //根据条件查询对应的元素
-
-	AnyWith() //判断数组是否有任意个元素满足条件
-
-	Calculate() //这个方法只能计算数值类型
-
-	Combine() //组合两个数组的两种方式
-
-	Contains() //包含
-
-	FirstAndLast() //第一个和最后一个
-
-	Distinct() //返回数组中唯一的元素
-
-	Except() //返回第一个序列没有出现在第二个序列中的成员
-
-	GroupBy() //按照对应规则进行分组
-
-	Intersect() //产生两个数组的交集
-
-	OrderBy() //排序
-
-	Skip() //略过指定条件的元素
-
-	Count() //计算数组总长度
-
-	Result() //对结果集进行操作
-
-	Take() //获取对应数量的元素，一般多用在排序后前几个的元素
-
-	Select() //筛选结构体中对应的元素
-
-	SelectMany() //对多维数组进行合并或者其他处理 对结构体中的数组进行处理(与结构体结合操作)
-
-	Join() //对两个有关联的数据进行处理
-
-}
-
-func Where() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	fmt.Println()
-	fmt.Println()
-	query.WhereT(func(book Book) bool {
-		return book.Money > float64(70)
-	}).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
-	})
-}
-
-func Take() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	query.OrderByDescendingT(func(book Book) string {
-		return book.Author
-	}).Take(3).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
-	})
-
-	fmt.Println()
-	fmt.Println()
-
-	//超出对应数量的元素会不会报错（输出所有的元素）
-	query.OrderByDescendingT(func(book Book) string {
-		return book.Author
-	}).Take(100).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
-	})
-
-	fmt.Println()
-	fmt.Println()
-	//负数会发生什么情况(直接返回，不做操作)
-	query.OrderByDescendingT(func(book Book) string {
-		return book.Author
-	}).Take(-2).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
-	})
-
-	//TakeWhile系列的方法，虽然能够根据条件进行查询，但是有一个弊端就是一旦查询到的结果和条件不符合则直接返回，也就是说后面满足条件的元素不会再被做筛选
-	//那么比如这边的这个大于的操作，就需要对整个数组进行排序之后然后进行筛选，如果不希望排序，则用原生的for循环可能会更好
-	fmt.Println()
-	fmt.Println()
-	query.TakeWhileT(func(book Book) bool {
-		return book.Money > float64(70)
-	}).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", book.Author, book.Name))
-	})
-}
-
-func Result() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-
-	bookMap := make(map[string]string, 0)
-	query.SelectT(func(book Book) linq.KeyValue {
-		return linq.KeyValue{
-			Key:   book.Author,
-			Value: book.Name,
-		}
-	}).ToMap(&bookMap)
-
-	for key, value := range bookMap {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", key, value))
-	}
-
-	fmt.Println()
-	fmt.Println()
-
-	//如果key相同的话，前面的元素会被覆盖掉（只会保留最后一个）
-	bookList1 := MakeBook1()
-	query1 := linq.From(bookList1)
-	bookMap1 := make(map[string]string, 0)
-	query1.SelectT(func(book Book) linq.KeyValue {
-		return linq.KeyValue{
-			Key:   book.Author,
-			Value: book.Name,
-		}
-	}).ToMap(&bookMap1)
-
-	for key, value := range bookMap1 {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", key, value))
-	}
-
-	fmt.Println()
-	fmt.Println()
-	bookList2 := MakeBook()
-	query2 := linq.From(bookList2)
-
-	bookMap2 := make(map[string]Book, 0)
-	query2.ToMapByT(&bookMap2,
-		//这个方法决定key的字段是什么
-		func(book Book) string {
-			return book.Author
-		}, //这个方法决定value的字段是什么
-		func(book Book) Book {
-			return book
-		})
-
-	for key, value := range bookMap2 {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", key, value.Name))
-	}
-
-	fmt.Println()
-	fmt.Println()
-	bookListResult := make([]Book, 0)
-	linq.From(MakeBook()).OrderByDescendingT(func(book Book) string {
-		return book.Author
-	}).ToSlice(&bookListResult)
-	for _, value := range bookListResult {
-		fmt.Println(fmt.Sprintf("作者%v，写了一本书叫做%v", value.Author, value.Name))
-	}
-}
-
-func Count() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	fmt.Println(fmt.Sprintf("数组中发布时间早于2019-1-1的书有%d本", query.CountWithT(PublishTimeBeforeFunc)))
-	fmt.Println(fmt.Sprintf("数组中发布时间晚于2018-1-1的书有%d本", query.CountWithT(PublishTimeAfterFunc)))
-}
-
-func Skip() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-
-	fmt.Println(fmt.Sprintf("跳过三个元素，返回的数组中包含%d个元素", len(query.Skip(3).Results())))
-	fmt.Println(fmt.Sprintf("跳过发布时间在2018.1.1之后的元素，返回的数组中包含%d个元素", query.SkipWhile(PublishTimeAfterFunc).Count()))
-}
-
-func SelectMany() {
-	input := [][]int{{1, 2, 3}, {4, 5, 6, 7}}
-
-	//二位数组进行合并
-	linq.From(input).SelectManyT(
-		func(i []int) linq.Query {
-			return linq.From(i)
-		},
-	).ForEachT(func(num int) {
-		fmt.Println(num)
-	})
-
-	fmt.Println()
-	fmt.Println()
-
-	//三维数组进行合并
-	input1 := [][][]int{{{1, 2, 3}}, {{4, 5, 6, 7}, {8, 9, 10}}}
-	linq.From(input1).SelectManyT(
-		func(i [][]int) linq.Query {
-			return linq.From(i)
-		},
-	).SelectManyT(
-		func(i []int) linq.Query {
-			return linq.From(i)
-		},
-	).ForEachT(func(num int) {
-		fmt.Print(num)
-		fmt.Print(" ")
-	})
-
-	//SelectMany的主要作用是,结构体中包含数组元素，可以把数组元素取出来和结构体做相应的操作
-	//如果是结构体中有多个数组的操作，可以把对应的多个数组放到一个新定义的结构体数组中
-	fmt.Println()
-	men := MakeInnerData()
-	linq.From(men).
-		//第一个方法筛选出结构体对应的数组
-		SelectManyByT(func(man Man) linq.Query {
-			return linq.From(man.Pets)
-		},
-			//第二个方法这边可以拿到数组中元素对应的结构体的数据.
-			func(pet Pets, man Man) map[string]Pets {
-				return map[string]Pets{
-					man.Name: pet,
-				}
-			}).ForEachT(func(petWithMan map[string]Pets) {
-		for key, value := range petWithMan {
-			fmt.Println(fmt.Sprintf("%v拥有一只宠物，它的名字叫做%v", key, value.Name))
-		}
-	})
-
-}
-
-func Select() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-
-	//筛选出结构体对应的元素
-	query.SelectT(func(book Book) string {
-		return book.Name
-	}).ForEachT(func(bookName string) {
-		fmt.Println(fmt.Sprintf("书名%v", bookName))
-	})
-
-	fmt.Println()
-	fmt.Println()
-
-	//根据下标进行返回，如果是跟下标有关的，则可以通过这个方法进行组合然后返回.
-	query.SelectIndexedT(func(index int, book Book) []string {
-		return []string{strconv.Itoa(index + 1), book.Name}
-	}).ForEachT(func(book []string) {
-		fmt.Println(fmt.Sprintf("第%v本书,书名%v", book[0], book[1]))
-	})
-}
-
-//OrderBy可以按照对应的规则进行排序，可以实现多重排序，需要注意的就是OrderBy是从到达，orderByDescending是从大到小
-func OrderBy() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	query = query.OrderByDescendingT(func(book Book) string {
-		return book.Name
-	}).ThenByDescendingT(func(book Book) string {
-		return book.Author
-	}).ThenByDescendingT(func(book Book) float64 {
-		return book.Money
-	}).Query
-
-	query.ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-
-	fmt.Println()
-	fmt.Println()
-
-	//reverse: 把结果逆序
-	query.Reverse().ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-}
-
-func Join() {
-	//任务和动物有关联，直接找到对应的关系，没有对应关系的数据不会处理，正常情况下应该用更单一的数据来做关联
-	persons, pets := MakeJoinData()
-	query1 := linq.From(persons)
-	query2 := linq.From(pets)
-	query1.JoinT(query2,
-		func(person Person) string {
-			return person.Name
-		},
-		func(pet Pet) string {
-			return pet.OwnerName
-		},
-		func(person Person, pet Pet) map[string]Pet {
-			petMap := make(map[string]Pet)
-			petMap[person.Name] = pet
-			return petMap
-		},
-	).ForEachT(func(petMap map[string]Pet) {
-		for key, value := range petMap {
-			fmt.Println(fmt.Sprintf("%v拥有一只宠物，它的名字叫做:%v", key, value.Name))
-		}
-	})
-}
-
-func Intersect() {
-	bookList1 := MakeBook1()
-	query1 := linq.From(bookList1)
-	bookList2 := MakeBook2()
-	query2 := linq.From(bookList2)
-
-	fmt.Println("输出对应的书籍元素，按照结构体判断交集")
-	query3 := query1.Intersect(query2)
-	query3.ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-
-	fmt.Println()
-	fmt.Println("输出对应的书籍元素，按照元素判断交集")
-	query3 = query1.IntersectByT(query2, func(book Book) string {
-		return book.Author
-	})
-	query3.ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-
-	//这边计算是按照结构体的一个元素进行比较。事实证明无论是否按照结构体的元素筛选，返回的都是完全相同的元素
-	fmt.Println()
-	fmt.Println("输出对应的书籍元素，按照元素判断交集2")
-	bookList1 = MakeBook1()
-	query1 = linq.From(bookList1)
-	bookList3 := MakeBook3()
-	query2 = linq.From(bookList3)
-	query3 = query2.IntersectByT(query1, func(book Book) string {
-		return book.Author
-	})
-	query3.ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-
-	fmt.Println()
-	fmt.Println("判断是否会不重复的处理")
-	query1 = linq.From([]int{1, 2, 3, 4, 5, 3})
-	query2 = linq.From([]int{1, 3, 3, 78, 99, 0, 111})
-	query3 = query2.IntersectByT(query1, func(i int) int {
-		return i
-	})
-	fmt.Println(query3.Results())
-}
-
-func GroupBy() {
-	bookList1 := MakeBook1()
-	query := linq.From(bookList1)
-
-	fmt.Println("输出对应书名和作者")
-	//第一个func是分组的依据，第二个func是分组后返回的元素.
-	query = query.GroupByT(func(book Book) string {
-		return book.Author
-	}, func(book Book) Book {
-		return book
-	})
-
-	query.ForEachT(func(bookGroup linq.Group) {
-		fmt.Println(fmt.Sprintf("作者是%v", bookGroup.Key))
-		for _, item := range bookGroup.Group {
-			fmt.Println(fmt.Sprintf("书名%v,作者%v", item.(Book).Name, item.(Book).Author))
-			fmt.Println()
-		}
-
-	})
-	fmt.Println()
-	fmt.Println("输出对应书名")
-
-	bookList1 = MakeBook1()
-	query = linq.From(bookList1)
-	var nameGroups []linq.Group
-	query.GroupByT(
-		func(book Book) string { return book.Author },
-		func(book Book) string { return book.Name },
-	).ToSlice(&nameGroups)
-
-	for _, item := range nameGroups {
-		fmt.Println(fmt.Sprintf("作者是%v", item.Key))
-		for _, row := range item.Group {
-			fmt.Println(fmt.Sprintf("书名%v", row))
-		}
-	}
-}
-
-func Except() {
-	bookList1 := MakeBook1()
-	query1 := linq.From(bookList1)
-	bookList2 := MakeBook2()
-	query2 := linq.From(bookList2)
-
-	fmt.Println("输出对应书名和作者")
-	//判断结构结构体本身是否相等
-	query1.Except(query2).
-		ForEachT(func(book Book) {
-			fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-		})
-
-	fmt.Println()
-	fmt.Println("输出对应书名和作者")
-	//判断结构体的某个字段是否出现
-	query1.ExceptByT(query2, func(book Book) string {
-		return book.Author
-	}).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-}
-
-func Distinct() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	query = query.Append(Book{
-		Name:        "Go语言",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})
-	bookList1 := make([]Book, 0)
-	query.ToSlice(&bookList1)
-	fmt.Println(fmt.Sprintf("筛选之前query中总共有%d个数据", query.Count()))
-	//这边的distinct如果是结构体，则判断的是结构体的所有值，如果是指针则判断的是指针地址.
-	query = query.Distinct()
-	fmt.Println(fmt.Sprintf("筛选之后query中总共有%d个数据", query.Count()))
-
-	fmt.Println()
-	fmt.Println("输出对应书名和作者")
-	query = query.Append(Book{
-		Name:        "Go语言(第二版)",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})
-	//根据对应的规则来判断是否相同 -- 如果对应的字段一样，只会保留第一个找到的，后面的会被清除掉
-	query.DistinctByT(func(book Book) string {
-		return book.Author
-	}).ForEachT(func(book Book) {
-		fmt.Println(fmt.Sprintf("书名%v,作者%v", book.Name, book.Author))
-	})
-}
-
-func Combine() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	query1 := query.Concat(query) //不会排除重复项
-	query2 := query.Union(query)  //会排除重复项
-	fmt.Println(fmt.Sprintf("不会排除重复项的方法返回的元素个数是%d", len(query1.Results())))
-	fmt.Println(fmt.Sprintf("会排除重复项的方法返回的元素个数是%d", len(query2.Results())))
-	query1 = query1.Append(Book{Name: "Last One"})   //加在原来的Query的最后面
-	query2 = query2.Prepend(Book{Name: "First One"}) //加在原来的Query的第一个
-	fmt.Println(fmt.Sprintf("最后一个元素是%v", query1.Last()))
-	fmt.Println(fmt.Sprintf("第一个元素是%v", query2.First()))
-}
-
-func FirstAndLast() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	fmt.Println(fmt.Sprintf("数组第一本书书名叫:%s", query.First().(Book).Name))
-	fmt.Println(fmt.Sprintf("数组第一本书发布时间在2018年1月1号之后的书书名叫:%s", query.FirstWith(PublishTimeAfterFunc).(Book).Name))
-
-	fmt.Println(fmt.Sprintf("数组最后一本书书名叫:%s", query.Last().(Book).Name))
-	fmt.Println(fmt.Sprintf("数组最后一本书发布时间在2018年1月1号之后的书书名叫:%s", query.LastWith(PublishTimeAfterFunc).(Book).Name))
-}
-
-func Contains() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	//这边需要注意是的是如果要判断两个元素是否相等，在go里面不能使用元素的地址
-	// 所以这边加到query里面的必须不能是元素的地址，否则没办法比较结构体本身，而是比较结构体的地址
-	fmt.Println(fmt.Sprintf("判断当前数组是否包含相同的元素,判断的是所有的值，而不是地址，结果是%v", query.Contains(Book{
-		Name:        "Go语言",
-		Author:      "Go",
-		Money:       100,
-		WordsNum:    1000,
-		PublishTime: time.Date(2020, 1, 1, 10, 0, 0, 0, time.Local),
-	})))
-}
-
-func Calculate() {
-	query := linq.From([]int{1, 2, 3, 4, 5, 6, 7, 8, 9})
-	fmt.Println(fmt.Sprintf("平均值为：%f", query.Average()))
-	fmt.Println(fmt.Sprintf("最大的值为%d", query.Max()))
-	fmt.Println(fmt.Sprintf("最小的值为%d", query.Min()))
-}
-
-func AnyWith() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	result := query.AnyWith(PublishTimeBeforeFunc) //判断是否有任意个元素满足条件
-	fmt.Println(fmt.Sprintf("是否有任意书的发表时间早于2020年1月1号，答案是%v", result))
-
-	result = query.AnyWith(PublishTimeAfterFunc2) //判断是否有任意个元素满足条件
-	fmt.Println(fmt.Sprintf("是否有任意书的发表时间晚于2021年1月1号，答案是%v", result))
-}
-
-func All() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	result := query.All(PublishTimeBeforeFunc)
-	fmt.Println(fmt.Sprintf("是否所有的书的发表时间都早于2020年1月1号，答案是%v", result))
-
-	result = query.All(PublishTimeAfterFunc)
-	fmt.Println(fmt.Sprintf("是否所有的书的发表时间都晚于2018年1月1号，答案是%v", result))
-}
-
-func Aggregate() {
-	bookList := MakeBook()
-	query := linq.From(bookList)
-	// 这边的聚合操作其实就是【自定义对应的比较方法】。
-	// 根据注释，第一次拿到的是数组的第一个元素，然后跟第二个元素进行比较，如果第二个元素符合条件则【替换第一个元素】，否则当前聚合操作还是持有第一个元素。
-	// 以此类推后面的元素
-	result := query.Aggregate(AggregateFunc).(Book)
-	fmt.Println(fmt.Sprintf("聚合操作查询出的结果是【%s】这本书，它的发布时间最早为：%v", result.Name, timed.GetTimeDefaultFormatString(result.PublishTime.Unix())))
-}

util/search/LomutoPartition.go

@@ -23,7 +23,7 @@ func LomutoPartition(list []int, start int, end int) int {
 		if list[i] < compareValue {
 			moveSubscript++
 			charge++
-			list[moveSubscript], list[i] = list[i], list[moveSubscript]
+			list[moveSubscript], list[i] = list[i], list[moveSubscript] //交换元素
 		}
 	}
 	charge++

util/search/LomutoPartition_test.go

@@ -13,17 +13,26 @@ import (
 
 func TestPartition(t *testing.T) {
 	list := []int{99, 1, 2, 3, 4, 100, 200, 90, 5}
-	s := LomutoPartition(list, 0, 9-1)
-	fmt.Println(fmt.Sprintf("当前第一个元素应该存在位置为：%d", s))
-	for _, r := range list {
-		fmt.Print(r, " ")
+
+	for i := 1; i <= len(list); i++ {
+		s := LomutoPartition(list, 0, len(list)-1)
+		fmt.Println()
+		fmt.Println(fmt.Sprintf("当前第一个元素应该存在位置为：%d", s))
+		for _, r := range list {
+			fmt.Print(r, " ")
+		}
 	}
 
-	s = LomutoPartition(list, 0, 9-1)
-	fmt.Println(fmt.Sprintf("当前第一个元素应该存在位置为：%d", s))
-	for _, r := range list {
-		fmt.Print(r, " ")
+	fmt.Println()
+	for i := 1; i <= len(list); i++ {
+		num, _, _ := LomutoQuiteSelect(list, i)
+		fmt.Println(fmt.Sprintf("第%d个位置的数是：%d", i, num))
 	}
+
+	for i := 0; i < len(list); i++ {
+		fmt.Println(list[i])
+	}
+
 }
 
 func doc() string {

util/timed/TestTimeIntervalUtil_test.go

@@ -42,6 +42,15 @@ func TestTimeIntervalUtil(t *testing.T) {
 	o2 := GetIntervalBetweenTimes(time.Now().AddDate(3, 2, 5).Add(5*time.Hour).Add(7*time.Minute).Add(10*time.Second).Unix(), time.Now().Unix())
 	o3 := GetIntervalBetweenTimes(time.Now().Unix(), time.Now().AddDate(3, -2, 5).Add(5*time.Hour).Add(7*time.Minute).Add(10*time.Second).Unix())
 
+	O4 := GetIntervalDay(time.Now(), time.Now().AddDate(0, 0, 2))
+	O5 := GetIntervalDay(time.Now(), time.Now().AddDate(0, 0, 2).Add(5*time.Hour))
+	O6 := GetIntervalDay(time.Now(), time.Now().AddDate(0, 0, 2).Add(25*time.Hour))
+
+	fmt.Println("相差天数计算：")
+	fmt.Println(O4)
+	fmt.Println(O5)
+	fmt.Println(O6)
+
 	ox := GetIntervalBetweenTimes(time.Now().Unix(), time.Date(2020, 5, 6, 0, 0, 0, 0, time.Local).Unix())
 	fmt.Println(ox)
 

util/timed/TimeIntervalUtil.go

@@ -136,6 +136,20 @@ func GetIntervalBetweenTimes(timestamp, stamp int64) vo.IntervalObj {
 
 }
 
+// 获取两个时间点之间相差多少天
+func GetIntervalDay(beforeTime, afterTime time.Time) int {
+	timestamp := beforeTime.Unix()
+	stamp := afterTime.Unix()
+	//时间大小保证前小后大
+	if timestamp > stamp {
+		timestamp, stamp = stamp, timestamp
+	}
+	timeBefore := time.Unix(timestamp, 0)
+	timeAfter := time.Unix(stamp, 0)
+	m := timeAfter.Sub(timeBefore)
+	return int(m.Hours() / 24)
+}
+
 /*
  * @param timestamp 时间戳
  * @param stamp 时间戳

util/trie/Trie.go

@@ -32,7 +32,7 @@ func initTrie() *Trie {
 }
 
 //往前缀树中添加对应的字符串(build模式)
-func (trie *Trie) insert(word string) *Trie {
+func (trie *Trie) Insert(word string) *Trie {
 	traverse := trie
 	for _, v := range []rune(word) {
 		if _, ok := traverse.Child[v]; !ok {
@@ -48,13 +48,21 @@ func (trie *Trie) insert(word string) *Trie {
 //删除对应的字符串，如果查找不到则直接返回(build模式)
 func (trie *Trie) Delete(word string) *Trie {
 	traverse := trie
+	parent := trie
+	var value rune
 	for _, v := range []rune(word) {
 		if _, ok := traverse.Child[v]; !ok {
 			return trie
 		}
+		parent = traverse
 		traverse = traverse.Child[v]
+		value = v
 	}
-	traverse.Word = emptyTag
+	if len(parent.Child) == 0 {
+		delete(parent.Child, value)
+		return trie
+	}
+	parent.Child[value].Word = emptyTag
 	return trie
 }
 

util/trie/Trie_test.go

@@ -14,15 +14,16 @@ import (
 //模糊查询前缀匹配的所有字符串
 func TestSearchTrieVague(t *testing.T) {
 	fmt.Println()
-	fmt.Println("模糊查询 查找前缀匹配的所有字符串")
+	fmt.Println("模糊查询 查找前缀匹配的所有字符串，输入\"新年快乐\" ")
 	trie := New()
-	trie.insert("abcuuid").insert("abcuued").insert("abcMxns").insert("abssde").insert("avddfa")
-	trie.insert("我爱中国").insert("我爱祖国").insert("我爱学习").insert("我是谁").insert("我在哪里")
-	trie.insert("我是你").insert("我").insert("我喜欢学习").insert("我在厦门").insert("我是一个程序员")
+	trie.Insert("abcuuid").Insert("abcuued").Insert("abcMxns").Insert("abssde").Insert("avddfa")
+	trie.Insert("我爱中国").Insert("我爱祖国").Insert("我爱学习").Insert("我是谁").Insert("我在哪里")
+	trie.Insert("我是你").Insert("我").Insert("我喜欢学习").Insert("我在厦门").Insert("我是一个程序员")
+	trie.Insert("新年快乐，你好呀").Insert("新年新气象").Insert("新的一年新的开始")
 
 	fmt.Println()
 	fmt.Println()
-	result3, _ := trie.SearchTrieVague("我爱她")
+	result3, _ := trie.SearchTrieVague("新年快乐")
 	for _, r := range result3 {
 		fmt.Println(r)
 	}
@@ -33,8 +34,8 @@ func TestSearchTrie(t *testing.T) {
 	fmt.Println()
 	fmt.Println("查找前缀匹配的所有字符串")
 	trie := New()
-	trie.insert("abcuuid").insert("abcuued").insert("abcMxns").insert("abssde").insert("avddfa")
-	trie.insert("我爱中国").insert("我爱祖国").insert("我爱学习").insert("我是谁").insert("我在哪里")
+	trie.Insert("abcuuid").Insert("abcuued").Insert("abcMxns").Insert("abssde").Insert("avddfa")
+	trie.Insert("我爱中国").Insert("我爱祖国").Insert("我爱学习").Insert("我是谁").Insert("我在哪里")
 
 	fmt.Println()
 	fmt.Println()
@@ -62,7 +63,7 @@ func TestSearchTrie(t *testing.T) {
 //敏感词汇屏蔽测试
 func TestSensitiveWordsTest(t *testing.T) {
 	trie := New()
-	trie.insert("粗话").insert("fuck").insert("fuckk").insert("脏话")
+	trie.Insert("粗话").Insert("fuck").Insert("fuckk").Insert("脏话")
 	s := "我是脏话，我是粗话，fuckk,fuck,fffuccck"
 	word := trie.DealFunc(s, func(sentence []rune, start int, end int) string {
 		var replace string
@@ -73,13 +74,14 @@ func TestSensitiveWordsTest(t *testing.T) {
 		runes = append(runes, sentence[end:]...)
 		return string(runes)
 	})
-	fmt.Println(word)
+	fmt.Println(fmt.Sprintf("原来的字符串： \"%v\"", s))
+	fmt.Println(fmt.Sprintf("转换后的字符串： \"%v\"", word))
 }
 
 //常规功能测试
 func TestCommonTest(t *testing.T) {
 	trie := New()
-	trie.insert("ABC").insert("AB").insert("ABE").insert("ABEX").insert("XYZ").insert("你").insert("你好").insert("你是谁")
+	trie.Insert("ABC").Insert("AB").Insert("ABE").Insert("ABEX").Insert("XYZ").Insert("你").Insert("你好").Insert("你是谁")
 	result := trie.Traverse()
 	for _, r := range result {
 		fmt.Println(r)