leetcode148_排序链表

思路

• 自底向上构建归并排序算法

func sortList(head *ListNode) *ListNode {
    if head == nil {
        return head
    }

    // 统计链表的总长度
    listLength := 0
    for node := head; node != nil; node = node.Next{
        listLength++
    }
    
    // 引入虚拟头节点，可以避免一些不必要的讨论
    dummyHead := &ListNode{Next:head}

    // 自底向上构建归并排序
    for subLength:=1; subLength < listLength ; subLength<<=1{
        
        pre := dummyHead
        cur := dummyHead.Next

        // 构建待排序的子链表，两两合并，直至遍历完整个链表
        for cur != nil {

            head1 := cur
            for i:=1; i<subLength && cur.Next != nil; i++ {
                cur = cur.Next
            }

            head2 := cur.Next
            cur.Next = nil
            cur = head2
            for i:= 1; i<subLength && cur !=nil && cur.Next != nil; i++{
                cur=cur.Next
            }

            var next *ListNode
            if cur != nil {
                next = cur.Next
                cur.Next = nil
            }
            

            // 返回排序后链表的头节点、尾节点
            newHead, newTail := sort(head1, head2)

            pre.Next = newHead
            newTail.Next = next
            cur = next
            pre = newTail

        }
    }
    return dummyHead.Next
}

// 合并两个有序链表，并返回合并后链表的首、尾节点
func sort(head1, head2 *ListNode) (head, tail *ListNode){
    dummyNode := &ListNode{}
    cur := dummyNode

    n1, n2 := head1, head2
    for ; n1 != nil && n2 != nil; {
        if n1.Val <= n2.Val {
            cur.Next = n1
            cur = cur.Next
            n1 = n1.Next
        }else{
            cur.Next = n2
            cur = cur.Next
            n2 = n2.Next
        }
    }
    if n1 != nil {
        cur.Next = n1
        //遍历到链表尾部
        for cur.Next != nil {
            cur = cur.Next
        }
    }

    if n2 != nil {
        cur.Next = n2
        //遍历到链表尾部
        for cur.Next != nil {
            cur = cur.Next
        }
    }

    return dummyNode.Next, cur
}