《leetcode-go》常数级空间复杂度对链表进行排序_常数级排序算法对链表-优快云博客

本文链接：https://blog.youkuaiyun.com/less_cold/article/details/107925593

本文介绍了一种在O(nlogn)时间内使用常数级空间复杂度对链表进行排序的方法。通过递归将链表分为两半，然后分别对两半进行排序，最后将两个已排序的链表合并为一个有序链表。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。

Sort a linked list in O(n log n) time using constant space complexity.

注意，一定要先判断前面的是不是nil，再判断后面的，第一个if卡了好长时间

package main

import "fmt"

type ListNode struct {
	Val  int
	Next *ListNode
}

func main() {
	a1 := new(ListNode)
	a1.Val = 3
	a2 := new(ListNode)
	a2.Val = 4
	a3 := new(ListNode)
	a3.Val = 2
	a1.Next = a2
	a2.Next = a3
	ret := sortList(a1)
	for ret != nil {
		fmt.Println(ret.Val)
		ret = ret.Next
	}
}

/**
 *
 * @param head ListNode类
 * @return ListNode类
 */
func sortList(head *ListNode) *ListNode {
	// write code here
	if head == nil || head.Next == nil {
		return head
	}
	var node = head
	var fastNode = head.Next
	for fastNode != nil && fastNode.Next != nil {
		node = node.Next
		fastNode = fastNode.Next.Next
	}
	midNode := node.Next
	rightNode := sortList(midNode)
	node.Next = nil
	leftNode := sortList(head)
	//全部合并到leftNode去
	newHead := &ListNode{}
	newNode := newHead
	for leftNode != nil && rightNode != nil {
		if leftNode.Val < rightNode.Val {
			newNode.Next = leftNode
			newNode = newNode.Next
			leftNode = leftNode.Next
		} else {
			newNode.Next = rightNode
			newNode = newNode.Next
			rightNode = rightNode.Next
		}
	}
	if leftNode != nil {
		newNode.Next = leftNode
	}
	if rightNode != nil {
		newNode.Next = rightNode
	}
	return newHead.Next
}