feat: 字符串

Author: 陈世伟

leetcode/150.逆波兰表达式求值/evalRPN.go

@@ -0,0 +1,49 @@
+package _50_逆波兰表达式求值
+
+import (
+	"strconv"
+)
+
+func evalRPN(tokens []string) int {
+	l := len(tokens)
+	var stack []int
+	for i := 0; i < l; i++ {
+		switch tokens[i] {
+		case "+":
+			if len(stack) >= 2 {
+				num1, num2 := stack[len(stack)-2], stack[len(stack)-1]
+				stack = stack[:len(stack)-2]
+				stack = append(stack, num1+num2)
+			}
+		case "-":
+			if len(stack) >= 2 {
+				num1, num2 := stack[len(stack)-2], stack[len(stack)-1]
+				stack = stack[:len(stack)-2]
+				stack = append(stack, num1-num2)
+			}
+		case "*":
+			if len(stack) >= 2 {
+				num1, num2 := stack[len(stack)-2], stack[len(stack)-1]
+				stack = stack[:len(stack)-2]
+				stack = append(stack, num1*num2)
+			}
+		case "/":
+			if len(stack) >= 2 {
+				num1, num2 := stack[len(stack)-2], stack[len(stack)-1]
+				stack = stack[:len(stack)-2]
+				stack = append(stack, num1/num2)
+			}
+		default:
+			n, _ := strconv.Atoi(tokens[i])
+			stack = append(stack, n)
+		}
+	}
+
+	if len(stack) > 0 {
+		result := stack[0]
+		stack = stack[1:]
+		return result
+	}
+
+	return -1
+}

leetcode/150.逆波兰表达式求值/evalRPN_test.go

@@ -0,0 +1,25 @@
+package _50_逆波兰表达式求值
+
+import "testing"
+
+func Test_evalRPN(t *testing.T) {
+	type args struct {
+		tokens []string
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{name: `tokens = ["2","1","+","3","*"] 9`, args: args{tokens: []string{"2", "1", "+", "3", "*"}}, want: 9},
+		{name: `tokens = ["4","13","5","/","+"] 6`, args: args{tokens: []string{"4", "13", "5", "/", "+"}}, want: 6},
+		{name: `tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"] 22`, args: args{tokens: []string{"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"}}, want: 22},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := evalRPN(tt.args.tokens); got != tt.want {
+				t.Errorf("evalRPN() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

leetcode/239.滑动窗口最大值/maxSlidingWindow.go

@@ -0,0 +1,100 @@
+package _39_滑动窗口最大值
+
+import (
+	"fmt"
+	"github.com/chen-shiwei/leetcode/leetcode/datastruct"
+)
+
+type MyQueue struct {
+	dq *datastruct.Deque
+}
+
+func NewMyQueue() *MyQueue {
+	return &MyQueue{dq: datastruct.NewDeque()}
+}
+
+func (m *MyQueue) Push(x int) {
+	for !m.dq.Empty() && x > m.dq.Back() {
+		m.dq.PopBack()
+	}
+	m.dq.PushBack(x)
+}
+
+func (m *MyQueue) Pop(x int) {
+	if !m.dq.Empty() && x == m.dq.Front() {
+		fmt.Println("pop", m.dq.PopFront())
+	}
+}
+
+func (m *MyQueue) Front() int {
+	return m.dq.Front()
+}
+
+func maxSlidingWindow(nums []int, k int) []int {
+	l := len(nums)
+	//var q []int
+
+	qu := NewMyQueue()
+
+	//push := func(x int) {
+	//	if len(q) != 0 && x > q[len(q)-1] {
+	//		q = q[:len(q)-1]
+	//	}
+	//	q = append(q, x)
+	//}
+	//
+	//pop := func(x int) {
+	//	if len(q) != 0 && q[0] == x {
+	//		q = q[1:]
+	//	}
+	//}
+
+	var result []int
+	for i := 0; i < k; i++ {
+		qu.Push(nums[i])
+	}
+
+	qu.dq.Println()
+	//result = append(result, q[0])
+	result = append(result, qu.Front())
+	for i := k; i < l; i++ {
+		qu.Pop(nums[i-k])
+		qu.Push(nums[i])
+		qu.dq.Println()
+		result = append(result, qu.Front())
+		//result = append(result, q[0])
+	}
+	return result
+}
+
+func maxSlidingWindow1(nums []int, k int) []int {
+	l := len(nums)
+	var q []int
+
+	push := func(x int) {
+		for len(q) != 0 && x > q[len(q)-1] {
+			q = q[:len(q)-1]
+		}
+		q = append(q, x)
+	}
+
+	pop := func(x int) {
+		if len(q) != 0 && q[0] == x {
+			fmt.Println("pop", q[0])
+			q = q[1:]
+		}
+	}
+
+	var result []int
+	for i := 0; i < k; i++ {
+		push(nums[i])
+	}
+
+	result = append(result, q[0])
+	for i := k; i < l; i++ {
+		pop(nums[i-k])
+		push(nums[i])
+		result = append(result, q[0])
+	}
+	return result
+}

leetcode/239.滑动窗口最大值/maxSlidingWindow_test.go

@@ -0,0 +1,31 @@
+package _39_滑动窗口最大值
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_maxSlidingWindow(t *testing.T) {
+	type args struct {
+		nums []int
+		k    int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{name: `输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
+输出：[3,3,5,5,6,7]`, args: args{
+			nums: []int{1, 3, -1, -3, 5, 3, 6, 7},
+			k:    3,
+		}, want: []int{3, 3, 5, 5, 6, 7}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := maxSlidingWindow1(tt.args.nums, tt.args.k); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("maxSlidingWindow1() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

leetcode/25.K 个一组翻转链表/reverseKGroup.go

@@ -14,26 +14,36 @@ type ListNode struct {
 }
 
 func reverseKGroup(head *ListNode, k int) *ListNode {
-	var n = head
-
-	var stack []int
-
-	var c = k
-	for cur := head; cur != nil; cur = cur.Next {
-
-		if c == 0 {
-			var l = &ListNode{}
-			for _, v := range stack {
-				l.Val = v
-				l.Next = &ListNode{}
+	hair := &ListNode{Next: head}
+	pre := hair
+
+	for head != nil {
+		tail := pre
+		for i := 0; i < k; i++ {
+			tail = tail.Next
+			if tail == nil {
+				return hair.Next
 			}
-			stack = stack[:0]
-			c = k
-		} else {
-			stack = append([]int{cur.Val}, stack...)
-			c--
-		}
 
+		}
+		tmp := tail.Next
+		head, tail = reverseLinkedList(head, tail)
+		pre.Next = head
+		tail.Next = tmp
+		pre = tail
+		head = tail.Next
 	}
 
+	return hair.Next
+}
+
+func reverseLinkedList(head, tail *ListNode) (*ListNode, *ListNode) {
+	var pre, cur = tail.Next, head
+	for cur != nil {
+		tmp := cur.Next
+		cur.Next = pre
+		pre = cur
+		cur = tmp
+	}
+	return tail, head
 }

leetcode/28.实现strStr/strStr.go

@@ -0,0 +1,52 @@
+package _8_实现strStr
+
+import "fmt"
+
+func strStr(haystack string, needle string) int {
+	l1 := len(haystack)
+	l2 := len(needle)
+
+	for i := 0; i < l1-l2+1; i++ {
+		var s2 int
+		for j := 0; j < l2; j++ {
+			if haystack[i+j] != needle[j] {
+				continue
+			}
+			s2++
+		}
+
+		if s2 == l2 {
+			return i
+		}
+	}
+	return -1
+}
+
+func strStrWithKMP(haystack string, needle string) int {
+	l1 := len(haystack)
+	l2 := len(needle)
+
+	next := make([]int, l2)
+	for i, j := 1, 0; i < l2; i++ {
+		for j > 0 && needle[i] != needle[j] {
+			j = next[j-1]
+		}
+		if needle[i] == needle[j] {
+			j++
+		}
+		next[i] = j
+	}
+	fmt.Println(next)
+	for i, j := 0, 0; i < l1; i++ {
+		for j > 0 && haystack[i] != needle[j] {
+			j = next[j-1]
+		}
+		if haystack[i] == needle[j] {
+			j++
+		}
+		if j == l2 {
+			return i - l2 + 1
+		}
+	}
+	return -1
+}

leetcode/28.实现strStr/strStr_test.go

@@ -0,0 +1,39 @@
+package _8_实现strStr
+
+import "testing"
+
+func Test_strStr(t *testing.T) {
+	type args struct {
+		haystack string
+		needle   string
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{name: `输入：haystack = "hello", needle = "ll"
+输出：2`, args: args{
+			haystack: "hello",
+			needle:   "ll",
+		}, want: 2},
+		{name: `输入：haystack = "aabaabaafa", needle = "aabaaf"
+输出：2`, args: args{
+			haystack: "aabaabaafa",
+			needle:   "aabaaf",
+		}, want: 3},
+	}
+	for _, tt := range tests {
+		//t.Run(tt.name, func(t *testing.T) {
+		//	if got := strStr(tt.args.haystack, tt.args.needle); got != tt.want {
+		//		t.Errorf("strStr() = %v, want %v", got, tt.want)
+		//	}
+		//})
+		t.Run(tt.name, func(t *testing.T) {
+			if got := strStrWithKMP(tt.args.haystack, tt.args.needle); got != tt.want {
+				t.Errorf("strStrWithKMP() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+
+}

leetcode/347.前K个高频元素/topkfrequent.go

@@ -1,5 +1,10 @@
 package _47_前K个高频元素
 
+import (
+	"container/heap"
+	"github.com/chen-shiwei/leetcode/leetcode/datastruct"
+)
+
 func topKFrequent(nums []int, k int) []int {
 	var dict = make(map[int]int)
 
@@ -43,3 +48,26 @@ func QSort(nums [][]int) {
 	QSort(nums[left+1:])
 
 }
+
+func topKFrequentWithIHeap(nums []int, k int) []int {
+	dict := map[int]int{}
+	for _, v := range nums {
+		dict[v]++
+	}
+
+	h := &datastruct.IHeap{}
+	heap.Init(h)
+	for i, v := range dict {
+		heap.Push(h, [2]int{i, v})
+		if h.Len() > k {
+			heap.Pop(h)
+		}
+	}
+
+	result := make([]int, k)
+	for i := 0; i < k; i++ {
+		result[k-i-1] = heap.Pop(h).([2]int)[0]
+	}
+
+	return result
+}