update

medium/139.go

@@ -57,8 +57,8 @@ func wordBreak(s string, wordDict []string) bool { // Faster DP solution
 	return result[length]
 }
 
-func main() {
-	println(wordBreak(
-		"catsanddogsand",
-		[]string{"cats", "and", "sand", "dogs", "dog"}))
-}
+// func main() {
+// 	println(wordBreak(
+// 		"catsanddogsand",
+// 		[]string{"cats", "and", "sand", "dogs", "dog"}))
+// }

medium/142.js

@@ -0,0 +1,61 @@
+'use strict'
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+function ListNode(val) {
+    this.val = val
+    this.next = null
+}
+
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var detectCycle = function (head) {
+    // Assume l1 = dis(head, entry), and l2 = dis(entry, meeting),
+    // c = len(cycle), n = count of loop (fast pointer), then
+    // dis(head, fast) = l1+l2+n*c = 2*dis(head, slow) = 2*(l1+l2).
+    // So l1 = c-l2+(n-1)*c, for a pointer in cycle, it means
+    // l1 = c - l2, ie. dis(head, entry) = dis(meeting, entry).
+    if (!head) return null
+    let slow = head
+    let fast = head
+    let entry = head
+    while (fast.next && fast.next.next) {
+        slow = slow.next
+        fast = fast.next.next
+        if (fast === slow) {
+            while (entry !== slow) {
+                entry = entry.next
+                slow = slow.next
+            }
+            return entry
+        }
+    }
+    return null
+}
+
+function __main__() {
+    /* eslint no-console: ["error", {"allow": ["log"]}] */
+    const logger = console.log.bind(console)
+    const n5 = new ListNode(5)
+    const n4 = new ListNode(4)
+    n4.next = n5
+    const n3 = new ListNode(3)
+    n3.next = n4
+    const n2 = new ListNode(2)
+    n2.next = n3 
+    const n1 = new ListNode(1)
+    n1.next = n2
+    n5.next = n3
+    logger(n3)
+    logger(detectCycle(n1))
+}
+
+__main__()

medium/143.go

@@ -0,0 +1,73 @@
+package main
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func reorderListOld(head *ListNode) {
+	// Given a singly linked list L: L0→L1→…→Ln-1→Ln,
+	// reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
+	if head == nil || head.Next == nil {
+		return
+	}
+	stack := make([]*ListNode, 0)
+	beg := head
+	length := 0
+	for beg != nil {
+		stack = append(stack, beg)
+		beg = beg.Next
+		length++
+	}
+	beg = head
+	for i := 0; i < length/2; i++ {
+		tmp := beg.Next
+		beg.Next = stack[length-i-1]
+		beg.Next.Next = tmp
+		beg = tmp
+	}
+	beg.Next = nil
+}
+
+func reorderList(head *ListNode) {
+	if head == nil || head.Next == nil {
+		return
+	}
+	slow, fast := head, head
+	for fast != nil && fast.Next != nil {
+		// Find the middle of list
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+	// Reverse the 2nd part
+	var prev *ListNode
+	for slow.Next != nil {
+		tmp := slow.Next
+		slow.Next = prev
+		prev = slow
+		slow = tmp
+	}
+	slow.Next = prev
+	// Merge the 1st part and the 2nd part
+	left, right := head, slow
+	for left != nil && right.Next != nil {
+		tmpL, tmpR := left.Next, right.Next
+		left.Next = right
+		right.Next = tmpL
+		left, right = tmpL, tmpR
+	}
+}
+
+// func main() {
+// 	n5 := ListNode{5, nil}
+// 	n4 := ListNode{4, &n5}
+// 	// n4 := ListNode{4, nil}
+// 	n3 := ListNode{3, &n4}
+// 	n2 := ListNode{2, &n3}
+// 	n1 := ListNode{1, &n2}
+// 	printList(&n1)
+// 	reorderList(&n1)
+// 	printList(&n1)
+// }

medium/144.go

@@ -0,0 +1,52 @@
+package main
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func preorderTraversalOld(root *TreeNode) []int {
+	result := make([]int, 0)
+	preorderRecurse(root, &result)
+	return result
+}
+
+func preorderRecurse(node *TreeNode, result *[]int) {
+	if node == nil {
+		return
+	}
+	*result = append(*result, node.Val)
+	preorderRecurse(node.Left, result)
+	preorderRecurse(node.Right, result)
+}
+
+func preorderTraversal(root *TreeNode) []int {
+	result := make([]int, 0)
+	if root == nil {
+		return result
+	}
+	stack := make([]*TreeNode, 0)
+	curr := root
+	for len(stack) != 0 || curr != nil {
+		for curr != nil {
+			result = append(result, curr.Val)
+			stack = append(stack, curr)
+			curr = curr.Left
+		}
+		if size := len(stack); size != 0 {
+			curr = stack[size-1]
+			stack = stack[:size-1]
+			curr = curr.Right
+		}
+	}
+	return result
+}
+
+// func main() {
+// 	t1 := sortedArrayToBST([]int{1, 2, 3, 4, 5, 6, 7})
+// 	printTree(t1)
+// 	fmt.Println(preorderTraversal(t1))
+// }

medium/147.go

@@ -0,0 +1,34 @@
+package main
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func insertionSortList(head *ListNode) *ListNode {
+	if head == nil || head.Next == nil {
+		return head
+	}
+	dummy := &ListNode{}
+	beg := head
+	for beg != nil {
+		prev := dummy
+		for ; prev.Next != nil && beg.Val > prev.Next.Val; prev = prev.Next {
+		}
+		insert := beg
+		beg = beg.Next
+		insert.Next = prev.Next
+		prev.Next = insert
+	}
+	return dummy.Next
+}
+
+// func main() {
+// 	l1 := toLinkedList([]int{
+// 		-1, 5, 3, 4, 0})
+// 	printList(insertionSortList(l1))
+// 	l2 := (*ListNode)(nil)
+// 	printList(insertionSortList(l2))
+// }

medium/148.go

@@ -0,0 +1,43 @@
+package main
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func sortList(head *ListNode) *ListNode {
+	return nil
+}
+
+func mergeSort() {
+
+}
+
+func mergeList(l1, l2 *ListNode) *ListNode {
+	dummy := &ListNode{}
+	prev := dummy
+	for l1 != nil && l2 != nil {
+		if l1.Val < l2.Val {
+			prev.Next = l1
+			l1 = l1.Next
+		} else {
+			prev.Next = l2
+			l2 = l2.Next
+		}
+		prev = prev.Next
+	}
+	if l1 != nil {
+		prev.Next = l1
+	} else {
+		prev.Next = l2
+	}
+	return dummy.Next
+}
+
+func main() {
+	l1 := toLinkedList([]int{
+		3, 52, 6, 8, 4})
+	printList(sortList(l1))
+}