add new

Author: anakin

1. Two Sum.go

@@ -0,0 +1,16 @@
+package main
+
+func twoSum(nums []int, target int) []int {
+	m := make(map[int]int)
+	for i := 0; i < len(nums); i++ {
+		c, ok := m[nums[i]]
+		if ok {
+			r := []int{c, i}
+			return r
+		} else {
+			m[target-nums[i]] = i
+		}
+	}
+	r := []int{0, 0}
+	return r
+}

101. Symmetric Tree.go

@@ -0,0 +1,22 @@
+package main
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func isSymmetric(root *TreeNode) bool {
+	return isMirror(root, root)
+}
+
+func isMirror(t1 *TreeNode, t2 *TreeNode) bool {
+	if t1 == nil && t2 == nil {
+		return true
+	}
+	if t1 == nil || t2 == nil {
+		return false
+	}
+
+	return t1.Val == t2.Val && isMirror(t1.Right, t2.Left) && isMirror(t2.Left, t1.Right)
+}

104. Maximum Depth of Binary Tree.go

@@ -0,0 +1,18 @@
+package main
+
+import "math"
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func maxDepth(root *TreeNode) int {
+	if root == nil {
+		return 0
+	}
+	l := maxDepth(root.Left)
+	r := maxDepth(root.Right)
+	return int(math.Max(float64(l), float64(r))) + 1
+}

105. Construct Binary Tree from Preorder and Inorder Traversal.go

@@ -0,0 +1,33 @@
+package main
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func buildTree(preorder []int, inorder []int) *TreeNode {
+	if len(preorder) == 0 {
+		return nil
+	}
+	res := &TreeNode{
+		Val: preorder[0],
+	}
+	if len(preorder) == 1 {
+		return res
+	}
+	idx := func(val int, nums []int) int {
+		for i, v := range nums {
+			if v == val {
+				return i
+			}
+		}
+		return -1
+	}(res.Val, inorder)
+	if idx == -1 {
+		return nil
+	}
+	res.Left = buildTree(preorder[1:idx+1], inorder[:idx])
+	res.Right = buildTree(preorder[idx+1:], inorder[idx+1:])
+	return res
+}

110. Balanced Binary Tree.go

@@ -0,0 +1,28 @@
+package main
+
+import "math"
+
+type TreeNode struct {
+	Val   int
+	Left  *TreeNode
+	Right *TreeNode
+}
+
+func isBalanced(root *TreeNode) bool {
+	if root == nil {
+		return true
+	}
+
+	l := getHeight(root.Left)
+	r := getHeight(root.Right)
+	return l-r < 2 && r-l < 2 && isBalanced(root.Left) && isBalanced(root.Right)
+}
+
+func getHeight(root *TreeNode) int {
+
+	if root == nil {
+		return 0
+	}
+
+	return int(math.Max(float64(getHeight(root.Left)), float64(getHeight(root.Right))) + 1)
+}

121. Best Time to Buy and Sell Stock.go

@@ -0,0 +1,13 @@
+package main
+
+import "math"
+
+func maxProfit(prices []int) int {
+	max_profit := 0
+	min_price := math.MaxInt64
+	for _, v := range prices {
+		min_price = int(math.Min(float64(min_price), float64(v)))
+		max_profit = int(math.Max(float64(max_profit), float64(v-min_price)))
+	}
+	return max_profit
+}

122. Best Time to Buy and Sell Stock II.go

@@ -0,0 +1,12 @@
+package main
+
+import "math"
+
+func maxProfit(prices []int) int {
+	cur, max := 0, 0
+	for i := 1; i < len(prices); i++ {
+		cur = int(math.Max(float64(cur), float64(cur+prices[i]-prices[i-1])))
+		max = int(math.Max(float64(cur), float64(max)))
+	}
+	return max
+}

139. Word Break.go

@@ -0,0 +1,25 @@
+package main
+
+func wordBreak(s string, wordDict []string) bool {
+	l := len(s)
+	flags := make([]bool, l+1)
+	flags[0] = true
+	for i := 1; i <= l; i++ {
+		for j := 0; j < i; j++ {
+			if flags[j] == true && contain(s[j:i], wordDict) {
+				flags[i] = true
+				break
+			}
+		}
+	}
+	return flags[l]
+}
+
+func contain(s string, wordDict []string) bool {
+	for _, v := range wordDict {
+		if s == v {
+			return true
+		}
+	}
+	return false
+}

2. Add Two Numbers.go

@@ -0,0 +1,38 @@
+package main
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
+	result := &ListNode{0, nil}
+	cursor := result
+	leftBit, rightBit, carryBit := 0, 0, 0
+
+	for l1 != nil || l2 != nil || carryBit > 0 {
+		if l1 != nil { //考虑5+5的情况
+			leftBit = l1.Val
+			l1 = l1.Next
+		} else {
+			leftBit = 0
+		}
+
+		if l2 != nil {
+			rightBit = l2.Val
+			l2 = l2.Next
+		} else {
+			rightBit = 0
+		}
+
+		cursor.Val = (leftBit + rightBit + carryBit) % 10
+		carryBit = (leftBit + rightBit + carryBit) / 10
+
+		if l1 != nil || l2 != nil || carryBit > 0 {
+			cursor.Next = &ListNode{0, nil}
+			cursor = cursor.Next
+		}
+	}
+
+	return result
+}

3. Longest Substring Without Repeating Characters.go

@@ -0,0 +1,17 @@
+package main
+
+func lengthOfLongestSubstring(s string) int {
+	m := make(map[rune]int)
+	start, max := -1, 0
+
+	for k, v := range s {
+		if last, ok := m[v]; ok && last > start {
+			start = last
+		}
+		m[v] = k
+		if k-start > max {
+			max = k - start
+		}
+	}
+	return max
+}