148. 排序链表

go.mod

@@ -0,0 +1,3 @@
+module lichx.top/go-test
+
+go 1.25.0

list.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}
+
+func makeLink(arr []int) *ListNode {
+	if len(arr) == 0 {
+		return nil
+	}
+	head := &ListNode{}
+	cur := head
+	for _, v := range arr {
+		cur.Next = &ListNode{Val: v}
+		cur = cur.Next
+	}
+	return head.Next
+}
+func checkLink(head *ListNode) {
+	for head != nil {
+		fmt.Println(head.Val)
+		head = head.Next
+	}
+}

main.go

@@ -1,55 +1,62 @@
 package main
 
-import "fmt"
+func conquerAndSort(head *ListNode, end *ListNode) *ListNode {
-
+	if head == nil || head == end || head.Next == nil {
-// ListNode Definition for singly-linked list.
+		return head
-type ListNode struct {
-	Val  int
-	Next *ListNode
 	}
-
+	if head.Next == end {
-func isPalindrome(head *ListNode) bool {
+		if end != nil {
-	srcHead := head
+			if head.Val > end.Val {
-	head = head.Next
+				head.Val, end.Val = end.Val, head.Val
-	// var left, right *ListNode
-	cnt := 1
-	for head != nil {
-		head = head.Next
-		cnt++
 			}
-	head = srcHead.Next
-	lastNode := srcHead
-	srcHead.Next = nil
-	half := cnt / 2
-	half--
-	for range half {
-		p := head.Next
-		head.Next = lastNode
-		lastNode = head
-		head = p
 		}
-	if cnt&1 == 1 {
+		return head
-		head = head.Next
 	}
-	for head != nil && lastNode != nil {
+	if head.Next.Next == end {
-		if head.Val != lastNode.Val {
+		if head.Val > head.Next.Val {
-			return false
+			head.Next.Val, head.Val = head.Val, head.Next.Val
 		}
-		head = head.Next
+		return head
-		lastNode = lastNode.Next
 	}
-	if head != nil || lastNode != nil {
+	slow, fast := head, head
-		return false
+	for fast.Next != nil && fast.Next.Next != nil {
+		slow = slow.Next
+		fast = fast.Next.Next
 	}
-	return true
+	lastSlow := slow
+	slow = slow.Next
+	lastSlow.Next = nil
+	a := conquerAndSort(head, nil)
+	b := conquerAndSort(slow, end)
+	if a.Val > b.Val {
+		a, b = b, a
+	}
+	// a Val < b Val
+	head = a
+	cur := a
+	a = a.Next
+	for a != nil && b != nil {
+		if a.Val > b.Val {
+			cur.Next = b
+			b = b.Next
+		} else {
+			cur.Next = a
+			a = a.Next
+		}
+		cur = cur.Next
+	}
+	if a == nil {
+		cur.Next = b
+	} else {
+		cur.Next = a
+	}
+	return head
+}
+func sortList(head *ListNode) *ListNode {
+	return conquerAndSort(head, nil)
 }
 
 func main() {
-	isPalindrome := isPalindrome(&ListNode{
+	arr := []int{-1, 5, 3, 4, 0}
-		Val: 1,
+	checkLink(sortList(makeLink(arr)))
-		Next: &ListNode{
-			Val: 2,
-		},
-	})
-	fmt.Printf("isPalindrome: %v\n", isPalindrome)
 }