Golang算法模板-常用标准库、类型转换等操作汇总

string数组切片

func main() {
	s1 := []string{}
	s1 = append(s1, "hello1")
	
	s2 := make([]string, 0)
	s2 = append(s2, "hello2")
	fmt.Println(s1, s2)
}

切片用法

• make创建切片时，初始长度为n，可以通过取下标和append；初始长度为0，只能通过append操作

func main() {
	m := make([]int, 5)
	m[1] = 1
	m = append(m, 6)
	fmt.Println(m)

	m2 := make([]int, 0)
	m2 = append(m2, 5)
	fmt.Println(m2)
}

//输出
[0 1 0 0 0 6]
[5]

• 切片赋值

func main() {
	arr := []int{1, 2, 3, 4}
	arr2 := [5]int{1, 2, 3, 4}
	fmt.Printf("%T, %T\n", arr, arr2) //[]int, [5]int
	arr3 := arr[0:4]
	fmt.Printf("%T, %v\n", arr3, arr3) //[]int, [1 2 3 4]
	arr3[1] = 6	//这种赋值方式，修改arr3，也会作用于原来的arr的值
	fmt.Printf("%v, %v\n", arr3, arr) //[1 6 3 4], [1 6 3 4]
}

字典基本用法

• value类型为int的值默认为0

func main() {
	m := make(map[string]int)
	m["hello"] = 2
	m["hello2"]++ //默认值为0
	
	for k, v := range m {
		fmt.Println(k, v)
	}
	
	delete(m, "hello")	//根据键删除
}

• 判断字典中是否有给定的键，用map["key"]，会返回两个值，第一个值是对应的value，第二个值是ok，表示是否存在

func main() {
	m := make(map[string]int)
	m["hello"] = 2
	m["hello2"]++ //默认值为0
	if val, ok := m["hello1"]; ok {
		fmt.Println(val)
	} else {
		fmt.Println("key not found")
	}
}

• 遍历map的方法

func main() {
	m := make(map[string]int)
	m["hello"] = 2
	m["hello2"] += 1
	for key, val := range m { //两个变量去接，获取的是key, value
		fmt.Println(key, val)
	}
	for key := range m { //一个变量去接，获取的是key
		fmt.Println(key)
	}
	for _, val := range m {	//这样获取的是value
		fmt.Println(val)
	}
}

sort库

func main() {
	arr_int := []int{3, 5, 1, 6, 2}
	sort.Ints(arr_int) //默认从小到大排序
	fmt.Println(arr_int)

	arr_string := []string{"hello", "a", "b", "c", "h"}
	sort.Strings(arr_string)
	fmt.Println(arr_string)

	sort.Slice(arr_int, func(i, j int) bool {
		return arr_int[i] > arr_int[j]
	})
	fmt.Println(arr_int)
}

func main() {
	//如果存在给定数，返回第一个数的下标
	//如果不存在给定数，返回应该插入的下标的位置
	//即返回第一个大于等于给定数的下标
	arr := []int{1, 1, 2, 2, 5, 8, 9, 9, 10}
	fmt.Println(sort.SearchInts(arr, 1))	//0
	fmt.Println(sort.SearchInts(arr, 2))//2
	fmt.Println(sort.SearchInts(arr, 7))//5
	fmt.Println(sort.SearchInts(arr, 11))//9
}

math库

func main() {
	fmt.Println(math.MaxInt32, math.MinInt32)
	fmt.Println(math.MaxInt64, math.MinInt64)
	fmt.Println(math.MaxInt, math.MinInt)
	fmt.Println(math.Max(1, 2), math.Min(5, 6))
}

strings库

字符串匹配查找

func main() {
    str1 := "hello, world"
    fmt.Println(strings.Contains(str1, "hello"))
}

字符串大小写转换

func main(){
	str1 := "hello"
	res1 := strings.ToLower(str1)  
	res2 := strings.ToUpper(str1)  
	res3 := strings.ToTitle(str1)
}

字符串比较

func main() {
	str1 := "hello"
	str2 := "Hello"

	fmt.Println(str1 == "hello")

	//比较两个字符串的大小，会逐个字符进行比较ASCII值
	fmt.Println(strings.Compare(str1, str2))

	//判断两个字符是否相等,忽略大小写，可以判断字符和中文
	fmt.Println(strings.EqualFold(str1, str2))
}

类型转换

byte-int

• string类型索引到某个下标的值是uint8类型(byte，也可以理解为ascii码值)
• 直接套上int(),byte()即可，只需要加减0字符

func main() {
	s1 := "54321"
	index1 := s1[0]
	str1 := string(s1[0])
	num1 := int(s1[0] - '0')
	byte1 := byte(num1 + '0')
	fmt.Printf("%T, %d\n", index1, index1)
	fmt.Printf("%s, %d, %c, %v\n", str1, num1, byte1, index1 == byte1)
}

string转int

val, err := strconv.Atoi(s)

string转byte切片

func main() {
	str1 := "hello"
	arr1 := []byte(str1)
	for _, v := range arr1 {
		fmt.Printf("%c, %d\n", v, v)
	}
}

string转byte数组

func main() {
	str1 := "hello"
	var byte1 [64]byte
	copy(byte1[:], str1)
	fmt.Printf("%v", byte1)
}