add leetcode and algs

Sitrone · Sitrone · commit 6daea0df2c0c · 2020-02-09T13:07:42.000+08:00
diff --git a/algs/leetcode/14_longestCommonPrefix.go b/algs/leetcode/14_longestCommonPrefix.go
@@ -0,0 +1,78 @@
+package leetcode
+
+import (
+	"bytes"
+	"fmt"
+)
+
+type node struct {
+	next  map[uint8]*node
+	isEnd bool
+}
+
+func (n *node) String() string {
+	return fmt.Sprintf("isEnd=%t, next=%v", n.isEnd, n.next)
+}
+
+func addWord(n *node, word string) {
+	for i := 0; i < len(word); i++ {
+		if n.next[word[i]-'a'] == nil {
+			n.next[word[i]-'a'] = &node{next: make(map[uint8]*node, 26)}
+		}
+		n = n.next[word[i]-'a']
+	}
+	n.isEnd = true
+}
+
+// 思路1：使用Trie树，4ms，击败6.37%用户，性能损耗在需要先扫描全部字符串，然后再判断
+// 占用存储4.7MB，击败5.1%用户
+func longestCommonPrefix(strs []string) string {
+	var root = &node{next: make(map[uint8]*node, 26)}
+
+	for _, s := range strs {
+		if s == "" {
+			return ""
+		}
+		addWord(root, s)
+	}
+
+	fmt.Println(root)
+	var ans bytes.Buffer
+	for cur := root; cur != nil && len(cur.next) == 1 && cur.isEnd == false; {
+		for k, n := range cur.next {
+			ans.WriteByte(k + 'a')
+			cur = n
+		}
+	}
+
+	return ans.String()
+}
+
+// 直接横向扫描, 耗时0ms，击败100%， 存储2.4MB，击败98.56%
+func longestCommonPrefix1(strs []string) string {
+	if len(strs) == 0 {
+		return ""
+	}
+	if len(strs) == 1 {
+		return strs[0]
+	}
+
+	var ans = make([]byte, 0, 2)
+	s1 := strs[0]
+	var equal bool
+	for i := 0; i < len(s1); i++ {
+		equal = true
+		for j := 1; j < len(strs); j++ {
+			if len(strs[j]) <= i || strs[j][i] != s1[i] {
+				equal = false
+			}
+		}
+		if equal {
+			ans = append(ans, s1[i])
+		} else {
+			break
+		}
+	}
+
+	return string(ans)
+}
diff --git a/algs/leetcode/14_longestCommonPrefix_test.go b/algs/leetcode/14_longestCommonPrefix_test.go
@@ -0,0 +1,13 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestLongestCommonPrefix(t *testing.T) {
+	strs := []string{"flowe", "flow", ""}
+	//strs := []string{"dog", "racecar", "car"}
+	ans := longestCommonPrefix1(strs)
+	fmt.Println(ans)
+}
diff --git a/algs/leetcode/155_MinStack.go b/algs/leetcode/155_MinStack.go
@@ -0,0 +1,54 @@
+package leetcode
+
+type MinStack struct {
+	eles    []int
+	minNums []int
+}
+
+// 思路：双栈，一个存储正常的值，一个存储最小值（有数据冗余）
+/** initialize your data structure here. */
+func Constructor() MinStack {
+	return MinStack{
+		eles:    make([]int, 0),
+		minNums: make([]int, 0),
+	}
+}
+
+func (this *MinStack) Push(x int) {
+	this.eles = append(this.eles, x)
+
+	if len(this.minNums) == 0 {
+		this.minNums = append(this.minNums, x)
+	} else {
+		if x > this.GetMin() {
+			this.minNums = append(this.minNums, this.GetMin())
+		} else {
+			this.minNums = append(this.minNums, x)
+		}
+	}
+}
+
+func (this *MinStack) Pop() {
+	if len(this.eles) == 0 {
+		return
+	}
+
+	this.eles = this.eles[:len(this.eles)-1]
+	this.minNums = this.minNums[:len(this.minNums)-1]
+}
+
+func (this *MinStack) Top() int {
+	if len(this.eles) == 0 {
+		return -1
+	}
+
+	return this.eles[len(this.eles)-1]
+}
+
+func (this *MinStack) GetMin() int {
+	if len(this.minNums) == 0 {
+		return -1
+	}
+
+	return this.minNums[len(this.minNums)-1]
+}
diff --git a/algs/leetcode/21_mergeTwoLists.go b/algs/leetcode/21_mergeTwoLists.go
@@ -0,0 +1,57 @@
+package leetcode
+
+// 23题的简化版，
+// 思路1：23题的小顶堆解法可以直接挪过来
+// 思路2，直接合并
+
+func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
+	head := &ListNode{Val: -1}
+
+	cur, cur1, cur2 := head, l1, l2
+	for ; cur1 != nil && cur2 != nil; cur = cur.Next {
+		if cur1.Val > cur2.Val {
+			cur.Next = &ListNode{Val: cur2.Val}
+			cur2 = cur2.Next
+		} else {
+			cur.Next = &ListNode{Val: cur1.Val}
+			cur1 = cur1.Next
+		}
+	}
+
+	for ; cur1 != nil; cur = cur.Next {
+		cur.Next = &ListNode{Val: cur1.Val}
+		cur1 = cur1.Next
+	}
+
+	for ; cur2 != nil; cur = cur.Next {
+		cur.Next = &ListNode{Val: cur2.Val}
+		cur2 = cur2.Next
+	}
+
+	return head.Next
+}
+
+func mergeTwoLists1(l1 *ListNode, l2 *ListNode) *ListNode {
+	head := &ListNode{Val: -1}
+
+	cur, cur1, cur2 := head, l1, l2
+	for ; cur1 != nil && cur2 != nil; cur = cur.Next {
+		if cur1.Val > cur2.Val {
+			cur.Next = &ListNode{Val: cur2.Val}
+			cur2 = cur2.Next
+		} else {
+			cur.Next = &ListNode{Val: cur1.Val}
+			cur1 = cur1.Next
+		}
+	}
+
+	if cur1 != nil {
+		cur.Next = cur1
+	}
+
+	if cur2 != nil {
+		cur.Next = cur2
+	}
+
+	return head.Next
+}
diff --git a/algs/leetcode/5311_numberOfSteps.go b/algs/leetcode/5311_numberOfSteps.go
@@ -0,0 +1,19 @@
+package leetcode
+
+func numberOfSteps(num int) int {
+	var f func(step, reminder int) int
+	f = func(step, reminder int) int {
+		if reminder == 0 {
+			return step
+		}
+
+		step++
+		if (reminder & 0x01) == 0 {
+			return f(step, reminder>>1)
+		} else {
+			return f(step, reminder-1)
+		}
+	}
+
+	return f(0, num)
+}
diff --git a/algs/leetcode/641_designDeque.go b/algs/leetcode/641_designDeque.go
@@ -108,16 +108,16 @@ type ListNode2 struct {
 }
 
 /** Initialize your data structure here. Set the size of the deque to be k. */
-func Constructor(k int) MyCircularDeque {
-	node := &ListNode2{Val: -1}
-	node.Next = node
-	node.Pre = node
-	return MyCircularDeque{
-		len:       0,
-		cap:       k,
-		dummyNode: node,
-	}
-}
+//func Constructor(k int) MyCircularDeque {
+//	node := &ListNode2{Val: -1}
+//	node.Next = node
+//	node.Pre = node
+//	return MyCircularDeque{
+//		len:       0,
+//		cap:       k,
+//		dummyNode: node,
+//	}
+//}
 
 /** Adds an item at the front of Deque. Return true if the operation is successful. */
 func (this *MyCircularDeque) InsertFront(value int) bool {
diff --git a/algs/leetcode/784_letterCasePermutation.go b/algs/leetcode/784_letterCasePermutation.go
@@ -0,0 +1,31 @@
+package leetcode
+
+import "strings"
+
+func letterCasePermutation(S string) []string {
+	ans := make([]string, 0, 2)
+	S = strings.ToLower(S)
+
+	var backtrace func(pos int, cur []byte)
+	backtrace = func(pos int, cur []byte) {
+		if len(cur) == len(S) {
+			ans = append(ans, string(cur))
+			return
+		}
+
+		if S[pos] >= 'a' && S[pos] <= 'z' {
+			for i := 0; i < 2; i++ {
+				cur = append(cur, S[pos]-uint8(32*i))
+				backtrace(pos+1, cur)
+				cur = cur[:len(cur)-1]
+			}
+		} else {
+			cur = append(cur, S[pos])
+			backtrace(pos+1, cur)
+		}
+	}
+
+	cur := make([]byte, 0, len(S))
+	backtrace(0, cur)
+	return ans
+}
diff --git a/algs/leetcode/784_letterCasePermutation_test.go b/algs/leetcode/784_letterCasePermutation_test.go
@@ -0,0 +1,14 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestLetterCasePermutation(t *testing.T) {
+	S := "a1b2"
+	ans := letterCasePermutation(S)
+
+	fmt.Println(len(ans))
+	fmt.Println(ans)
+}
diff --git a/algs/leetcode/78_subsets.go b/algs/leetcode/78_subsets.go
@@ -21,9 +21,30 @@ func subsets(nums []int) [][]int {
 	}
 
 	for i := 0; i <= len(nums); i++ {
-		cur := make([]int, 0, len(nums))
+		cur := make([]int, 0, i)
 		backtrace(0, i, cur)
 	}
 
 	return ans
 }
+
+// 动态规划:
+// 初始状态：dp[0]=[[]];
+// dp[i+1]={dp[i],[dp[i],nums[i-1]]}
+// FIXME 参考解法
+func subsets1(nums []int) [][]int {
+	result := make([][]int, 0)
+	result = append(result, []int{})
+
+	//遍历nums中的数，每遍历到一个就将该值依次添加到前面的所有子集中，形成新的子集
+	for i := 0; i < len(nums); i++ {
+		l := len(result)
+		for j := 0; j < l; j++ {
+			tmp := make([]int, 0)
+			tmp = append(tmp, result[j]...)
+			tmp = append(tmp, nums[i])
+			result = append(result, tmp)
+		}
+	}
+	return result
+}
diff --git a/algs/leetcode/90_subsetsWithDup.go b/algs/leetcode/90_subsetsWithDup.go
@@ -0,0 +1,36 @@
+package leetcode
+
+import "sort"
+
+func subsetsWithDup(nums []int) [][]int {
+	ans := make([][]int, 0)
+	sort.Ints(nums)
+
+	var backtrace func(pos, num int, cur []int)
+	backtrace = func(pos, num int, cur []int) {
+		if len(cur) == num {
+			tmp := make([]int, len(cur))
+			copy(tmp, cur)
+			ans = append(ans, tmp)
+			return
+		}
+
+		for i := pos; i < len(nums); i++ {
+			// 前面那个重复元素已经使用，则不再使用，在78题的基础上面剪枝
+			if i > pos && nums[i] == nums[i-1] {
+				continue
+			}
+
+			cur = append(cur, nums[i])
+			backtrace(i+1, num, cur)
+			cur = cur[:len(cur)-1]
+		}
+	}
+
+	for i := 0; i <= len(nums); i++ {
+		cur := make([]int, 0, i)
+		backtrace(0, i, cur)
+	}
+
+	return ans
+}
diff --git a/algs/leetcode/90_subsetsWithDup_test.go b/algs/leetcode/90_subsetsWithDup_test.go
@@ -0,0 +1,14 @@
+package leetcode
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSubsetsWithDup(t *testing.T) {
+	nums := []int{1, 2, 2, 3}
+	ans := subsetsWithDup(nums)
+
+	fmt.Println(len(ans))
+	fmt.Println(ans)
+}
diff --git a/algs/leetcode/9_isPalindrome.go b/algs/leetcode/9_isPalindrome.go
diff --git a/algs/leetcode/9_isPalindrome_test.go b/algs/leetcode/9_isPalindrome_test.go
