Leetcode

Author: kimi0230

Leetcode/0088.Merge-Sorted-Array/README.md

@@ -31,4 +31,38 @@ nums2.length == n
 
 ## 來源
 * https://books.halfrost.com/leetcode/ChapterFour/0001~0099/0088.Merge-Sorted-Array/
-* https://leetcode-cn.com/problems/merge-sorted-array/
+* https://leetcode-cn.com/problems/merge-sorted-array/
+
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/0088.Merge-Sorted-Array/Merge-Sorted-Array.go
+
+```go
+package mergesortedarray
+
+func Merge(nums1 []int, m int, nums2 []int, n int) {
+	if m == 0 {
+		copy(nums1, nums2)
+		return
+	}
+
+	num1Idx, num2Idx, tail := m-1, n-1, m+n-1
+	// 從每一個array的後面開始比較, 並放入最後面的位子. 這樣只要跑一次
+	for ; num1Idx >= 0 && num2Idx >= 0; tail-- {
+		if nums1[num1Idx] > nums2[num2Idx] {
+			nums1[tail] = nums1[num1Idx]
+			num1Idx--
+		} else {
+			nums1[tail] = nums2[num2Idx]
+			num2Idx--
+		}
+	}
+
+	// 將尚未跑完的補齊
+	for ; num2Idx > 0; tail-- {
+		nums1[tail] = nums2[num2Idx]
+		num2Idx--
+	}
+}
+
+```

Leetcode/0094.Binary-Tree-Inorder-Traversal/README.md

@@ -30,4 +30,56 @@ Follow up: Recursive solution is trivial, could you do it iteratively?
 
 ## 來源
 * https://books.halfrost.com/leetcode/ChapterFour/0001~0099/0094.Binary-Tree-Inorder-Traversal/
-* https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
+* https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
+
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/0094.Binary-Tree-Inorder-Traversal/Binary-Tree-Inorder-Traversal.go
+
+```go
+package binarytreeinordertraversal
+
+import (
+	"LeetcodeGolang/Utility/structures"
+)
+
+type TreeNode = structures.TreeNode
+
+func InorderTraversalStack(root *TreeNode) []int {
+	var result []int
+	inorderStack(root, &result)
+	return result
+}
+
+func InorderTraversalRecursion(root *TreeNode) []int {
+	var result []int
+	inorderRecursion(root, &result)
+	return result
+}
+
+func inorderRecursion(root *TreeNode, r *[]int) {
+	if root != nil {
+		inorderRecursion(root.Left, r)
+		*r = append(*r, root.Val)
+		inorderRecursion(root.Right, r)
+	}
+}
+
+func inorderStack(root *TreeNode, r *[]int) {
+	s := structures.NewArrayStack()
+	p := root
+
+	for !s.IsEmpty() || p != nil {
+		if p != nil {
+			// 把中間放入stack, 往左節點繼續往下找
+			s.Push(p)
+			p = p.Left
+		} else {
+			// 找不到時,印出
+			tmp := s.Pop().(*TreeNode)
+			*r = append(*r, tmp.Val)
+			p = tmp.Right
+		}
+	}
+}
+```

Leetcode/0141.Linked-List-Cycle/README.md

@@ -17,4 +17,29 @@ Can you solve it without using extra space?
 
 ## 來源
 * https://books.halfrost.com/leetcode/ChapterFour/0100~0199/0141.Linked-List-Cycle/
-* https://leetcode-cn.com/problems/linked-list-cycle/
+* https://leetcode-cn.com/problems/linked-list-cycle/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/0141.Linked-List-Cycle/Linked-List-Cycle.go
+
+```go
+package linkedlistcycle
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func HasCycle(head *ListNode) bool {
+	fast := head
+	slow := head
+	for slow != nil && fast != nil && fast.Next != nil {
+		fast = fast.Next.Next
+		slow = slow.Next
+		if slow == fast {
+			return true
+		}
+	}
+	return false
+}
+```

Leetcode/0203.Remove-Linked-List-Elements/README.md

@@ -23,4 +23,84 @@ Output: 1->2->3->4->5
 ## 來源
 * https://books.halfrost.com/leetcode/ChapterFour/0200~0299/0203.Remove-Linked-List-Elements/
 * https://leetcode-cn.com/problems/remove-linked-list-elements/
-* https://mp.weixin.qq.com/s/slM1CH5Ew9XzK93YOQYSjA
+* https://mp.weixin.qq.com/s/slM1CH5Ew9XzK93YOQYSjA
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/0203.Remove-Linked-List-Elements/Remove-Linked-List-Elements.go
+
+```go
+package removelinkedlistelements
+
+import (
+	"LeetcodeGolang/structures"
+)
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+
+type ListNode = structures.ListNode
+
+// 方法一: 另外考慮刪除head節點
+func RemoveElements(head *ListNode, val int) *ListNode {
+	// 刪除值相同的head
+	for head != nil && head.Val == val {
+		head = head.Next
+	}
+	if head == nil {
+		return head
+	}
+	tmpHead := head
+	for tmpHead.Next != nil {
+		if tmpHead.Next.Val == val {
+			tmpHead.Next = tmpHead.Next.Next
+		} else {
+			tmpHead = tmpHead.Next
+		}
+	}
+	return head
+}
+
+/*
+方法二 添加虛擬節點, 效能較好
+可以設置一個虛擬頭結點」，這樣原鍊錶的所有節點就都可以按照統一的方式進行移除了
+return newHead.Next
+*/
+func RemoveElementsVirtualNode(head *ListNode, val int) *ListNode {
+	if head == nil {
+		return head
+	}
+	// 建立一個虛擬 Head 節點
+	newHead := &ListNode{Val: 0, Next: head}
+	preHead := newHead
+	curHead := head
+	for curHead != nil {
+		if curHead.Val == val {
+			preHead.Next = curHead.Next
+		} else {
+			preHead = curHead
+		}
+		curHead = curHead.Next
+	}
+	return newHead.Next
+}
+
+/*
+方法二 遞迴
+*/
+func RemoveElementsRecurse(head *ListNode, val int) *ListNode {
+	if head == nil {
+		return head
+	}
+	head.Next = RemoveElementsRecurse(head.Next, val)
+	if head.Val == val {
+		return head.Next
+	} else {
+		return head
+	}
+}
+```

Leetcode/0209.Minimum-Size-Subarray-Sum/README.md

@@ -41,4 +41,129 @@ If you have figured out the O(n) solution, try coding another solution of which
 ## 來源
 * https://books.halfrost.com/leetcode/ChapterFour/0200~0299/0209.Minimum-Size-Subarray-Sum/
 * https://leetcode-cn.com/problems/minimum-size-subarray-sum/
-* https://mp.weixin.qq.com/s/UrZynlqi4QpyLlLhBPglyg
+* https://mp.weixin.qq.com/s/UrZynlqi4QpyLlLhBPglyg
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/0209.Minimum-Size-Subarray-Sum/Minimum-Size-Subarray-Sum.go
+
+```go
+package minimumsizesubarraysum
+
+import (
+	"math"
+	"sort"
+)
+
+// MinSubArrayLenBurst : 暴力解 時間複雜 O(n^2), 空間複雜 O(1)
+func MinSubArrayLenBurst(target int, nums []int) int {
+	lens := len(nums)
+	if lens <= 0 {
+		return 0
+	}
+
+	minSize := math.MaxInt32
+	for i := 0; i < lens; i++ {
+		sum := 0
+		for j := i; j < lens; j++ {
+			sum += nums[j]
+			if sum >= target {
+				minSize = min(minSize, j-i+1)
+			}
+		}
+	}
+	if minSize == math.MaxInt32 {
+		minSize = 0
+	}
+	return minSize
+}
+
+// MinSubArrayLenSlidingWindow : 滑動視窗 時間複雜 O(n), 空間複雜 O(1)
+// 滑動窗口的精妙之處在於根據當前子序列和大小的情況，不斷調節子序列的起始位置。從而將O(n^2)的暴力解法降為O(n)
+func MinSubArrayLenSlidingWindow(target int, nums []int) int {
+	lens := len(nums)
+	if lens <= 0 {
+		return 0
+	}
+	minSize := math.MaxInt32
+
+	start, end, sum := 0, 0, 0
+	for end < lens {
+		sum += nums[end]
+		for sum >= target {
+			minSize = min(minSize, end-start+1)
+			sum -= nums[start]
+			start++
+		}
+		end++
+
+	}
+
+	if minSize == math.MaxInt32 {
+		minSize = 0
+	}
+	return minSize
+}
+
+/*
+MinSubArrayLenBinarysearch : 前缀和 + 二分查找  O(nlog(n))
+為了使用二分查找，需要額外創建一個數組 sums 用於存儲數組nums 的前綴和，其中 sums[i] 表示從 nums[0] 到 nums[i−1] 的元素和。
+得到前綴和之後，對於每個開始下標i，可通過二分查找得到大於或等於 i 的最小下標 bound，
+使得 sums[bound]-sums[i-1] >= s，
+並更新子數組的最小長度（此時子數組的長度是 bound -(i-1) )。
+C++ 的 lower_bound，Java 的 Arrays.binarySearch
+
+因為這道題保證了數組中每個元素都為正，所以前綴和一定是遞增的，這一點保證了二分的正確性。如果題目沒有說明數組中每個元素都為正，這裡就不能使用二分來查找這個位置了。
+*/
+func MinSubArrayLenBinarysearch(target int, nums []int) int {
+	lens := len(nums)
+	if lens <= 0 {
+		return 0
+	}
+	minSize := math.MaxInt32
+
+	// sums[i] 表示從 nums[0] 到 nums[i−1]
+	sums := make([]int, lens+1)
+	// 為了方便計算 size = lens + 1
+	// sums[0] = 0, 前0個的元素和
+	// sums[1] = nums[0] , 前1個元素和為 nums[0]
+	for i := 1; i <= lens; i++ {
+		sums[i] = sums[i-1] + nums[i-1]
+	}
+	// fmt.Println("sums", sums)
+	for i := 1; i <= lens; i++ {
+		/*
+			target      7
+			input       2  3  1  2  4  3
+			-----------------------------------
+			i           0  1  2  3  4  5  6
+			-----------------------------------
+			sums        0  2  5  6  8 12 15	// input 的前 n 個元素和
+			tmpTarge       7  9 12 13 15 19	// tmpTarge = target + sums[i-1]
+			bound          4  5  5  6  6  7	// bound = sort.SearchInts(sums, tmpTarge)
+			bound-(i-1)    4  4  3  3  2  2
+			minSize        4  4  3  3  2  2
+		*/
+		tmpTarge := target + sums[i-1]
+		bound := sort.SearchInts(sums, tmpTarge)
+		// if bound < 0 {
+		// 	bound = -bound - 1
+		// }
+		if bound <= lens {
+			minSize = min(minSize, bound-(i-1))
+		}
+		// fmt.Println("i:", i, " tmpTarge", tmpTarge, "  bound:", bound, "  bound-(i-1)", bound-(i-1), " minSize:", minSize)
+	}
+
+	if minSize == math.MaxInt32 {
+		minSize = 0
+	}
+	return minSize
+}
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+```

Leetcode/0344.Reverse-String/README.md

@@ -33,3 +33,17 @@ Output: ["h","a","n","n","a","H"]
 ## 來源
 * https://books.halfrost.com/leetcode/ChapterFour/0300~0399/0344.Reverse-String/
 * https://leetcode-cn.com/problems/reverse-string/
+
+## 解答
+https://github.com/kimi0230/LeetcodeGolang/blob/master/Leetcode/0344.Reverse-Stringm/Reverse-String.go
+
+```go
+package reversestring
+
+func ReverseString(s []byte) {
+	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
+		s[i], s[j] = s[j], s[i]
+	}
+}
+
+```