第二周和第三周作业#10

Week_02/id_10/Leecode-102-10.go

@@ -0,0 +1,53 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+//DFS
+var result [][]int
+
+func levelOrder(root *TreeNode) [][]int {
+	result = [][]int{}
+	helper(root, 0)
+	return result
+}
+
+func helper(root *TreeNode, level int) {
+	if root == nil {
+		return
+	}
+	if len(result) <= level {
+		result = append(result, []int{})
+	}
+	result[level] = append(result[level], root.Val)
+	helper(root.Left, level+1)
+	helper(root.Right, level+1)
+}
+
+//BFS
+func levelOrder2(root *TreeNode) [][]int {
+	if root == nil {
+		return [][]int{}
+	}
+	result := make([][]int, 0)
+	nodes := []*TreeNode{root}
+	for len(nodes) > 0 {
+		result = append(result, []int{})
+		newnodes := make([]*TreeNode, 0)
+		for i := 0; i < len(nodes); i++ {
+			node := nodes[i]
+			result[len(result)-1] = append(result[len(result)-1], node.Val)
+			if node.Left != nil {
+				newnodes = append(newnodes, node.Left)
+			}
+			if node.Right != nil {
+				newnodes = append(newnodes, node.Right)
+			}
+		}
+		nodes = newnodes
+	}
+	return result
+}

Week_02/id_10/Leecode-103-10.go

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func zigzagLevelOrder(root *TreeNode) [][]int {
+	if root == nil {
+		return [][]int{}
+	}
+	nodes := []*TreeNode{root}
+	result := make([][]int, 0)
+	reversed := true
+	for len(nodes) > 0 {
+		newnodes := make([]*TreeNode, 0)
+		result = append(result, []int{})
+		for i := 0; i < len(nodes); i++ {
+			node := nodes[i]
+			result[len(result)-1] = append(result[len(result)-1], node.Val)
+		}
+		for i := len(nodes) - 1; i >= 0; i-- {
+			node := nodes[i]
+			if reversed {
+				if node.Right != nil {
+					newnodes = append(newnodes, node.Right)
+				}
+				if node.Left != nil {
+					newnodes = append(newnodes, node.Left)
+				}
+			} else {
+				if node.Left != nil {
+					newnodes = append(newnodes, node.Left)
+				}
+				if node.Right != nil {
+					newnodes = append(newnodes, node.Right)
+				}
+			}
+		}
+		nodes = newnodes
+		reversed = !reversed
+	}
+	return result
+}

Week_02/id_10/Leecode-242-10.go

@@ -0,0 +1,40 @@
+func isAnagram(s string, t string) bool {
+	if len(s) != len(t) {
+		return false
+	}
+	// 如果字符串包含 unicode 字符，使用map处理
+	// 测试数据："中国" ,"国中"
+	anagramrel := make(map[rune]int)
+	for _, b := range s {
+		anagramrel[b]++
+	}
+	for _, b := range t {
+		anagramrel[b]--
+		if anagramrel[b] < 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func isAnagram2(s string, t string) bool {
+	sbytes := []byte(s)
+	tbytes := []byte(t)
+	if len(sbytes) != len(tbytes) {
+		return false
+	}
+	// 如果字符串只包含小写字母  创建len=26的数组代替map
+	hasharr := make([]int, 26)
+	for i := 0; i < len(sbytes); i++ {
+		sb := sbytes[i]
+		hasharr[sb-'a'] += 1
+	}
+	for i := 0; i < len(tbytes); i++ {
+		tb := tbytes[i]
+		hasharr[tb-'a'] -= 1
+		if hasharr[tb-'a'] < 0 {
+			return false
+		}
+	}
+	return true
+}

Week_02/id_10/Leecode-3-10.go

@@ -0,0 +1,27 @@
+func lengthOfLongestSubstring(s string) int {
+	if len(s) == 0 {
+		return 0
+	}
+	maxsublen := 1
+	lastlen := 1
+	alphaposrel := make(map[byte]int)
+	alphaposrel[s[0]] = 0
+	for i := 1; i < len(s); i++ {
+		b := s[i]
+		cursublen := 0
+		if pos, ok := alphaposrel[b]; ok {
+			cursublen = i - pos
+		} else {
+			cursublen = i + 1
+		}
+		if cursublen > lastlen+1 {
+			cursublen = lastlen + 1
+		}
+		if maxsublen < cursublen {
+			maxsublen = cursublen
+		}
+		lastlen = cursublen
+		alphaposrel[b] = i
+	}
+	return maxsublen
+}

Week_02/id_10/Leecode-692-10.go

@@ -0,0 +1,44 @@
+import "sort"
+
+type WNode struct {
+	Val      string
+	Frequent int
+}
+
+type WNodes []*WNode
+
+func (s WNodes) Len() int      { return len(s) }
+func (s WNodes) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s WNodes) Less(i, j int) bool {
+	if s[i].Frequent > s[j].Frequent {
+		return true
+	} else if s[i].Frequent == s[j].Frequent {
+		return s[i].Val < s[j].Val
+	}
+	return false
+}
+
+func topKFrequent(words []string, k int) []string {
+	if k <= 0 {
+		return []string{}
+	}
+	frequenthash := make(map[string]*WNode)
+	frequentarr := make([]*WNode, 0, len(words))
+	for i := 0; i < len(words); i++ {
+		w := words[i]
+		if node, ok := frequenthash[w]; ok {
+			node.Frequent++
+		} else {
+			node = &WNode{w, 1}
+			frequenthash[w] = node
+			frequentarr = append(frequentarr, node)
+		}
+	}
+	sort.Sort(WNodes(frequentarr))
+	retarr := make([]string, k)
+	for i := 0; i < k; i++ {
+		retarr[i] = frequentarr[i].Val
+	}
+	return retarr
+
+}

Week_02/id_10/Leecode-726-10.go

@@ -0,0 +1,76 @@
+import "strconv"
+import "strings"
+import "sort"
+
+func countOfAtoms(formula string) string {
+	s := []byte(formula)
+	resultmap, _ := helper(s, 0)
+	resultstrs := make([]string, len(resultmap))
+	for k, v := range resultmap {
+		vstr := strconv.Itoa(v)
+		if vstr == "1" {
+			vstr = ""
+		}
+		resultstrs = append(resultstrs, k+vstr)
+	}
+	sort.Strings(resultstrs)
+	return strings.Join(resultstrs, "")
+
+}
+
+func helper(s []byte, start int) (map[string]int, int) {
+	elmentmap := make(map[string]int)
+	i := start
+	curel := ""
+	for i < len(s) {
+		if curel != "" && (s[i] < '0' || s[i] > '9') {
+			elmentmap[curel] += 1
+			curel = ""
+		}
+		if s[i] >= 'A' && s[i] <= 'Z' {
+			elbytes := make([]byte, 0)
+			elbytes = append(elbytes, s[i])
+			for i+1 < len(s) && s[i+1] >= 'a' && s[i+1] <= 'z' {
+				i++
+				elbytes = append(elbytes, s[i])
+			}
+			curel = string(elbytes)
+		}
+		if s[i] >= '0' && s[i] <= '9' {
+			nbyte := make([]byte, 0)
+			nbyte = append(nbyte, s[i])
+			for i+1 < len(s) && s[i+1] >= '0' && s[i+1] <= '9' {
+				i++
+				nbyte = append(nbyte, s[i])
+			}
+			numbyte, _ := strconv.Atoi(string(nbyte))
+			elmentmap[curel] += numbyte
+			curel = ""
+		} else if s[i] == '(' {
+			subelmap, pos := helper(s, i+1)
+			for k, v := range subelmap {
+				elmentmap[k] += v
+			}
+			i = pos
+		} else if s[i] == ')' {
+			nbyte := make([]byte, 0)
+			for i+1 < len(s) && s[i+1] >= '0' && s[i+1] <= '9' {
+				i++
+				nbyte = append(nbyte, s[i])
+			}
+			if len(nbyte) > 0 {
+				numbyte, _ := strconv.Atoi(string(nbyte))
+				for k, v := range elmentmap {
+					elmentmap[k] = v * numbyte
+				}
+			}
+			return elmentmap, i
+		}
+		i++
+	}
+	if curel != "" {
+		elmentmap[curel] += 1
+		curel = ""
+	}
+	return elmentmap, i
+}

Week_02/id_10/Leecode-783-10.go

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+//二叉树  中序遍历  递增
+const int_min = ^int(^uint(0) >> 1)
+
+var pre int
+var min_diff int
+
+func minDiffInBST(root *TreeNode) int {
+	pre = int_min
+	min_diff = int(^uint(0) >> 1)
+	_dfs(root)
+	return min_diff
+}
+
+func _dfs(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	_dfs(root.Left)
+	if pre != int_min && root.Val-pre < min_diff {
+		min_diff = root.Val - pre
+	}
+	pre = root.Val
+	_dfs(root.Right)
+}

Week_02/id_10/Leecode-938-10.go

@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func rangeSumBST(root *TreeNode, L int, R int) int {
+	if root == nil {
+		return 0
+	}
+	result := 0
+	if root.Val < L {
+		result += rangeSumBST(root.Right, L, R)
+	} else if root.Val > R {
+		result += rangeSumBST(root.Left, L, R)
+	} else {
+		result += root.Val
+		result += rangeSumBST(root.Left, L, R)
+		result += rangeSumBST(root.Right, L, R)
+	}
+	return result
+}

Week_02/id_10/Leecode-98-10.go

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+var pre int
+
+func isValidBST(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+	// int类型的最小值
+	pre = ^int(^uint(0) >> 1)
+	return _dfs(root)
+}
+
+//二叉搜索树 中序遍历  递增序列
+func _dfs(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+	if !_dfs(root.Left) {
+		return false
+	}
+	curVal := root.Val
+	if curVal <= pre {
+		return false
+	}
+	pre = curVal
+	if !_dfs(root.Right) {
+		return false
+	}
+	return true
+}