链表实现冒泡排序 leetcode148题 性能分析（时间空间复杂度稳定性）

背景

用链表来实现冒泡排序

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
##################################用来练习冒泡排序###########################
class Solution:

    def length(l: ListNode):
        """链表长度"""
        # 初始指针指向head
        cur = l
        count = 0
        # 指针指向None 表示到达尾部
        while cur is not None:
            count += 1
            # 指针下移
            cur = cur.next
        return count

    def sortList(self, head: ListNode) -> ListNode:
        if not head or not head.next: return head
        
        #增加哨兵（头节点），before_sort从哨兵开始遍历，sort从真实头节点开始 
        sort = head
        before_sort = head
        res = ListNode(0)
        res.next = head

        for i in range(Solution.length(head)):
            sort = res.next
            before_sort = res
            flag = False #如果某一次全部遍历之后发现都没有节点交换，那么说明后面的冒泡不需要了，直接return
            for j in range(Solution.length(res.next) - i -1):
            #注意sort和sort.next的判断
                if sort and sort.next and sort.val > sort.next.val:
                    temp = sort.next
                    sort.next = sort.next.next
                    before_sort.next = temp
                    temp.next = sort
                    before_sort = before_sort.next
                    flag = True
                elif before_sort and sort:
                    before_sort = before_sort.next
                    sort = sort.next
            if flag == False: return res.next
        
        return res.next

性能分析

空间复杂度O(1)
时间复杂度O(n^2)

平均情况时间复杂度
这里引用王争的分析：

稳定的排序指的是，排序之后，相同数值的两项前后关系没有被破坏

冒泡排序在交换时，相同的项，可以选择不换，所以是稳定的排序