按照标题与搜索词的相似度,进行排序

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
// 自定义排序函数,根据Item的Name字段与target字符串的相似性进行排序
func sortBySimilarity(items []item, target string) []item {
items = filter(items, target)
sort.Slice(items, func(i, j int) bool {
// 计算每个Item的Name与target的相似性
simI := levenshteinDistance(items[i].Title, target)
simJ := levenshteinDistance(items[j].Title, target)
// 假设我们想要相似性越高的越排在前面,因此返回simI < simJ
// 如果你的相似性算法逻辑不同,这里的比较逻辑也需要相应调整
return simI < simJ
})
return items
}
// 过滤掉不包含搜索词的记录
func filter(items []item, target string) []item {
results := []item{}
for _, v := range items {
if strings.Contains(strings.ToLower(v.Title), strings.ToLower(target)) {
results = append(results, v)
}
}
return results
}
// levenshteinDistance 计算两个字符串之间的Levenshtein距离
func levenshteinDistance(s1, s2 string) int {
len1 := len(s1)
len2 := len(s2)
if len1 < len2 {
return levenshteinDistance(s2, s1)
}
if len2 == 0 {
return len1
}
// 创建一个二维切片来存储计算过程中的中间结果
dp := make([][]int, len1+1)
for i := range dp {
dp[i] = make([]int, len2+1)
}
// 初始化第一列
for i := 0; i <= len1; i++ {
dp[i][0] = i
}
// 初始化第一行
for j := 0; j <= len2; j++ {
dp[0][j] = j
}
// 填充剩余的dp表格
for i := 1; i <= len1; i++ {
for j := 1; j <= len2; j++ {
cost := 0
if s1[i-1] != s2[j-1] {
cost = 1
}
dp[i][j] = min(
dp[i-1][j]+1, // 删除
dp[i][j-1]+1, // 插入
dp[i-1][j-1]+cost, // 替换
)
}
}
return dp[len1][len2]
}
// min 返回两个整数中的较小值
func min(a, b, c int) int {
if a <= b && a <= c {
return a
} else if b <= a && b <= c {
return b
}
return c
}
// 自定义排序函数,根据Item的Name字段与target字符串的相似性进行排序 func sortBySimilarity(items []item, target string) []item { items = filter(items, target) sort.Slice(items, func(i, j int) bool { // 计算每个Item的Name与target的相似性 simI := levenshteinDistance(items[i].Title, target) simJ := levenshteinDistance(items[j].Title, target) // 假设我们想要相似性越高的越排在前面,因此返回simI < simJ // 如果你的相似性算法逻辑不同,这里的比较逻辑也需要相应调整 return simI < simJ }) return items } // 过滤掉不包含搜索词的记录 func filter(items []item, target string) []item { results := []item{} for _, v := range items { if strings.Contains(strings.ToLower(v.Title), strings.ToLower(target)) { results = append(results, v) } } return results } // levenshteinDistance 计算两个字符串之间的Levenshtein距离 func levenshteinDistance(s1, s2 string) int { len1 := len(s1) len2 := len(s2) if len1 < len2 { return levenshteinDistance(s2, s1) } if len2 == 0 { return len1 } // 创建一个二维切片来存储计算过程中的中间结果 dp := make([][]int, len1+1) for i := range dp { dp[i] = make([]int, len2+1) } // 初始化第一列 for i := 0; i <= len1; i++ { dp[i][0] = i } // 初始化第一行 for j := 0; j <= len2; j++ { dp[0][j] = j } // 填充剩余的dp表格 for i := 1; i <= len1; i++ { for j := 1; j <= len2; j++ { cost := 0 if s1[i-1] != s2[j-1] { cost = 1 } dp[i][j] = min( dp[i-1][j]+1, // 删除 dp[i][j-1]+1, // 插入 dp[i-1][j-1]+cost, // 替换 ) } } return dp[len1][len2] } // min 返回两个整数中的较小值 func min(a, b, c int) int { if a <= b && a <= c { return a } else if b <= a && b <= c { return b } return c }
// 自定义排序函数,根据Item的Name字段与target字符串的相似性进行排序
func sortBySimilarity(items []item, target string) []item {
	items = filter(items, target)

	sort.Slice(items, func(i, j int) bool {
		// 计算每个Item的Name与target的相似性
		simI := levenshteinDistance(items[i].Title, target)
		simJ := levenshteinDistance(items[j].Title, target)

		// 假设我们想要相似性越高的越排在前面,因此返回simI < simJ
		// 如果你的相似性算法逻辑不同,这里的比较逻辑也需要相应调整
		return simI < simJ
	})

	return items
}

// 过滤掉不包含搜索词的记录
func filter(items []item, target string) []item {
	results := []item{}
	for _, v := range items {
		if strings.Contains(strings.ToLower(v.Title), strings.ToLower(target)) {
			results = append(results, v)
		}
	}

	return results
}

// levenshteinDistance 计算两个字符串之间的Levenshtein距离
func levenshteinDistance(s1, s2 string) int {
	len1 := len(s1)
	len2 := len(s2)
	if len1 < len2 {
		return levenshteinDistance(s2, s1)
	}
	if len2 == 0 {
		return len1
	}

	// 创建一个二维切片来存储计算过程中的中间结果
	dp := make([][]int, len1+1)
	for i := range dp {
		dp[i] = make([]int, len2+1)
	}

	// 初始化第一列
	for i := 0; i <= len1; i++ {
		dp[i][0] = i
	}

	// 初始化第一行
	for j := 0; j <= len2; j++ {
		dp[0][j] = j
	}

	// 填充剩余的dp表格
	for i := 1; i <= len1; i++ {
		for j := 1; j <= len2; j++ {
			cost := 0
			if s1[i-1] != s2[j-1] {
				cost = 1
			}
			dp[i][j] = min(
				dp[i-1][j]+1,      // 删除
				dp[i][j-1]+1,      // 插入
				dp[i-1][j-1]+cost, // 替换
			)
		}
	}

	return dp[len1][len2]
}

// min 返回两个整数中的较小值
func min(a, b, c int) int {
	if a <= b && a <= c {
		return a
	} else if b <= a && b <= c {
		return b
	}
	return c
}
120

0 评论
最新
最旧 最多投票
内联反馈
查看所有评论