對連結串列進行插入排序。

插入排序的動畫演示如上。從第一個元素開始，該連結串列可以被認為已經部分排序（用黑色表示）。
每次迭代時，從輸入資料中移除一個元素（用紅色表示），並原地將其插入到已排好序的連結串列中。

插入排序演算法：

插入排序是迭代的，每次只移動一個元素，直到所有元素可以形成一個有序的輸出列表。
每次迭代中，插入排序只從輸入資料中移除一個待排序的元素，找到它在序列中適當的位置，並將其插入。
重複直到所有輸入資料插入完為止。

示例 1：

輸入: 4->2->1->3
輸出: 1->2->3->4
示例2：

輸入: -1->5->3->4->0
輸出: -1->0->3->4->5

來源：力扣（LeetCode）

直接sort()

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        res=head
        nodes=[]
        while res:
            nodes.append(res.val)
            res
 
=res.next
        nodes.sort()
        i=0
        res=head
        while res:
            res.val=nodes[i]
            res=res.next
            i+=1
        return head

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
 


class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        if not head:return None
        nodes=[]
        node=head
        while node:
            nodes.append(node)
            node=node.next
        nodes=sorted(nodes,key=lambda x:x.val)
        for i in range(len(nodes)-1):
            nodes[i].next=nodes[i+1]
        nodes[len(nodes)-1].next=None
        return nodes[0]

堆

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
import heapq
class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        if not head: return head

        heap = []
        heapq.heapify(heap)

        while head:
            heapq.heappush(heap, head.val)
            head = head.next

        root = ListNode(0)
        cur = root
        while heap:
            val = heapq.heappop(heap)
            cur.next = ListNode(val)
            cur = cur.next

        return root.next

歸併排序

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        
        def merge(p1, p2):
            p = helper = ListNode()
            while p1 and p2:
                if p1.val < p2.val:
                    p.next = p1
                    p1 = p1.next
                else:
                    p.next = p2
                    p2 = p2.next
                p = p.next
            if p1: p.next = p1
            if p2: p.next = p2
            return helper.next

        def merge_sort(left, right):
            if left is right: return left
            slow, fast = left, left.next
            while fast and fast.next:
                slow, fast = slow.next, fast.next.next
            mid, slow.next = slow.next, None
            p1 = merge_sort(left, slow)
            p2 = merge_sort(mid, right)
            return merge(p1, p2)
        
        return merge_sort(head, None)

插入排序

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        dummy=ListNode(0)
        while head:
            p=dummy
            while p.next and p.next.val<head.val:
                p=p.next
            q=head
            head=head.next
            q.next=p.next
            p.next=q
        return dummy.next