Update solution 707、918

Author: halfrost

leetcode/0707.Design-Linked-List/707. Design Linked List.go

@@ -1,82 +1,97 @@
 package leetcode
 
 type MyLinkedList struct {
+	head *Node
+}
+
+type Node struct {
 	Val  int
-	Next *MyLinkedList
+	Next *Node
+	Prev *Node
 }
 
 /** Initialize your data structure here. */
 func Constructor() MyLinkedList {
-	return MyLinkedList{Val: -999, Next: nil}
+	return MyLinkedList{}
 }
 
 /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
 func (this *MyLinkedList) Get(index int) int {
-	cur := this
-	for i := 0; cur != nil; i++ {
-		if i == index {
-			if cur.Val == -999 {
-				return -1
-			} else {
-				return cur.Val
-			}
-		}
-		cur = cur.Next
+	curr := this.head
+	for i := 0; i < index && curr != nil; i++ {
+		curr = curr.Next
+	}
+	if curr != nil {
+		return curr.Val
+	} else {
+		return -1
 	}
-	return -1
 }
 
 /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
 func (this *MyLinkedList) AddAtHead(val int) {
-	if this.Val == -999 {
-		this.Val = val
-	} else {
-		tmp := &MyLinkedList{Val: this.Val, Next: this.Next}
-		this.Val = val
-		this.Next = tmp
+	node := &Node{Val: val}
+	node.Next = this.head
+	if this.head != nil {
+		this.head.Prev = node
 	}
+	this.head = node
 }
 
 /** Append a node of value val to the last element of the linked list. */
 func (this *MyLinkedList) AddAtTail(val int) {
-	cur := this
-	for cur.Next != nil {
-		cur = cur.Next
+	if this.head == nil {
+		this.AddAtHead(val)
+		return
 	}
-	tmp := &MyLinkedList{Val: val, Next: nil}
-	cur.Next = tmp
+	node := &Node{Val: val}
+	curr := this.head
+	for curr != nil && curr.Next != nil {
+		curr = curr.Next
+	}
+	node.Prev = curr
+	curr.Next = node
 }
 
 /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
 func (this *MyLinkedList) AddAtIndex(index int, val int) {
-	cur := this
 	if index == 0 {
 		this.AddAtHead(val)
-		return
-	}
-	for i := 0; cur != nil; i++ {
-		if i == index-1 {
-			break
+	} else {
+		node := &Node{Val: val}
+		curr := this.head
+		for i := 0; i < index-1 && curr != nil; i++ {
+			curr = curr.Next
+		}
+		if curr != nil {
+			node.Next = curr.Next
+			node.Prev = curr
+			if node.Next != nil {
+				node.Next.Prev = node
+			}
+			curr.Next = node
 		}
-		cur = cur.Next
-	}
-	if cur != nil && cur.Val != -999 {
-		tmp := &MyLinkedList{Val: val, Next: cur.Next}
-		cur.Next = tmp
 	}
 }
 
 /** Delete the index-th node in the linked list, if the index is valid. */
 func (this *MyLinkedList) DeleteAtIndex(index int) {
-	cur := this
-	for i := 0; cur != nil; i++ {
-		if i == index-1 {
-			break
+	if index == 0 {
+		this.head = this.head.Next
+		if this.head != nil {
+			this.head.Prev = nil
+		}
+	} else {
+		curr := this.head
+		for i := 0; i < index-1 && curr != nil; i++ {
+			curr = curr.Next
+		}
+		if curr != nil && curr.Next != nil {
+			curr.Next = curr.Next.Next
+			if curr.Next != nil {
+				curr.Next.Prev = curr
+			}
 		}
-		cur = cur.Next
-	}
-	if cur != nil && cur.Next != nil {
-		cur.Next = cur.Next.Next
 	}
 }
 

leetcode/0707.Design-Linked-List/707. Design Linked List_test.go

@@ -54,11 +54,10 @@ func Test_Problem707(t *testing.T) {
 
 func MList2Ints(head *MyLinkedList) []int {
 	res := []int{}
-
-	for head != nil {
-		res = append(res, head.Val)
-		head = head.Next
+	cur := head.head
+	for cur != nil {
+		res = append(res, cur.Val)
+		cur = cur.Next
 	}
-
 	return res
 }

leetcode/0918.Maximum-Sum-Circular-Subarray/918. Maximum Sum Circular Subarray.go

@@ -2,34 +2,50 @@ package leetcode
 
 import "math"
 
-func maxSubarraySumCircular(A []int) int {
-	n, sum := len(A), 0
-	for _, v := range A {
-		sum += v
-	}
-	kad := kadane(A)
-	for i := 0; i < n; i++ {
-		A[i] = -A[i]
+func maxSubarraySumCircular(nums []int) int {
+	var max1, max2, sum int
+
+	// case: no circulation
+	max1 = int(math.Inf(-1))
+	l := len(nums)
+	for i := 0; i < l; i++ {
+		sum += nums[i]
+		if sum > max1 {
+			max1 = sum
+		}
+		if sum < 1 {
+			sum = 0
+		}
 	}
-	negativeMax := kadane(A)
-	if sum+negativeMax <= 0 {
-		return kad
+
+	// case: circling
+	arr_sum := 0
+	for i := 0; i < l; i++ {
+		arr_sum += nums[i]
 	}
-	return max(kad, sum+negativeMax)
-}
 
-func kadane(a []int) int {
-	n, MaxEndingHere, maxSoFar := len(a), a[0], math.MinInt32
-	for i := 1; i < n; i++ {
-		MaxEndingHere = max(a[i], MaxEndingHere+a[i])
-		maxSoFar = max(MaxEndingHere, maxSoFar)
+	sum = 0
+	min_sum := 0
+	for i := 1; i < l-1; i++ {
+		sum += nums[i]
+		if sum >= 0 {
+			sum = 0
+		}
+		if sum < min_sum {
+			min_sum = sum
+		}
 	}
-	return maxSoFar
+	max2 = arr_sum - min_sum
+
+	return max(max1, max2)
 }
 
-func max(a int, b int) int {
-	if a > b {
-		return a
+func max(nums ...int) int {
+	max := int(math.Inf(-1))
+	for _, num := range nums {
+		if num > max {
+			max = num
+		}
 	}
-	return b
+	return max
 }

website/content/ChapterFour/0500~0599/0538.Convert-BST-to-Greater-Tree.md

@@ -109,5 +109,5 @@ func dfs538(root *TreeNode, sum *int) {
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0537.Complex-Number-Multiplication/">⬅️上一页</a></p>
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0541.Reverse-String-II/">下一页➡️</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0540.Single-Element-in-a-Sorted-Array/">下一页➡️</a></p>
 </div>

website/content/ChapterFour/0500~0599/0540.Single-Element-in-a-Sorted-Array.md

@@ -0,0 +1,71 @@
+# [540. Single Element in a Sorted Array](https://leetcode.com/problems/single-element-in-a-sorted-array/)
+
+## 题目
+
+You are given a sorted array consisting of only integers where every element appears exactly twice, except for one element which appears exactly once.
+
+Return the single element that appears only once.
+
+Your solution must run in O(log n) time and O(1) space.
+
+**Example 1:**
+
+    Input: nums = [1,1,2,3,3,4,4,8,8]
+    Output: 2
+
+**Example 2:**
+
+    Input: nums = [3,3,7,7,10,11,11]
+    Output: 10
+
+**Constraints:**
+
+- 1 <= nums.length <= 100000
+- 0 <= nums[i] <= 100000
+
+## 题目大意
+
+给你一个仅由整数组成的有序数组，其中每个元素都会出现两次，唯有一个数只会出现一次。
+
+请你找出并返回只出现一次的那个数。
+
+你设计的解决方案必须满足 O(log n) 时间复杂度和 O(1) 空间复杂度。
+
+## 解题思路
+
+    假设下标idx是单独的数字,idx左边的偶数下标x有nums[x] == nums[x + 1],
+    idx右边的奇数下标y有nums[y] == nums[y + 1],可以根据此特性用二分查找idx对应的值 
+
+## 代码
+
+```go
+package leetcode
+
+func singleNonDuplicate(nums []int) int {
+	left, right := 0, len(nums)-1
+	for left < right {
+		mid := (left + right) / 2
+		if mid%2 == 0 {
+			if nums[mid] == nums[mid+1] {
+				left = mid + 1
+			} else {
+				right = mid
+			}
+		} else {
+			if nums[mid] == nums[mid-1] {
+				left = mid + 1
+			} else {
+				right = mid
+			}
+		}
+	}
+	return nums[left]
+}
+```
+
+
+----------------------------------------------
+<div style="display: flex;justify-content: space-between;align-items: center;">
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0538.Convert-BST-to-Greater-Tree/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0541.Reverse-String-II/">下一页➡️</a></p>
+</div>

website/content/ChapterFour/0500~0599/0541.Reverse-String-II.md

@@ -70,6 +70,6 @@ func revers(s string) string {
 
 ----------------------------------------------
 <div style="display: flex;justify-content: space-between;align-items: center;">
-<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0538.Convert-BST-to-Greater-Tree/">⬅️上一页</a></p>
+<p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0540.Single-Element-in-a-Sorted-Array/">⬅️上一页</a></p>
 <p><a href="https://books.halfrost.com/leetcode/ChapterFour/0500~0599/0542.01-Matrix/">下一页➡️</a></p>
 </div>