golang字符串切⽚去重实例
实现⽬的：实现字符串切⽚去重，只是两个字符完全相同时，去除⼀个。
实现⽅式：考虑两种，⼀种是常规的双重循环去除，另⼀种是利⽤map的key的唯⼀性实现。
1、通过双重循环来过滤重复元素
⽅法1，
思路：利⽤for双重循环，新建⼀个slice，遍历原slice中的每⼀个元素，每⼀次判断这个元素和后⾯元素是否相同，若相同则去除，若不同则存⼊新slice中，判断本元素后，再继续判断下⼀个元素，直到判断完毕。
package main
import "fmt"
func main() {
var arr = []string{"hello", "hi", "world", "hi", "china", "hello", "hi"}
fmt.Println(RemoveRepeatedElement(arr))
}
//去除重复字符串
字符串长度截取func RemoveRepeatedElement(arr []string) (newArr []string) {
newArr = make([]string, 0)
for i := 0; i < len(arr); i++ {
repeat := false
for j := i + 1; j < len(arr); j++ {
if arr[i] == arr[j] {
repeat = true
break
}
}
if !repeat {
newArr = append(newArr, arr[i])
}
}
return newArr
}
⽅法2，
思路：先对原slice使⽤sort进⾏排序，后⾯思路同⽅法1。
package main
import(
"fmt"
"sort"
)
//去除重复字符串和空格
func RemoveDuplicatesAndEmpty(a []string) (ret []string){
a_len := len(a)
for i:=0; i < a_len; i++{
if (i > 0 && a[i-1] == a[i]) || len(a[i])==0{
continue;
}
ret = append(ret, a[i])
}
return
}
func main(){
a := []string{"hello", "", "world", "yes", "hello", "nihao", "shijie", "hello", "yes", "nihao","good"}
sort.Strings(a)
fmt.Println(a)
fmt.Println(RemoveDuplicatesAndEmpty(a))
}
2、通过字典来过滤
思路：因为字典的主键唯⼀，所以可以⽤来判断元素是否重复。
package main
import (
"fmt"
)
func main() {
testStr := make([]string, 0)
testStr = append(testStr, "haha", "hehe", "hoho", "hehe")
afterStr := removeDuplicate(testStr)
fmt.Println(afterStr)
}
/
/ 通过map主键唯⼀的特性过滤重复元素
func removeDuplicate(arr []string) []string {
resArr := make([]string, 0)
tmpMap := make(map[string]interface{})
for _, val := range arr {
//判断主键为val的map是否存在
if _, ok := tmpMap[val]; !ok {
resArr = append(resArr, val)
tmpMap[val] = nil
}
}
return resArr
}
3、效率考虑
程序算法有两个指标：运⾏时间、内存消耗（即：时间复杂度、空间复杂度）。
以上两个⽅法，当数据量⼩和数据量⼤时分别考虑⽤双重for循环⽅法和map主键唯⼀⽅法。具体需要数据验证。
补充：Golang中如何删除切⽚的重复元素
思想如下：利⽤map中key唯⼀的特性将slice中的数据保存到map的key中
但是要注意key的类型，有些数值不能做为key
Map 是⼀种⽆序的键值对的集合。Map 最重要的⼀点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是⼀种集合，所以我们可以像迭代数组和切⽚那样迭代它。不过，Map 是⽆序的，我们⽆法决定它
的返回顺序，这是因为 Map 是使⽤ hash 表来实现的
Golang中map中key的类型
golang中的map，其中的 key 可以是很多种类型，⽐如 bool, 数字，string, 指针, channel , 还有只包含前⾯⼏个类型的interface types, structs, arrays
显然，slice， map 还有 function 是不可以了，因为这⼏个没法⽤ == 来判断
原⽂如下：
As mentioned earlier, map keys may be of any type that is comparable. The language spec defines this precisely, but in short, comparable types are boolean, numeric, string, pointer, channel, and interface types, and structs or arrays that contain only those types. Notably absent from the list are slices, maps, and functions; these types cannot be compared using ==, and may not be used as map keys.
// 删除切⽚中重复的数据
package main
import (
"fmt"
"reflect"
"sort"
)
func main() {
b := []string{"a", "b", "c", "c", "e", "f", "a", "g", "b", "b", "c"}
sort.Strings(b)
fmt.Println(Duplicate(b))
c := []int{1, 1, 2, 4, 6, 7, 8, 4, 3, 2, 5, 6, 6, 8}
sort.Ints(c)
fmt.Println(DeleteDuplicateValue(c))
}
func Duplicate(a interface{}) (ret []interface{}) {
fmt.Printf("a : %+v\n", a)
va := reflect.ValueOf(a)
fmt.Printf("va : %+v\n", va)
for i := 0; i < va.Len(); i++ {
if i > 0 && reflect.DeepEqual(va.Index(i-1).Interface(), va.Index(i).Interface()) {
continue
}
ret = append(ret, va.Index(i).Interface())
}
return ret
}
// 这种⽅式⽐较容易理解
func DeleteDuplicateValue(s []int) (ret []int) {
fmt.Printf("s :%+v\n", s)
tmpM := make(map[int]int) // key的类型要和切⽚中的数据类型⼀致
for _, v := range s {
tmpM[v] = 1
}
// 先清空s
s = []int{}
for i, _ := range tmpM {
s = append(s, i)
}
return s
}
输出的结果如下：
以上为个⼈经验，希望能给⼤家⼀个参考，也希望⼤家多多⽀持。如有错误或未考虑完全的地⽅，望不吝赐教。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。