有关go的学习

Go语言核心36讲/main.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello")
+	nums := []string{"1", "hel", "袁"}
+	for i := 0; i < len(nums); i++ {
+		fmt.Println(nums[i])
+	}
+}

algorithm/1.两数之和/main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	nums := []int{3, 3}
+	fmt.Print(twoSum(nums, 6))
+	fmt.Print(twoSumMap(nums, 6))
+}
+
+func twoSum(nums []int, target int) []int {
+	answer := make([]int, 2)
+	var i, j int
+	for i = 0; i < len(nums); i++ {
+		for j = i + 1; j < len(nums); j++ {
+			if nums[i]+nums[j] == target {
+				answer[0] = i
+				answer[1] = j
+				return answer
+			}
+		}
+	}
+	// answer[0] = 0
+	// answer[1] = 0
+	return answer
+}
+
+func twoSumMap(nums []int, target int) []int {
+	datamap := make(map[int]int)
+	for i := 0; i < len(nums); i++ {
+		datamap[nums[i]] = i
+	}
+	for index1 := 0; index1 < len(nums); index1++ {
+		index2, isOk := datamap[target-nums[index1]]
+		if isOk && index2 != index1 {
+			return []int{index1, index2}
+		}
+	}
+	return nil
+}

algorithm/2.两数相加/main.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"fmt"
+)
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func main() {
+	data1 := []int{9, 9, 9, 9, 9, 9, 9}
+	data2 := []int{9, 9, 9, 9}
+	headA := new(ListNode)
+	headA.Val = data1[0]
+	headB := new(ListNode)
+	headB.Val = data2[0]
+	t := headA
+	// data2 := []int{5, 6, 4}
+	for i := 1; i < len(data1); i++ {
+		node := new(ListNode)
+		node.Val = data1[i]
+		t.Next = node
+		t = node
+	}
+	t = headB
+	for i := 1; i < len(data2); i++ {
+		node := new(ListNode)
+		node.Val = data2[i]
+		t.Next = node
+		t = node
+	}
+	t = addTwoNumbers(headA, headB)
+	for t != nil {
+		fmt.Print(t.Val)
+		t = t.Next
+	}
+}
+
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	l3 := new(ListNode)
+	p := l3
+	flag := 0
+	for l1 != nil && l2 != nil {
+		node := new(ListNode)
+		node.Val = (l1.Val + l2.Val + flag)
+		if flag == 1 {
+			flag = 0
+		}
+		if node.Val >= 10 {
+			node.Val = node.Val - 10
+			flag = 1
+		}
+		// fmt.Print(node.Val)
+		p.Next = node
+		p = node
+		l1 = l1.Next
+		l2 = l2.Next
+	}
+	for l1 == nil && l2 != nil {
+		node := new(ListNode)
+		node.Val = l2.Val + flag
+		if flag == 1 {
+			flag = 0
+		}
+		if node.Val >= 10 {
+			node.Val = node.Val - 10
+			flag = 1
+		}
+		p.Next = node
+		p = node
+		l2 = l2.Next
+		// fmt.Print(node.Val)
+	}
+	for l2 == nil && l1 != nil {
+		node := new(ListNode)
+		node.Val = l1.Val + flag
+		if flag == 1 {
+			flag = 0
+		}
+		if node.Val >= 10 {
+			node.Val = node.Val - 10
+			flag = 1
+		}
+		p.Next = node
+		p = node
+		l1 = l1.Next
+		// fmt.Print(node.Val)
+	}
+	if l1 == nil && l2 == nil && flag == 1 {
+		node := new(ListNode)
+		node.Val = 1
+		p.Next = node
+	}
+	return l3.Next
+	//这里.Next是符合力扣
+}

algorithm/20.有效的括号/main.go

@@ -0,0 +1,82 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(isValid2("(())}[]"))
+	fmt.Println(isValid("()[]"))
+}
+
+func isValid(s string) bool {
+	//  (:40    [:91   {:123       ):41     ]:93   }:125
+	length := len(s)
+	if length == 0 {
+		return true
+	}
+	// if length%2 == 1 {
+	// 	return false
+	// }
+	stock := []int{}
+	for i := 0; i < length; i++ {
+		tmp := s[i]
+		if tmp == 40 || tmp == 123 || tmp == 91 {
+			stock = append(stock, int(tmp))
+		} else if tmp == 41 {
+			if len(stock) == 0 {
+				return false
+			}
+			if stock[len(stock)-1] == 40 {
+				stock = stock[:len(stock)-1]
+			} else {
+				stock = append(stock, int(tmp))
+			}
+		} else if tmp == 93 {
+			if len(stock) == 0 {
+				return false
+			}
+			if stock[len(stock)-1] == 91 {
+				stock = stock[:len(stock)-1]
+			} else {
+				stock = append(stock, int(tmp))
+			}
+		} else if tmp == 125 {
+			if len(stock) == 0 {
+				return false
+			}
+			if stock[len(stock)-1] == 123 {
+				stock = stock[:len(stock)-1]
+			} else {
+				stock = append(stock, int(tmp))
+			}
+		}
+	}
+	return len(stock) == 0
+}
+
+func isValid2(s string) bool {
+	//  (:40    [:91   {:123       ):41     ]:93   }:125
+	length := len(s)
+	if length == 0 {
+		return true
+	}
+	mapdata := make(map[int]int)
+	mapdata[40] = 41
+	mapdata[91] = 93
+	mapdata[123] = 125
+	stock := []int{}
+	for i := 0; i < length; i++ {
+		tmp := s[i]
+		if tmp == 40 || tmp == 123 || tmp == 91 {
+			stock = append(stock, int(tmp))
+		} else {
+			if len(stock) == 0 {
+				return false
+			} else if mapdata[stock[len(stock)-1]] == int(tmp) {
+				stock = stock[:len(stock)-1]
+			} else {
+				stock = append(stock, int(tmp))
+			}
+		}
+	}
+	return len(stock) == 0
+}

algorithm/21.合并两个有序链表/main.go

@@ -0,0 +1,70 @@
+package main
+
+import "fmt"
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func main() {
+	// fmt.Print("hello")
+	data1 := []int{1, 2, 4}
+	data2 := []int{1, 3, 4}
+	list1 := new(ListNode)
+	p1 := list1
+	list2 := new(ListNode)
+	p2 := list2
+	for i := 0; i < len(data1); i++ {
+		tmp := new(ListNode)
+		tmp.Val = data1[i]
+		p1.Next = tmp
+		p1 = tmp
+	}
+	for i := 0; i < len(data2); i++ {
+		tmp := new(ListNode)
+		tmp.Val = data2[i]
+		p2.Next = tmp
+		p2 = tmp
+	}
+	list3 := mergeTwoLists(list1.Next, list2.Next)
+	for list3 != nil {
+		fmt.Print(list3.Val)
+		list3 = list3.Next
+	}
+}
+
+func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
+	head := new(ListNode)
+	node := head
+	for list1 != nil && list2 != nil {
+		if list1.Val <= list2.Val {
+			tmp := new(ListNode)
+			tmp.Val = list1.Val
+			node.Next = tmp
+			node = tmp
+			list1 = list1.Next
+		} else if list1.Val > list2.Val {
+			tmp := new(ListNode)
+			tmp.Val = list2.Val
+			node.Next = tmp
+			node = tmp
+			list2 = list2.Next
+		}
+	}
+	for list1 != nil {
+		tmp := new(ListNode)
+		tmp.Val = list1.Val
+		node.Next = tmp
+		node = tmp
+		list1 = list1.Next
+	}
+	for list2 != nil {
+		tmp := new(ListNode)
+		tmp.Val = list2.Val
+		node.Next = tmp
+		node = tmp
+		list2 = list2.Next
+	}
+	return head.Next
+}

algorithm/22.括号生成/main.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+
+	fmt.Println("hello" + "(")
+	fmt.Println(generateParenthesis(3))
+
+}
+
+func generateParenthesis(n int) []string {
+	result := []string{}
+	left := 0
+	right := 0
+	strNow := ""
+	var gobackfunc func(n int, left int, right int, strNow string)
+	gobackfunc = func(n int, left int, right int, strNow string) {
+		if right > left {
+			return
+		}
+		if left == right && left == n {
+			result = append(result, strNow)
+			return
+		}
+		if left < n {
+			gobackfunc(n, left+1, right, strNow+"(")
+		}
+		if left > right {
+			gobackfunc(n, left, right+1, strNow+")")
+		}
+	}
+	gobackfunc(n, left, right, strNow)
+	return result
+}
+
+/*
+func generateParenthesis(n int) []string {
+	//不能把result作为参数传过去，因为回溯后中，result是空的，也就是你append的都会被清掉
+	result := []string{}
+	left := 0
+	right := 0
+	strNow := ""
+	var gobackfunc func(result []string, n int, left int, right int, strNow string)
+	gobackfunc = func(result []string, n int, left int, right int, strNow string) {
+		if right > left {
+			return
+		}
+		if left == right && left == n {
+			result = append(result, strNow)
+			return
+		}
+		if left < n {
+			gobackfunc(result, n, left+1, right, strNow+"(")
+		}
+		if left > right {
+			gobackfunc(result, n, left, right+1, strNow+")")
+		}
+	}
+	gobackfunc(result, n, left, right, strNow)
+	return result
+}
+*/
+
+/*
+func generateParenthesis(n int) []string {
+	var generate func(left, right int, tmp []byte)
+
+	res := make([]string, 0)
+	generate = func(left, right int, tmp []byte) {
+		if left == 0 && right == 0 {
+			res = append(res, string(tmp))
+			return
+		}
+		// 左括号还能放就优先放
+		if left != 0 {
+			tmp = append(tmp, '(')
+			generate(left-1, right, tmp)
+			tmp = tmp[:len(tmp)-1]
+		}
+		// 右括号数量不能大于左括号的，要不然合不回来，就不是合法数据了
+		if right > left {
+			tmp = append(tmp, ')')
+			generate(left, right-1, tmp)
+			tmp = tmp[:len(tmp)-1]
+		}
+	}
+	generate(n, n, []byte{})
+	return res
+}
+*/

algorithm/24.两两交换链表中的节点/main.go

@@ -0,0 +1,134 @@
+package main
+
+import (
+	"fmt"
+)
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+/*
+func swapPairs(head *ListNode) *ListNode {
+	res := new(ListNode)
+	res.Next = head
+	p := res.Next
+	fmt.Print("changeOrgin:")
+	for p != nil {
+		fmt.Print(p.Val)
+		p = p.Next
+	}
+	fmt.Println("")
+	cur := res
+	if head == nil {
+		return nil
+	}
+	next := head.Next
+	if next == nil {
+		return head
+	}
+	tmp := next.Next
+	if tmp == nil {
+		cur.Next = next
+		next.Next = head
+		head.Next = nil
+		return res.Next
+	}
+	cur.Next = next
+	next.Next = head
+	head.Next = tmp
+	p = res.Next
+	fmt.Print("changeSwap1:")
+	for p != nil {
+		fmt.Print(p.Val)
+		p = p.Next
+	}
+	fmt.Println("")
+	cur = head
+	head = tmp
+	next = head.Next
+	tmp = next.Next
+	cur.Next = next
+	next.Next = head
+	head.Next = tmp
+	p = res.Next
+	fmt.Print("changeSwap2:")
+	for p != nil {
+		fmt.Print(p.Val)
+		p = p.Next
+	}
+	fmt.Println("")
+	cur = head
+	head = tmp
+	next = head.Next
+	tmp = next.Next
+	cur.Next = next
+	next.Next = head
+	head.Next = tmp
+	p = res
+
+	fmt.Print("changeSwap3:")
+	for p != nil {
+		fmt.Print(p.Val)
+		p = p.Next
+	}
+	fmt.Println("")
+	return res.Next
+}
+*/
+func swapPairs(head *ListNode) *ListNode {
+	res := new(ListNode)
+	res.Next = head
+	// p := res.Next
+	// fmt.Print("changeOrgin:")
+	// for p != nil {
+	// 	fmt.Print(p.Val)
+	// 	p = p.Next
+	// }
+	// fmt.Println("")
+	cur := res
+	for head != nil && head.Next != nil && head.Next.Next == nil {
+		head = cur.Next
+		next := head.Next
+		cur.Next = next
+		next.Next = head
+		head.Next = nil
+		cur = head
+	}
+	for head != nil && head.Next != nil && head.Next.Next != nil {
+		head = cur.Next
+		next := head.Next
+		tmp := next.Next
+		cur.Next = next
+		next.Next = head
+		head.Next = tmp
+		cur = head
+		// p = res.Next
+		// fmt.Print("changeSwap1:")
+		// for p != nil {
+		// 	fmt.Print(p.Val)
+		// 	p = p.Next
+		// }
+		// fmt.Println("")
+	}
+	return res.Next
+}
+func main() {
+	data := []int{1, 2}
+	head := new(ListNode)
+	p := head
+	for i := 0; i < len(data); i++ {
+		node := new(ListNode)
+		node.Val = data[i]
+		p.Next = node
+		p = node
+	}
+	// p = head.Next
+
+	p = swapPairs(head.Next)
+	for p != nil {
+		fmt.Print(p.Val)
+		p = p.Next
+	}
+}

algorithm/27.移除元素/main.go

@@ -0,0 +1,44 @@
+//双指针法
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println("hello")
+	nums := []int{3}
+	fmt.Println(removeElement(nums, 3))
+}
+
+func removeElement(nums []int, val int) int {
+	l := 0
+	r := len(nums) - 1
+	if r == -1 {
+		return 0
+	}
+	for l != r {
+		for nums[l] != val {
+			if l == r {
+				break
+			}
+			l++
+		}
+		for nums[r] == val {
+			if l == r {
+				break
+			}
+			r--
+		}
+		//这个时候，nums[l] =val && nums[r]!=val
+		tmp := nums[l]
+		nums[l] = nums[r]
+		nums[r] = tmp
+		fmt.Println(nums)
+	}
+	if nums[l] == val { //函数走到这里，l=r
+		return l
+	} else {
+		return l + 1
+	}
+}

algorithm/35.搜索插入位置/main.go

@@ -0,0 +1,45 @@
+// 二分查找法
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello")
+	nums := []int{-5, -4, -3, -2, -1, 0, 1, 2, 4, 5}
+	fmt.Println(searchInsert(nums, 3))
+}
+
+func searchInsert(nums []int, target int) int {
+	l := 0
+	r := len(nums) - 1
+	m := (l + r) / 2
+	flag := true
+	for flag {
+		//这里顺序要考究下
+		if nums[r] < target {
+			return r + 1
+		}
+		if nums[r] == target {
+			return r
+		}
+		if nums[l] >= target {
+			return l
+		}
+		//以上先考虑边界情况
+		if nums[m] < target && target < nums[m+1] {
+			return m + 1
+		}
+		if nums[m] == target {
+			return m
+		}
+		if nums[m] < target {
+			l = m
+			m = (l + r) / 2
+		}
+		if nums[m] > target {
+			r = m
+			m = (l + r) / 2
+		}
+	}
+	return m
+}

algorithm/46.全排列/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	fmt.Println("hello")
+	nums := []int{1, 2, 3}
+	fmt.Println(permute(nums))
+}
+
+func permute(nums []int) [][]int {
+	result := [][]int{}
+	length := len(nums)
+	dataMap := make(map[int]bool)
+	for i := 0; i < length; i++ {
+		dataMap[nums[i]] = false
+	}
+	row := []int{}
+	var backMethod func(nums []int, length int, row []int)
+	backMethod = func(nums []int, length int, row []int) {
+		for i := 0; i < length; i++ {
+			// if dataMap[nums[i]] {
+			// 	return //这里必须得注视掉，因为递归的时候（row[:low(row)-1]），会直接从这个出口出去了。
+			// }
+			if !dataMap[nums[i]] {
+				row = append(row, nums[i])
+				dataMap[nums[i]] = true
+				backMethod(nums, length, row)
+				row = row[:len(row)-1]
+				dataMap[nums[i]] = false
+			}
+		}
+		if length == len(row) {
+			row2 := []int{}
+			for i := 0; i < len(row); i++ {
+				row2 = append(row2, row[i])
+			}
+			result = append(result, row2)
+			// return
+		}
+	}
+	backMethod(nums, length, row)
+	return result
+}

algorithm/49.字母异味词分组/main.go

@@ -0,0 +1,119 @@
+//   114/117 未能全部通过
+package main
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func main() {
+	fmt.Println("hello")
+	strs := []string{"bdddddddddd", "bbbbbbbbbbc"}
+	// strs := []string{"acc", "acc"}
+	fmt.Println(groupAnagrams(strs))
+}
+
+// 输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+// 输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+func groupAnagrams(strs []string) [][]string {
+	mapDate := make(map[string][]string)
+	originMap := make(map[string]int)
+	result := [][]string{}
+	key := ""
+	for i := 0; i < 26; i++ {
+		originMap[string(rune(97+i))] = 0
+	}
+	for i := 0; i < len(strs); i++ {
+		key = ""
+		strElement := strs[i]
+		for j := 0; j < len(strElement); j++ {
+			fmt.Print(string(strElement[j]))
+			originMap[string(strElement[j])] = originMap[string(strElement[j])] + 1
+		}
+		fmt.Println()
+		for i := 0; i < 26; i++ {
+			key = key + strconv.Itoa(originMap[string(rune(97+i))])
+			originMap[string(rune(97+i))] = 0
+		}
+		if rowList, isOK := mapDate[key]; isOK {
+			rowList = append(rowList, strElement)
+			mapDate[key] = rowList
+		} else {
+			rowList = append(rowList, strElement)
+			mapDate[key] = rowList
+		}
+	}
+	for _, v := range mapDate {
+		result = append(result, v)
+	}
+	fmt.Println(mapDate)
+	return result
+}
+
+/*
+func groupAnagrams(strs []string) [][]string {
+	// var mapCompare func(map1 map[byte]int, map2 map[byte]int) bool
+	mapCompare := func(map1 map[byte]int, map2 map[byte]int) bool {
+		// fmt.Println(map1, map2)
+		for k, v := range map1 {
+			if map2[k] != v {
+				return false
+			}
+		}
+		for k, v := range map2 {
+			if map1[k] != v {
+				return false
+			}
+		}
+		return true
+	}
+	result := [][]string{}
+	mainMap := make(map[int]map[byte]int)
+	// subMap := map[string]bool{"a": true}
+	// mainMap[0] = map[byte]bool{0: false}
+	count := 0
+	for i := 0; i < len(strs); i++ {
+		// fmt.Println("----------------------------------------", i)
+		strElement := strs[i]
+		subMap := make(map[byte]int)
+		for j := 0; j < len(strElement); j++ {
+			value, isOk := subMap[strElement[j]]
+			if isOk {
+				subMap[strElement[j]] = value + 1
+			} else {
+				subMap[strElement[j]] = 1
+			}
+		}
+		flag := true
+		for flag {
+			for k, _ := range mainMap {
+				if mapCompare(subMap, mainMap[k]) {
+					row := result[k]
+					row = append(row, strElement)
+					result[k] = row
+					flag = false
+					break
+				}
+			}
+			if flag {
+				row := []string{}
+				row = append(row, strElement)
+				result = append(result, row)
+				flag = false
+				mainMap[count] = subMap
+				count++
+				flag = false
+			}
+		}
+		// fmt.Println(subMap)
+		// fmt.Println(mainMap)
+		// fmt.Println(result)
+	}
+	// for i := 0; i < count; i++ {
+	// 	listElement := []string{}
+	// 	if
+	// }
+	return result
+}
+*/

algorithm/53.最大子数组和/main.go

@@ -0,0 +1,26 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello")
+	nums := []int{-2, 1}
+	fmt.Println(maxSubArray(nums))
+}
+
+func maxSubArray(nums []int) int {
+	maxNum := nums[0]
+	for i := 0; i < len(nums); i++ {
+		now := nums[i]
+		if now > maxNum {
+			maxNum = now
+		}
+		for j := i + 1; j < len(nums); j++ {
+			now = now + nums[j]
+			if now > maxNum {
+				maxNum = now
+			}
+		}
+	}
+	return maxNum
+}

learn/1.7/main.go

@@ -0,0 +1,34 @@
+// Server2 is a minimal "echo" and counter server.
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"sync"
+)
+
+var mu sync.Mutex
+var count int
+
+func main() {
+	http.HandleFunc("/", handler)
+	http.HandleFunc("/count", counter)
+	log.Fatal(http.ListenAndServe("localhost:8000", nil))
+}
+
+// handler echoes the Path component of the requested URL.
+func handler(w http.ResponseWriter, r *http.Request) {
+	mu.Lock()
+	count++
+	mu.Unlock()
+	fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
+}
+
+// counter echoes the number of calls so far.
+func counter(w http.ResponseWriter, r *http.Request) {
+	mu.Lock()
+	fmt.Println(r)
+	fmt.Fprintf(w, "Count %d\n", count)
+	mu.Unlock()
+}

learn/1.8/main.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Print(Signum(1))
+}
+
+func Signum(x int) int {
+	switch {
+	case x > 0:
+		return +1
+	case x < 0:
+		return -1
+	default:
+		return 0
+	}
+}

learn/2.4/main.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	var x interface{}
+	x = 10
+	value, ok := x.(int)
+	fmt.Print(value, ",", ok)
+}