【leetcode】排序链表

自底向上合并排序，时间复杂度O(nlog(n))，空间复杂度O(1)

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """

        '''
        定义子函数function合并两个有序链表list1和list2
        '''
        def mergeSortList(list1, list2):
            if list1 == None:
                return list2
            elif list2 == None:
                return list1
            else:
                # list1 和 list2 都非空
                p, q, head, k = list1, list2, None, None
                while p != None and q != None:
                    if p.val <= q.val:
                        if head == None and p == list1:
                            # 新的头节点没有赋值，且p是list1的头节点的时候，新的头节点赋值为
                            head = p
                            k = head
                            p = p.next
                        else:
                            k.next = p
                            k = k.next
                            p = p.next
                    else:
                        if head == None and q == list2:
                            # 新的头节点没有赋值，且q是list2的头节点的时候，新的头节点赋值为q
                            # print('Hello q')
                            head = q
                            k = head
                            q = q.next
                        else:
                            k.next = q
                            k = k.next
                            q = q.next
                if p != None:
                    k.next = p
                elif q != None:
                    k.next = q
                return head

        '''
        主函数
        '''
        # 特殊情况：空链表
        if not head:
            return head
        # 计算链表的长度ListLen
        listLen = 0
        p = head
        while p != None:
            listLen += 1
            p = p.next
        # print('listLen = ', listLen)
        # 每两个子链表分别合并
        subListLen = 1
        while subListLen < listLen: # 循环结束的条件是子有序链表的长度小于链表的总长度
            p = head
            dummyHead = ListNode(-1) # dummy链表的头节点，真是妙啊
            prev = dummyHead # dummy链表的遍历指针
            mergeTimes = listLen//(subListLen*2) if listLen%(subListLen*2)==0 else (listLen//(subListLen*2) + 1) # 合并次数 -> listLen中有多少个(subList*2)，如果不足1也记作1
            # print('**** mergeTimes = ', mergeTimes)
            for i in range(0, mergeTimes):
                # print('subListLen = %d, i = %d' % (subListLen, i))
                # 寻找第1个有序链表
                head1 = p
                k = 0 # 记数用
                while p != None and k < subListLen:
                    q = p # 记录尾节点
                    p = p.next
                    k += 1
                q.next = None # head1的尾部指向None

                # 寻找第2个有序链表
                if p == None:
                    # 遇到不足个数的情况，第二个链表置空
                    head2 = None
                else:
                    head2 = p
                    k = 0
                    while p != None and k < subListLen:
                        q = p
                        p = p.next
                        k += 1
                    q.next = None
                
                # 合并两个有序链表，返回合并结果链表
                sortListHead = mergeSortList(head1, head2)

                # 合并结果链表拼接到dummy链表上
                prev.next = sortListHead
                tail = sortListHead
                while tail.next != None:
                    tail = tail.next
                prev = tail # 更新prev到合并结果链表的尾节点
            
            subListLen *= 2
            head = dummyHead.next # dummy链表头节点的next节点是赋值给head，图解参考Leetcode的“合并两个有序链表”

        return head

暂时想到几个容易忽略的部分：
（1）找到第1个链表的头结点head1和第2个链表的头结点head2
（2）同时将第1个链表的尾结点和第2个链表的尾结点置None
（3）同时记录第1个链表前面那个结点，记录第2个链表结尾之后的那个结点，它是下一次找head1的指针
（4）使用dummy结点避免和头结点为空的情况打交道
呜呜呜，好不容易写对了逻辑，然而代码太长了惹，不简洁
leetcode测试
执行用时：
1004 ms
, 在所有 Python 提交中击败了
5.26%
的用户
内存消耗：
45.1 MB
, 在所有 Python 提交中击败了
28.25%
的用户
通过测试用例：29/29
未免时间太长了惹，呜呜呜

于是我去看了官方题解
执行用时：
696 ms
, 在所有 Python 提交中击败了
9.71%
的用户
内存消耗：
45.1 MB
, 在所有 Python 提交中击败了
28.97%
的用户
通过测试用例：
29 / 29

它的执行时间just soso嘛

总之～子函数“合并两个有序链表”迭代法还能用dummy链表再优化优化，可能运行时间会缩短一些

最后，这次完成了长长的代码，开心到飞起来