first commit

Author: skrbug

11_container_with_most_water/leetcode11.go

@@ -0,0 +1,71 @@
+package leetcode11
+
+// https://leetcode-cn.com/problems/container-with-most-water/
+
+// area distance * minHeight 
+// best method
+func maxArea(height []int) int {
+
+	if len(height) < 2 {
+		return 0
+	}
+
+	result,left,right := 0,0,len(height) - 1
+	result = (right -  left) * min(height[left],height[right]) 
+	for left < right {
+		if height[left] < height[right]{
+			left ++
+		}else {
+			right --
+
+		}
+		thisResult := (right -  left) * min(height[left],height[right]) 
+		result = max(result,thisResult)
+	}
+	return result
+}
+
+func min(x,y int) int{
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func max(x,y int) int{
+	if x > y {
+		return x
+	}
+	return y
+}
+
+
+
+
+// force 
+func maxAreaForce(height []int) int {
+	n := len(height)
+	if n < 2 {
+		return 0
+	}
+
+	result := 0
+	for i := 0; i < n ; i ++ {
+		for j := 0; j <n;j ++ {
+			if height[j] < height[i] || j == i {
+				continue
+			}
+			dV := distance(j , i)
+			result = max(result,dV * height[i])
+		}
+	}
+	return result
+}
+
+func distance(x,y int)int {
+    if x < y {
+        return y - x
+    }else{
+        return x - y
+    }
+}

11_container_with_most_water/leetcode11_test.go

@@ -0,0 +1,33 @@
+package leetcode11
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMaxArea(t *testing.T){
+	tests := []struct{
+		name string
+		arg []int
+		want int
+	}{
+		{
+			"Double Pointer",
+			[]int{1,8,6,2,5,4,8,3,7},
+			49,
+		},
+		{
+			"Force soulution",
+			[]int{1,8,6,2,5,4,8,3,7},
+			49,
+		},
+	}
+	
+	for _,tt:=range tests{
+		t.Run(tt.name,func(t *testing.T){
+			assert.Equal(t,tt.want,maxArea(tt.arg))
+		})
+	}
+
+}

141_linked-list-cycle/leetcode141.go

@@ -0,0 +1,28 @@
+package main 
+
+type ListNode struct{
+	Val int 
+	Next *ListNode
+}
+
+// 快慢指针法，让其两个指针速度不一样，如果有环一定会相撞
+func hasCycle(head *ListNode) bool {
+	fast,slow := head,head
+	if head == nil{
+		return false
+	}
+	for {
+		if fast.Next ==nil || fast.Next.Next == nil {
+			return false
+		}
+		
+		fast = fast.Next.Next
+		slow = slow.Next
+
+		if fast == slow {
+			return true
+		}
+
+	}
+
+}

142_linked-list-cycle/leetcode141.go

@@ -0,0 +1,55 @@
+package main 
+
+type ListNode struct{
+	Val int 
+	Next *ListNode
+}
+/*
+
+
+
+	判断环原理: 
+
+	定义 
+		x1 令牌环head到环的第一个节点的步数，即我们要求的那个节点
+		x2 从环的第一个点到相遇的那个点，需要x2步
+		x3 从环中相遇点回到环的第一个点需要x3步 
+
+	
+	fast、slow会相遇，说明走的时间是一定的
+	路程有如下关系
+	fast : t = (x1 + x2 + x3 + x2) / 2
+	slow:  t = (x1 + x2) / 1
+
+	得到 x1 = x3 
+	
+	相遇后，我们让快指针指向头节点，然后步频为1的走，下次相遇即是x1的位置  
+
+
+*/
+
+
+func detectCycle(head *ListNode) *ListNode {
+    fast,slow := head,head
+	if head == nil{
+		return nil
+	}
+	for {
+		if fast.Next ==nil || fast.Next.Next == nil {
+			return nil
+		}
+		
+		fast = fast.Next.Next
+		slow = slow.Next
+        if fast == slow {
+            break
+        }
+	}
+    fast = head 
+    for fast != slow {
+        fast = fast.Next 
+        slow = slow.Next
+    }
+    return fast
+
+}

15_3sum/leetcode15.go

@@ -0,0 +1,81 @@
+package leetcode15
+
+import "sort"
+
+// https://leetcode-cn.com/problems/3sum/
+
+// a + b + c = 0
+// 去重问题难解决，如果用java，可以用Set容器装，go语言需要自己处理去重
+// func threeSum(nums []int) [][]int {
+// 	sort.Slice(nums,func(i, j int) bool {
+// 		if nums[i] <= nums[j] {
+// 			return true
+// 		}
+// 		return false
+// 	})
+// 	result := make([][]int,0)
+
+// 	for i:=0 ; i < len(nums) - 2 ;  i ++ {
+// 		a := nums[i]
+
+// 		for j,k := i + 1, len(nums) - 1; j < k;{
+// 			b := nums[j]
+// 			c := nums[k]
+// 			if a + b + c == 0 {
+// 				combol := []int{a,b,c}
+// 				result = append(result, combol)
+// 				break
+// 			}else if a + b + c < 0 {
+// 				j ++
+// 			}else {
+// 				k --
+// 			}
+
+// 		}
+// 	}
+// 	return result
+// }
+
+func threeSum(nums []int)[][]int{
+	res := [][]int{}
+
+	counter := map[int]int{}
+
+	for _,value := range nums {
+		counter[value] ++
+	}
+	uniques := []int{}
+	for key := range  counter {
+		uniques = append(uniques,key)
+	}
+
+	sort.Ints(uniques)
+
+	for i := 0; i < len(uniques); i++ {
+		if uniques[i] * 3 == 0 && counter[uniques[i]] >= 3 {
+			res = append(res, []int{uniques[i],uniques[i],uniques[i]})
+		}
+
+		for j := i + 1; j < len(uniques); j++ {
+			if uniques[i] * 2 + uniques[j] == 0 && counter[uniques[i]] > 1 {
+				res = append(res, []int{uniques[i],uniques[i],uniques[j]})
+			}
+
+			if uniques[j] * 2 + uniques[i] == 0 && counter[uniques[j]] > 1 {
+				res = append(res, []int{uniques[i],uniques[j],uniques[j]})
+			}
+			
+			c := 0 - uniques[i] - uniques[j]
+			if c > uniques[j] && counter[c] > 0 {
+				res = append(res, []int{uniques[i],uniques[j],c})
+			}
+
+		}
+	
+	}
+
+	return res
+}
+
+
+

15_3sum/leetcode15_test.go

@@ -0,0 +1,30 @@
+package leetcode15
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test3Sum(t *testing.T) {
+	tests := []struct {
+		name string
+		arg  []int
+		want [][]int
+	}{
+		{	"3sum",
+			[]int{-1, 0, 1, 2, -1, -4},
+			[][]int{
+				[]int{-1, 0, 1},
+				[]int{-1, -1, 2},
+			},
+		},
+	}
+
+	for _,tt := range tests {
+		t.Run(tt.name,func(t *testing.T) {
+			assert.Equal(t,tt.want,threeSum(tt.arg))
+		})
+	}
+
+}

189_rotate_array/leetcode.go

@@ -0,0 +1,35 @@
+package leetcode 
+
+
+
+// 旋转数组 
+func rotate(nums []int,k int){
+	for i := 0; i < k; i++ {
+		last := nums[len(nums) - 1]
+		for j := len(nums) - 1; j- 1 >= 0; j-- {
+			nums[j] = nums[j-1]
+		}
+		nums[0] = last
+	}
+}
+
+
+// 最优解，每个元素只移动了一次，每个元素都是一步到位
+func rotate2(nums []int,k int){
+	k = k % len(nums)
+	for start,count := 0,0; count < len(nums);start ++ {
+		current := start 
+		pre := nums[start]
+		for  {
+			next := (current + k) % len(nums)
+			tmp := nums[next]
+			nums[next] = pre
+			pre = tmp 
+			current = next 
+			count ++
+			if start == current {   // java 当中的do-while语句，在这里只能 for 死循环加上最后判断，才能实现至少执行一次的效果
+				break
+			}
+		}
+	}
+}