给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。 Python

可以使用归并排序的思想对链表进行排序。具体实现步骤如下：

1. 定义递归函数 `merge_sort`，接收链表头结点参数 `head`，并返回排序后的链表头结点。

2. 如果链表为空或只有一个结点，则直接返回。

3. 使用快慢指针找到链表的中点，并将链表从中点处断开。

4. 递归调用 `merge_sort` 函数分别对左右两个链表进行排序。

5. 定义合并两个有序链表的函数 `merge`，并将左右两个链表传入。

6. 定义两个指针 p 和 q，分别指向左右两个链表的头结点。

7. 定义一个空节点 dummy，作为合并后链表的头部。

8. 比较 p 和 q 的节点值，将较小的节点加入到 dummy 节点后面，并将该指针后移一位。

9. 重复步骤 8 直到 p 或 q 为空。

10. 将 p 或 q 剩余的节点加入到 dummy 节点后面。

11. 返回 dummy 的下一个节点，即合并后链表的头结点。

完整代码如下：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        # 定义递归函数
        def merge_sort(head):
            if not head or not head.next:
                return head
            
            # 使用快慢指针找到链表的中点
            slow, fast = head, head.next
            while fast and fast.next:
                slow = slow.next
                fast = fast.next.next
            
            # 将链表从中点处断开
            mid = slow.next
            slow.next = None
            
            # 递归调用 merge_sort 函数分别对左右两个链表进行排序
            left = merge_sort(head)
            right = merge_sort(mid)
            
            # 合并两个有序链表
            return merge(left, right)
        
        # 定义合并两个有序链表的函数
        def merge(left, right):
            dummy = ListNode(0)
            p = left
            q = right
            cur = dummy
            
            while p and q:
                if p.val <= q.val:
                    cur.next = p
                    p = p.next
                else:
                    cur.next = q
                    q = q.next
                cur = cur.next
            
            if p:
                cur.next = p
            if q:
                cur.next = q
            
            return dummy.next
        
        return merge_sort(head)

其中，时间复杂度为 O(nlogn)，空间复杂度为 O(logn)。