u

top-100-liked/32/32_test.go

@@ -0,0 +1,47 @@
+package top100liked
+
+// https://leetcode.cn/problems/copy-list-with-random-pointer/?envType=study-plan-v2&envId=top-100-liked
+
+type Node struct {
+	Val    int
+	Next   *Node
+	Random *Node
+}
+
+func copyRandomList(head *Node) *Node {
+	if head == nil {
+		return nil
+	}
+
+	m := make(map[*Node]*Node)
+	cur := head
+
+	var first *Node
+
+	// 新旧节点映射
+	for cur != nil {
+		newNode := &Node{
+			Val:    cur.Val,
+			Next:   nil,
+			Random: nil,
+		}
+		if first == nil {
+			first = newNode
+		}
+		m[cur] = newNode
+		cur = cur.Next
+	}
+
+	cur = head
+	for cur != nil {
+		if cur.Next != nil {
+			m[cur].Next = m[cur.Next]
+		}
+		if cur.Random != nil {
+			m[cur].Random = m[cur.Random]
+		}
+		cur = cur.Next
+	}
+
+	return first
+}

top-100-liked/33/33_test.go

@@ -0,0 +1,155 @@
+package top100liked
+
+import (
+	"fmt"
+	"testing"
+)
+
+// https://leetcode.cn/problems/reverse-nodes-in-k-group/description/?envType=study-plan-v2&envId=top-100-liked
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+// 模拟冒泡，超时了
+// func sortList(head *ListNode) *ListNode {
+// 	if head == nil {
+// 		return nil
+// 	}
+// 	if head.Next == nil {
+// 		return head
+// 	}
+// 	dummy := &ListNode{Next: head}
+// 	count := 0
+// 	l := 0
+// 	var p1, p2, p3 *ListNode
+// 	for i := 0; l == 0 || l != i; i++ {
+// 		p1, p2, p3 = dummy, dummy.Next, dummy.Next.Next
+// 		for p3 != nil {
+// 			if p2.Val > p3.Val {
+// 				p1.Next = p3
+// 				p2.Next = p3.Next
+// 				p3.Next = p2
+// 				p2, p3 = p3, p2
+// 			}
+// 			if l == 0 {
+// 				// 首次遍历
+// 				count++
+// 			} else if count >= l-i {
+// 				break
+// 			}
+// 			p1 = p1.Next
+// 			p2 = p2.Next
+// 			p3 = p3.Next
+// 		}
+// 		if l == 0 {
+// 			l = count
+// 		}
+// 		count = 0
+// 	}
+// 	return dummy.Next
+// }
+
+// 归并排序
+func f(head, tail *ListNode) *ListNode {
+	if head == nil || tail == nil || head == tail {
+		return head
+	}
+	if head.Next == tail {
+		if head.Val > tail.Val {
+			tail.Next = head
+			head.Next = nil
+			return tail
+		} else {
+			return head
+		}
+	}
+	// 找中点
+	slow, fast := head, head
+	for fast != nil && fast.Next != nil {
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+
+	// slow 是中点
+	postSlow := slow.Next
+	slow.Next = nil
+	tail.Next = nil
+	left := f(head, slow)
+	right := f(postSlow, tail)
+	newHead := &ListNode{}
+	p1, p2, p3 := left, right, newHead
+	for p1 != nil || p2 != nil {
+		if p1 == nil || (p2 != nil && p1.Val > p2.Val) {
+			p3.Next = p2
+			p3 = p3.Next
+			p2 = p2.Next
+		} else if p2 == nil || p1.Val <= p2.Val {
+			p3.Next = p1
+			p3 = p3.Next
+			p1 = p1.Next
+		}
+	}
+	return newHead.Next
+}
+
+func sortList(head *ListNode) *ListNode {
+	if head == nil {
+		return nil
+	}
+	if head.Next == nil {
+		return head
+	}
+	cur := head
+	for cur.Next != nil {
+		cur = cur.Next
+	}
+	return f(head, cur)
+}
+
+func Test1(t *testing.T) {
+	input := &ListNode{
+		Val: 4,
+		Next: &ListNode{
+			Val: 2,
+			Next: &ListNode{
+				Val: 1,
+				Next: &ListNode{
+					Val:  3,
+					Next: nil,
+				},
+			},
+		},
+	}
+	output := sortList(input)
+	for output != nil {
+		fmt.Print(output.Val, " ")
+		output = output.Next
+	}
+}
+
+func Test2(t *testing.T) {
+	input := &ListNode{
+		Val: -1,
+		Next: &ListNode{
+			Val: 5,
+			Next: &ListNode{
+				Val: 3,
+				Next: &ListNode{
+					Val: 4,
+					Next: &ListNode{
+						Val:  0,
+						Next: nil,
+					},
+				},
+			},
+		},
+	}
+	output := sortList(input)
+	for output != nil {
+		fmt.Print(output.Val, " ")
+		output = output.Next
+	}
+	fmt.Println()
+}

top-100-liked/34/leetcode_test.go

@@ -0,0 +1,146 @@
+package top100liked
+
+import (
+	"fmt"
+	"testing"
+)
+
+// https://leetcode.cn/problems/reverse-nodes-in-k-group/description/?envType=study-plan-v2&envId=top-100-liked
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+// 暴力解，非常慢，但是能通过
+// func mergeKLists(lists []*ListNode) *ListNode {
+// 	if lists == nil {
+// 		return nil
+// 	}
+// 	dummy := &ListNode{}
+// 	p := dummy
+// 	var minValue int
+// 	minIndex := -1
+// 	for {
+// 		for i := range lists {
+// 			if lists[i] != nil {
+// 				if minIndex == -1 {
+// 					minValue = lists[i].Val
+// 					minIndex = i
+// 				}
+// 				if lists[i].Val < minValue {
+// 					minValue = lists[i].Val
+// 					minIndex = i
+// 				}
+// 			}
+// 		}
+// 		if minIndex == -1 {
+// 			return nil
+// 		}
+// 		p.Next = lists[minIndex]
+// 		p = p.Next
+// 		lists[minIndex] = lists[minIndex].Next
+// 		minIndex = -1
+// 		allNil := true
+// 		for i := range lists {
+// 			if lists[i] != nil {
+// 				allNil = false
+// 				break
+// 			}
+// 		}
+// 		if allNil {
+// 			break
+// 		}
+// 	}
+// 	return dummy.Next
+// }
+
+func mergeTwoLists(list1 *ListNode, list2 *ListNode) *ListNode {
+	p1, p2 := list1, list2
+	p := &ListNode{}
+	res := p
+	for p1 != nil && p2 != nil {
+		if p1.Val <= p2.Val {
+			p.Next = p1
+			p = p.Next
+			p1 = p1.Next
+		} else {
+			p.Next = p2
+			p = p.Next
+			p2 = p2.Next
+		}
+	}
+	for p1 != nil {
+		p.Next = p1
+		p = p.Next
+		p1 = p1.Next
+	}
+	for p2 != nil {
+		p.Next = p2
+		p = p.Next
+		p2 = p2.Next
+	}
+	return res.Next
+}
+
+// 分治归并
+func mergeKLists(lists []*ListNode) *ListNode {
+	if len(lists) == 0 || lists == nil {
+		return nil
+	}
+	if len(lists) == 1 {
+		return lists[0]
+	}
+	l := []*ListNode{}
+	for i := range len(lists) / 2 {
+		l = append(l, mergeTwoLists(lists[2*i], lists[2*i+1]))
+	}
+	if len(lists)%2 != 0 {
+		l = append(l, lists[len(lists)-1])
+	}
+	return mergeKLists(l)
+}
+
+func Test1(t *testing.T) {
+	input := []*ListNode{
+		{
+			Val: 1,
+			Next: &ListNode{
+				Val: 4,
+				Next: &ListNode{
+					Val:  5,
+					Next: nil,
+				},
+			},
+		},
+		{
+			Val: 1,
+			Next: &ListNode{
+				Val: 3,
+				Next: &ListNode{
+					Val:  4,
+					Next: nil,
+				},
+			},
+		},
+		{
+			Val: 2,
+			Next: &ListNode{
+				Val:  6,
+				Next: nil,
+			},
+		},
+	}
+	output := mergeKLists(input)
+	for output != nil {
+		fmt.Print(output.Val, " ")
+		output = output.Next
+	}
+}
+
+func Test2(t *testing.T) {
+	mergeKLists(nil)
+}
+func Test3(t *testing.T) {
+	mergeKLists([]*ListNode{nil})
+}