添加新题目

双指针/接雨水/main.go

@@ -1,33 +1,73 @@
 package main
 
-import "fmt"
+import (
+	"fmt"
+)
 
 func main() {
-	resule := trap([]int{4, 2, 0, 3, 2, 5})
+	resule := trap([]int{0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1})
 	fmt.Println("最大接水数为：", resule)
 }
 
 func trap(height []int) int {
-	leftP := 0
-	rightP := 1
-	result := 0
-	midres := 0
-	for {
-		if leftP > len(height)-1 || rightP > len(height)-1 {
-			break
+	value := 0
+	leftmax := make([]int, len(height))
+	rightmax := make([]int, len(height))
+	leftmax[0] = height[0]
+	rightmax[len(height)-1] = height[len(height)-1]
+	for i := 1; i < len(height); i++ {
+		leftmax[i] = max(leftmax[i-1], height[i])
 	}
-		if height[leftP] > height[rightP] {
-			midres += height[leftP] - height[rightP]
-			fmt.Println("result加上:", height[leftP]-height[rightP], "当前左指针：", leftP, "当前右指针:", rightP)
-			rightP++
-		} else if height[leftP] <= height[rightP] && midres != 0 {
-			result += midres
-			leftP = rightP
-			rightP = leftP + 1
-		} else {
-			leftP++
-			rightP = leftP + 1
+	for j := len(height) - 2; j >= 0; j-- {
+		rightmax[j] = max(rightmax[j+1], height[j])
 	}
+	fmt.Println(leftmax)
+	fmt.Println(rightmax)
+	for i := 0; i < len(height); i++ {
+		value += min(leftmax[i], rightmax[i]) - height[i]
 	}
-	return result
+
+	return value
 }
+
+// 错误思路:只计算凹槽，一个桶里可能有多个凹槽
+//
+//func trap(height []int) int {
+//	tap := make([]int, 0)
+//	for i := 0; i < len(height); i++ {
+//		if i-1 >= 0 && i+1 < len(height) {
+//			if height[i-1]-height[i] > 0 && height[i] < height[i+1] {
+//				tap = append(tap, i)
+//			}
+//		}
+//	}
+//	fmt.Println(tap)
+//	value := 0
+//	for i := range tap {
+//		tempvalue := 0
+//		left, right := tap[i], tap[i]
+//		for height[left-1] > height[left] {
+//			left--
+//		}
+//		for height[right+1] > height[right] {
+//			right++
+//		}
+//		fmt.Println("左右指针指向：", left, right)
+//		temp := min(height[left], height[right])
+//		for left != right {
+//			if temp-height[left] < 0 {
+//				left++
+//			} else {
+//				value += temp - height[left]
+//				tempvalue += temp - height[left]
+//				fmt.Println("当前temp和left的值", temp, height[left])
+//				fmt.Println("添加体积：", tempvalue)
+//
+//				left++
+//			}
+//
+//		}
+//		fmt.Println("临时体积：", tempvalue)
+//	}
+//	return value
+//}

子串/和为K的子数组/main.go

@@ -0,0 +1,40 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(subarraySum([]int{1, 2, 1, 2, 1}, 3))
+}
+
+func subarraySum(nums []int, k int) int {
+	result := 0
+	hash := make(map[int]int)
+	value := 0
+	hash[0] = 1
+	for i := range nums {
+		value += nums[i]
+		if v, ok := hash[value-k]; ok {
+			result += v
+		}
+		hash[value]++
+	}
+
+	return result
+}
+
+//func subarraySum(nums []int, k int) int {
+//	slow := 0
+//	result := 0
+//	for slow < len(nums) {
+//		value := 0
+//		fmt.Println("1")
+//		for fast := slow; fast < len(nums); fast++ {
+//			value += nums[fast]
+//			if value == k {
+//				result += 1
+//			}
+//		}
+//		slow++
+//	}
+//	return result
+//}

子串/滑动窗口最大值/main.go

@@ -0,0 +1,166 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+)
+
+func main() {
+	var a []int
+	a[0] = 1
+	fmt.Println(a[1])
+	//fmt.Println(maxSlidingWindow([]int{1, 3, -1, -3, 5, 3, 6, 7}, 3))
+}
+
+func maxSlidingWindow(nums []int, k int) []int {
+	queue := make([]int, k)
+	result := make([]int, 0)
+	for i := 0; i < k; i++ {
+		queue[i] = nums[i]
+	}
+	maxnum := 0
+	for i := 0; i < len(nums)-k+1; i++ {
+		if i == 0 {
+			queuetmp := make([]int, len(queue))
+			copy(queuetmp, queue) // 深拷贝
+			sort.Ints(queuetmp)
+			maxnum = queuetmp[k-1]
+			result = append(result, queuetmp[k-1])
+
+			//fmt.Println("result:", result)
+			continue
+		}
+		fmt.Println("queue分割前：", queue)
+		queueA := queue[1:]
+		//fmt.Println("queueA", queueA)
+		queueA = append(queueA, nums[i+k-1])
+		queue = queueA
+		fmt.Println("max", maxnum)
+		fmt.Println("当前右边界:", nums[i+k-1])
+		if nums[i+k-1] >= maxnum {
+			maxnum = nums[i+k-1]
+			result = append(result, nums[i+k-1])
+		} else {
+			queuetmp := make([]int, len(queue))
+			copy(queuetmp, queue) // 深拷贝
+			sort.Ints(queuetmp)
+			result = append(result, queuetmp[k-1])
+		}
+		//
+
+		//fmt.Println("queueA2", queueA)
+		//fmt.Println("queueA", queue)
+
+		fmt.Println("result:", result)
+	}
+	return result
+}
+
+//func maxSlidingWindow(nums []int, k int) []int {
+//	queue := make([]int, k)
+//	result := make([]int, 0)
+//	for i := 0; i < k; i++ {
+//		queue[i] = nums[i]
+//	}
+//	maxnum := 0
+//	for i := 0; i < len(nums)-k+1; i++ {
+//		if i == 0 {
+//			queuetmp := make([]int, len(queue))
+//			copy(queuetmp, queue) // 深拷贝
+//			sort.Ints(queuetmp)
+//			maxnum = queuetmp[k-1]
+//			result = append(result, queuetmp[k-1])
+//
+//			//fmt.Println("result:", result)
+//			continue
+//		}
+//		fmt.Println("queue分割前：", queue)
+//		queueA := queue[1:]
+//		//fmt.Println("queueA", queueA)
+//		queueA = append(queueA, nums[i+k-1])
+//		queue = queueA
+//		fmt.Println("max", maxnum)
+//		fmt.Println("当前右边界:", nums[i+k-1])
+//		if nums[i+k-1] >= maxnum {
+//			maxnum = nums[i+k-1]
+//			result = append(result, nums[i+k-1])
+//		} else {
+//			queuetmp := make([]int, len(queue))
+//			copy(queuetmp, queue) // 深拷贝
+//			sort.Ints(queuetmp)
+//			result = append(result, queuetmp[k-1])
+//		}
+//		//
+//
+//		//fmt.Println("queueA2", queueA)
+//		//fmt.Println("queueA", queue)
+//
+//		fmt.Println("result:", result)
+//	}
+//	return result
+//}
+
+//func maxSlidingWindow(nums []int, k int) []int {
+//	queue := make([]int, k)
+//	result := make([]int, 0)
+//	for i := 0; i < k; i++ {
+//		queue[i] = nums[i]
+//	}
+//	maxnum := 0
+//	for i := 0; i < len(nums)-k+1; i++ {
+//		if i == 0 {
+//			queuetmp := make([]int, len(queue))
+//			copy(queuetmp, queue) // 深拷贝
+//			sort.Ints(queuetmp)
+//			maxnum = queuetmp[k-1]
+//			result = append(result, queuetmp[k-1])
+//
+//			//fmt.Println("result:", result)
+//			continue
+//		}
+//		fmt.Println("queue分割前：", queue)
+//		queueA := queue[1:]
+//		//fmt.Println("queueA", queueA)
+//		queueA = append(queueA, nums[i+k-1])
+//		queue = queueA
+//		fmt.Println("max", maxnum)
+//		fmt.Println("当前右边界:", nums[i+k-1])
+//		if nums[i+k-1] >= maxnum {
+//			maxnum = nums[i+k-1]
+//			result = append(result, nums[i+k-1])
+//		} else {
+//			queuetmp := make([]int, len(queue))
+//			copy(queuetmp, queue) // 深拷贝
+//			sort.Ints(queuetmp)
+//			result = append(result, queuetmp[k-1])
+//		}
+//		//
+//
+//		//fmt.Println("queueA2", queueA)
+//		//fmt.Println("queueA", queue)
+//
+//		fmt.Println("result:", result)
+//	}
+//	return result
+//}
+
+//func maxSlidingWindow(nums []int, k int) []int {
+//	result := make([]int, 0)
+//	nowmax := 0
+//	for i := 0; i < len(nums)-k+1; i++ {
+//		if i == 0 {
+//			tmp := nums[:k]
+//			sort.Ints(tmp)
+//			result = append(result, tmp[k-1])
+//			nowmax = tmp[k-1]
+//			continue
+//		}
+//		if nums[i+k-1] > nowmax {
+//			result = append(result, nums[i+k-1])
+//		} else {
+//			result = append(result, nowmax)
+//		}
+//
+//	}
+//	return result
+//}

普通数组/合并区间/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"sort"
+)
+
+func main() {
+	intervals := [][]int{
+		{5, 5},
+		{1, 3},
+		{3, 5},
+		{4, 6},
+		{1, 1},
+		{3, 3},
+		{5, 6},
+		{3, 3},
+		{2, 4},
+		{0, 0},
+	}
+
+	merge(intervals)
+}
+
+func merge(intervals [][]int) [][]int {
+	sort.Slice(intervals, func(i, j int) bool {
+		return intervals[i][0] < intervals[j][0]
+	})
+	//fmt.Println(intervals)
+	tp2 := -1
+	result := [][]int{}
+	for i := 0; i < len(intervals); i++ {
+		if intervals[i][0] < tp2 {
+			continue
+		}
+		temp := make([]int, 0)
+		temp = append(temp, intervals[i]...)
+
+		tp := intervals[i][1]
+		//fmt.Println("当前tp1", tp)
+		for j := i + 1; j < len(intervals); j++ {
+			if intervals[j][0] <= tp {
+				temp = append(temp, intervals[j]...)
+				tp = max(intervals[j][1], tp)
+				//fmt.Println("--", intervals[j][1], intervals[i][1])
+
+				//fmt.Println("当前tp", tp)
+			}
+		}
+		//fmt.Println("temp", temp)
+		//fmt.Println("当前tp", tp)
+		tp2 = tp + 1
+		sort.Ints(temp)
+		result = append(result, []int{temp[0], temp[len(temp)-1]})
+	}
+	//fmt.Println(result)
+	return result
+}

普通数组/最大子数组和/main.go

@@ -0,0 +1,40 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(maxSubArray([]int{-1, 0, -2}))
+}
+
+func maxSubArray(nums []int) int {
+	if len(nums) == 1 {
+		return nums[0]
+	}
+	result := nums[0]
+	value := 0
+	tmp := make([]int, 0)
+	for i := range nums {
+		value += nums[i]
+		tmp = append(tmp, value)
+	}
+	fmt.Println(tmp)
+	minnum := make([]int, len(tmp)+1)
+	minnum[0] = 0
+	for i, v := range tmp {
+		//fmt.Println("当前数字：", nums[i])
+		minnum[i+1] = min(v, minnum[i])
+		temp := tmp[i] - minnum[i]
+		fmt.Println("当前temp", temp)
+
+		if result <= temp {
+			result = temp
+		}
+
+	}
+
+	fmt.Println("minnum", minnum)
+	////fmt.Println("maxnum", maxnum)
+	//fmt.Println(result)
+
+	return result
+}

普通数组/轮转数组/main.go

@@ -0,0 +1,16 @@
+package main
+
+func main() {
+	rotate([]int{1, 2, 3, 4, 5, 6, 7}, 3)
+}
+
+func rotate(nums []int, k int) {
+	temp := make([]int, len(nums))
+	for i := 0; i < len(nums); i++ {
+		target := (i + k) % len(nums)
+		temp[target] = nums[i]
+	}
+	for i := 0; i < len(nums); i++ {
+		nums[i] = temp[i]
+	}
+}

滑动窗口/找到字符串中所有字母异位词/main.go

@@ -0,0 +1,95 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	fmt.Println(findAnagrams("cbaebabacd", "abc"))
+
+}
+
+func findAnagrams(s string, p string) []int {
+	length := len(p)
+	if length > len(s) {
+		return []int{}
+	}
+	nums := [26]int{}
+	nownum := [26]int{}
+	result := []int{}
+
+	for _, ch := range p {
+		nums[ch-'a']++
+	}
+
+	for i := 0; i < len(s)-length+1; i++ {
+		if i == 0 {
+			for i := 0; i < length; i++ {
+				nownum[s[i]-'a']++
+			}
+			if nums == nownum {
+				result = append(result, i)
+			}
+			continue
+		}
+
+		nownum[s[i-1]-'a']--
+		nownum[s[i+length-1]-'a']++
+
+		if nums == nownum {
+			result = append(result, i)
+		}
+	}
+
+	return result
+}
+
+//func findAnagrams(s string, p string) []int {
+//	result := make([]int, 0)
+//	if len(s) < len(p) {
+//		return result
+//	}
+//	windowlength := len(p)
+//	hashmap := make(map[string]int)
+//	keynum := 0
+//	for i := range p {
+//		if _, ok := hashmap[string(p[i])]; ok {
+//			hashmap[string(p[i])] += 1
+//		} else {
+//			keynum++
+//			hashmap[string(p[i])] = 1
+//		}
+//	}
+//	//fmt.Println(hashmap)
+//	for slow := 0; slow < len(s); slow++ {
+//		fasttmp := slow
+//		hashtemp := make(map[string]int)
+//		if len(s)-fasttmp < windowlength {
+//			break
+//		}
+//		for fast := slow; fast < windowlength+slow; fast++ {
+//			if _, ok := hashmap[string(s[fast])]; ok {
+//				hashtemp[string(s[fast])] += 1
+//			} else {
+//				break
+//			}
+//			if fast == windowlength+slow-1 {
+//				va := 0
+//				for k, v := range hashtemp {
+//					if hashmap[k] != v {
+//						//fmt.Println("退出")
+//						break
+//					} else {
+//						va++
+//					}
+//				}
+//				//fmt.Println("当前va:", va)
+//				if va == keynum {
+//					result = append(result, slow)
+//				}
+//			}
+//		}
+//		//fmt.Println("hashtemp", hashtemp)
+//	}
+//	fmt.Println(result)
+//	return result
+//}

滑动窗口/无重复字符的最长字串/main.go

@@ -0,0 +1,37 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println(lengthOfLongestSubstring(" "))
+}
+
+func lengthOfLongestSubstring(s string) int {
+	if len(s) == 0 {
+		fmt.Println("直接")
+		return 0
+	}
+	if len(s) == 1 {
+		return 1
+	}
+	left, right := 0, 1
+	window := 1
+	result := 0
+	hash := make(map[rune]struct{}, 0)
+	hash[rune(s[0])] = struct{}{}
+	for right < len(s) {
+		if _, ok := hash[rune(s[right])]; ok {
+			window--
+			delete(hash, rune(s[left]))
+			left++
+
+		} else {
+			hash[rune(s[right])] = struct{}{}
+			right++
+			window++
+			result = max(result, window)
+		}
+
+	}
+	return result
+}