链表问题（6）-----排序

一、题目：将单向链表按某值划分为左边小、中间相等、右边大的形式

简单的思路：时间O（N），空间O（N）

采用一个数组来存储链表中的值，然后对该数组进行快排，然后再连成链表，快排思想如下图所示：

代码：

class Node:
    def __init__(self,value):
        self.value = value
        self.next = None
#快排思想
def partition(arr,pivot):
    small = -1
    big = len(arr)
    index = 0
    while index != big:
        if arr[index] < pivot:
            small += 1
            arr[small] , arr[index] = arr[index] , arr[small]
            index += 1
        elif arr[index] == pivot:
            index += 1
        else:
            big -= 1
            arr[index] , arr[big] = arr[big] , arr[index]
    return arr
#链表操作
def listSort(head,pivot):
    if not head:
        return head
#将链表存储在数组中
    arr = []
    while head:
        arr.append(head.value)
        head = head.next
    arr = partition(arr,pivot) 
#创建链表   
    node = Node(arr[0])
    p = node
    for i in range(1,len(arr)):
        p.next = Node(arr[i])
        p = p.next
    return node

head = Node(9)
head.next = Node(0)
head.next.next = Node(4)
head.next.next.next = Node(3)
head.next.next.next.next = Node(1)
pivot = 3
node = listSort(head,pivot)

进阶思想：时间O（N），空间O（1）

 

代码：

class Node:
    def __init__(self,value):
        self.value = value
        self.next = None
def listPartition(head,pivot):
    if not head:
        return head
    sH = None
    sT = None
    eH = None
    eT = None
    bH = None
    bT = None   
    while head:
        next = head.next
        head.next = None
        if head.value < pivot:
            if not sH:
                sH = head
                sT = head
            else:
                sT.next = head
                sT = head
        elif head.value == pivot:
            if not eH:
                eH = head
                eT = head
            else:
                eT.next = head
                eT = head
        else:
            if bH == None:
                bH = head
                bT = head
            else:
                bT.next = head
                bT = head
        head = next
    
    if sT:
        sT.next = eH
        eT = eT if eT else sT
    if eT:
        eT.next = bH
    return sH if sH else eH if eH else bH

arr = [9,1,4,5,6,3,8]
head = Node(arr[0])
p = head
for i in range(1,len(arr)):
    p.next = Node(arr[i])
    p = p.next
pivot = 5
res = listPartition(head,pivot)

---

二、题目：实现单链表的选择排序：

要求：额外空间为O（1），时间复杂度为O（N²）

代码：

class Node:
    def __init__(self,val):
        self.val = val
        self.next = None
def sortList(head):
    if not head:
        return head
    tail = None
    res = tail
    cur = head
    smallpre = Node(None)
    small = Node(None)
    while cur:
        small = cur
        smallPre = getSmallValue(cur)
        if smallPre: 
            small = smallPre.next 
            smallPre.next = small.next
        cur = cur.next if cur == small else cur
        if not tail:
            tail = small
            res = small
        else:
            tail.next = small
        tail = small
def getSmallValue(cur):
    small = cur
    smallPre = None
    while cur.next:
        if cur.next.val < small.val:
            small = cur.next
            smallPre = cur
        cur = cur.next
    return smallPre
head = Node(4)
head.next = Node(5)
head.next.next = Node(3)
head.next.next.next = Node(1)
head.next.next.next.next = Node(2)
sortList(head)   

---

三、题目：实现单链表的归并排序

在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。

思路：时间复杂度O（nlogn），空间复杂度O(1)

1、找到链表中间节点

2、递归排序左边链表和右边链表。

3、排序合并左右两边链表

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

class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next:
            return head
        mid = self.get_mid(head)
        l = head
        r = mid.next
        mid.next = None
        return self.merge(self.sortList(l),self.sortList(r))
    def get_mid(self,head):
        if not head or not head.next:
            return None
        slow = head
        fast = head
        while fast.next and fast.next.next:
            slow = slow.next
            fast = fast.next.next
        return slow
    def merge(self,l,r):
        head = ListNode(0)
        tmp = head
        while l and r:
            if l.val <= r.val:
                tmp.next = l
                l = l.next
            else:
                tmp.next = r
                r = r.next
            tmp = tmp.next
        if l:
            tmp.next = l
        if r:
            tmp.next = r
        return head.next
                
                 

 

---

四、对链表进行插入排序

时间复杂度为O（n2)，空间复杂度为O（1）

思路：

一个函数遍历原链表到当前元素，一个函数将当前元素插入到已经排好序的链表中，最终返回已经排好序的列表。

代码：

lass ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def insertionSortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next:
            return head
        sortnode = None
        cur = head
        while cur:
            node = cur
            cur = cur.next
            node.next = None
            sortnode = self.sortList(sortnode,node)
            
        return sortnode
    def sortList(self,head,node):
        pre = None
        cur = head
        while cur and node.val > cur.val:
            pre = cur
            cur = cur.next
        node.next = cur
        if cur == head:
            head = node
        else:
            pre.next = node
        return head