Merge branch 'master' of github.com:kylesliu/awesome-golang-algorithm

Author: Cori1109

leetcode/1-100/0047.Permutations-II/Solution.go

@@ -1,5 +1,35 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+import "sort"
+
+func Solution(nums []int) [][]int {
+    res := [][]int{}
+    sort.Slice(nums, func(i, j int) bool {
+        return nums[i] < nums[j]
+    })
+    visited := make(map[int]bool)
+    helper(nums, []int{}, visited, &res)
+    return res
+}
+
+func helper(nums, res []int, visited map[int]bool, final *[][]int) {
+    if len(nums) == len(res) {
+        temp := make([]int, len(res))
+        copy(temp, res)
+        *final = append(*final, temp)
+        return
+    }
+    for i := 0; i < len(nums); i++ {
+        if visited[i] {
+            continue
+        }
+        if i > 0 && nums[i] == nums[i - 1] && !visited[i - 1] {
+            continue
+        }
+        res = append(res, nums[i])
+        visited[i] = true
+        helper(nums, res, visited, final)
+        visited[i] = false
+        res = res[:len(res) - 1]
+    }
 }

leetcode/1-100/0047.Permutations-II/Solution_test.go

@@ -9,12 +9,15 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs []int
+		expect [][]int
 	}{
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", false, false},
+		{"TestCacse 1", []int{1,1,2}, [][]int{
+			{1,1,2}, {1,2,1}, {2,1,1},
+		}},
+		{"TestCacse 2", []int{1,2,3}, [][]int{
+			{1,2,3},{1,3,2},{2,1,3},{2,3,1},{3,1,2},{3,2,1},
+		}},
 	}
 
 	//	开始测试

leetcode/1-100/0048.Rotate-Image/Solution.go

@@ -1,5 +1,17 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(matrix [][]int)  {
+    n := len(matrix)
+    for i := 0; i < n; i++ {
+        for j := i; j < n; j++ {
+            matrix[j][i], matrix[i][j] = matrix[i][j], matrix[j][i]
+        }
+    }
+    for i := 0; i < n; i++ {
+        reversed := make([]int, n)
+        for j := 0; j < n; j++ {
+            reversed[j] = matrix[i][n - j - 1]
+        }
+        matrix[i] = reversed
+    }
 }

leetcode/1-100/0048.Rotate-Image/Solution_test.go

@@ -9,21 +9,30 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs [][]int
+		expect [][]int
 	}{
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", false, false},
+		{"TestCase 1", [][]int{
+			{1,2,3}, {4,5,6}, {7,8,9},
+		}, [][]int{
+			{7,4,1}, {8,5,2}, {9,6,3},
+		}},
+		{"TestCase 2", [][]int{
+			{5,1,9,11},{2,4,8,10},{13,3,6,7},{15,14,12,16},
+		}, [][]int{
+			{15,13,2,5},{14,3,4,1},{12,6,8,9},{16,7,10,11},
+		}},
 	}
 
 	//	开始测试
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			ret := Solution(c.inputs)
-			if !reflect.DeepEqual(ret, c.expect) {
+			input := [][]int{}
+			copy(input, c.inputs)
+			Solution(c.inputs)
+			if !reflect.DeepEqual(c.inputs, c.expect) {
 				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, ret, c.inputs)
+					c.expect, c.inputs, input)
 			}
 		})
 	}

leetcode/1-100/0080.Remove-Duplicates-from-Sorted-Array-II/Solution.go

@@ -1,5 +1,33 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(nums []int) int {
+	cmpObj, repeatCount := nums[0], 1
+	fillIdx := 0
+	for idx := 1; idx < len(nums); idx++ {
+		if nums[idx] == cmpObj {
+			repeatCount++
+			continue
+		}
+
+		cmpObj = nums[idx]
+
+		if repeatCount > 2 {
+			repeatCount = 2
+		}
+		preObj := nums[idx-1]
+		for ; repeatCount > 0; repeatCount, fillIdx = repeatCount-1, fillIdx+1 {
+			nums[fillIdx] = preObj
+		}
+		repeatCount = 1
+	}
+	if repeatCount > 2 {
+		repeatCount = 2
+	}
+
+	preObj := nums[len(nums)-1]
+	for ; repeatCount > 0; repeatCount, fillIdx = repeatCount-1, fillIdx+1 {
+		nums[fillIdx] = preObj
+	}
+
+	return fillIdx
 }

leetcode/1-100/0080.Remove-Duplicates-from-Sorted-Array-II/Solution_test.go

@@ -9,12 +9,13 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs []int
+		expect int
 	}{
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", true, true},
-		{"TestCacse 1", false, false},
+		{"TestCase1", []int{1}, 1},
+		{"TestCase2", []int{1, 1, 1, 2, 2, 3}, 5},
+		{"TestCase3", []int{0, 0, 1, 1, 1, 1, 2, 3, 3}, 7},
+		{"TestCase4", []int{1, 2, 3, 4}, 4},
 	}
 
 	//	开始测试
@@ -25,6 +26,7 @@ func TestSolution(t *testing.T) {
 				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
 					c.expect, ret, c.inputs)
 			}
+			t.Logf("%v", c.inputs[:c.expect])
 		})
 	}
 }

leetcode/101-200/0103.Binary-Tree-Zigzag-Level-Order-Traversal/Solution.go

@@ -1,5 +1,34 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(root *TreeNode) [][]int {
+	if root == nil {
+		return [][]int{}
+    }
+	res := make([][]int, 0)
+    stack := []*TreeNode{root}
+    reverse := false
+    for len(stack) > 0 {
+        temp := make([]*TreeNode, 0)
+        tempVals := make([]int, 0)
+        for len(stack) > 0 {
+            node := stack[0]
+            tempVals = append(tempVals, node.Val)
+            if node.Left != nil {
+                temp = append(temp, node.Left)
+            }
+            if node.Right != nil {
+                temp = append(temp, node.Right)
+            }
+            stack = stack[1:]
+        }
+        if reverse {
+            for i, j := 0, len(tempVals) - 1; i < j; i, j = i + 1, j - 1 {
+                tempVals[i], tempVals[j] = tempVals[j], tempVals[i]
+            }
+        }
+        reverse = !reverse
+        res = append(res, tempVals)
+        stack = append(stack, temp...)
+    }
+    return res
 }

leetcode/101-200/0103.Binary-Tree-Zigzag-Level-Order-Traversal/Solution_test.go

@@ -10,12 +10,14 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		inputs *TreeNode
+		expect [][]int
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase", &TreeNode{3, &TreeNode{9, nil, nil}, &TreeNode{20, &TreeNode{15, nil, nil}, &TreeNode{7, nil, nil}}}, [][]int{
+			{3}, {20, 9}, {15,7},
+		}},
+		{"TestCase", &TreeNode{1, nil, nil}, [][]int{{1}}},
+		{"TestCase", nil, [][]int{}},
 	}
 
 	//	开始测试

leetcode/101-200/0103.Binary-Tree-Zigzag-Level-Order-Traversal/TreeNode.go

@@ -0,0 +1,7 @@
+package Solution
+
+type TreeNode struct {
+	Val int
+	Left *TreeNode
+	Right *TreeNode
+}

leetcode/101-200/0105.Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal/Solution.go

@@ -1,5 +1,25 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+var idxMap map[int]int
+var preorderIdx int
+
+func Solution(preorder []int, inorder []int) *TreeNode {
+    idxMap = make(map[int]int)
+    preorderIdx = 0
+    for i, v := range inorder {
+        idxMap[v] = i
+    }
+    return build(0, len(inorder) - 1, preorder)
+}
+
+func build(left, right int, preorder []int) *TreeNode {
+    if left > right {
+        return nil
+    }
+    root := &TreeNode{Val: preorder[preorderIdx]}
+    preorderIdx++
+    idx := idxMap[root.Val]
+    root.Left = build(left, idx - 1, preorder)
+    root.Right = build(idx + 1, right, preorder)
+    return root
 }

leetcode/101-200/0105.Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal/Solution_test.go

@@ -10,21 +10,21 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		preorder []int 
+		inorder []int
+		expect *TreeNode
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase", []int{3,9,20,15,7}, []int{9,3,15,20,7}, &TreeNode{3, &TreeNode{Val: 9}, &TreeNode{20, &TreeNode{Val: 15}, &TreeNode{Val: 7}}}},
+		{"TestCase", []int{-1}, []int{-1}, &TreeNode{Val: -1}},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.preorder, c.inorder)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v",
+					c.expect, got, c.preorder, c.inorder)
 			}
 		})
 	}

leetcode/101-200/0105.Construct-Binary-Tree-from-Preorder-and-Inorder-Traversal/TreeNode.go

@@ -0,0 +1,7 @@
+package Solution
+
+type TreeNode struct {
+	Val int
+	Left *TreeNode
+	Right *TreeNode
+}

leetcode/101-200/0106.Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal/Solution.go

@@ -1,5 +1,25 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+var idxMap map[int]int
+var p int
+
+func Solution(inorder []int, postorder []int) *TreeNode {
+    p = len(postorder) - 1
+    idxMap = make(map[int]int)
+    for i, v := range inorder {
+        idxMap[v] = i
+    }
+    return build(0, len(inorder) - 1, postorder)
+}
+
+func build(left, right int, postorder []int) *TreeNode {
+    if left > right {
+        return nil
+    }
+    root := &TreeNode{Val: postorder[p]}
+    p--
+    idx := idxMap[root.Val]
+    root.Right = build(idx + 1, right, postorder)
+    root.Left = build(left, idx - 1, postorder)
+    return root
 }

leetcode/101-200/0106.Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal/Solution_test.go

@@ -10,21 +10,21 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		postorder []int
+		inorder []int
+		expect *TreeNode
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase", []int{9,15,7,20,3}, []int{9,3,15,20,7}, &TreeNode{3, &TreeNode{Val: 9}, &TreeNode{20, &TreeNode{Val: 15}, &TreeNode{Val: 7}}}},
+		{"TestCase", []int{-1}, []int{-1}, &TreeNode{Val: -1}},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.inorder, c.postorder)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v",
+					c.expect, got, c.inorder, c.postorder)
 			}
 		})
 	}

leetcode/101-200/0106.Construct-Binary-Tree-from-Inorder-and-Postorder-Traversal/TreeNode.go

@@ -0,0 +1,7 @@
+package Solution
+
+type TreeNode struct {
+	Val int
+	Left *TreeNode
+	Right *TreeNode
+}