python排序链表快速排序_python实现链表归并排序与快排

# encoding=utf-8

"""

8.24日

快速排序、归并排序应用到链表当中

"""

class ListNode():

"""定于链表节点"""

def __init__(self, value):

self.value = value

self.next = None

class NodeList():

"""定义链表"""

def __init__(self):

self.head = None

def nodelist_init(self, list0):

"""初始化链表，使用list数据"""

node_list = []

for l in list0:

newnode = ListNode(l)

node_list.append(newnode)

for i in range(len(node_list) - 1):

node_list[i].next = node_list[i + 1]

node_list[-1].next = None

self.head = node_list[0]

def listsort(self):

"""链表排序，可以选择不同的排序方案"""

# s = Solution()

# s.quicksorted(self.head, None) # 快排

s = Solution1() # 归并排序

self.head = s.mergesort(self.head)

def printListnode(self):

"""输出链表每个节点值"""

p = self.head

while p:

print(p.value)

p = p.next

class Solution():

"""快排类"""

def __init__(self):

pass

def quicksorted(self, head, end):

if head != end:

node = self.partition(head, end) # 先挖坑填数

self.quicksorted(head, node) # 递归调用

self.quicksorted(node.next, end) # 递归调用

def partition(self, head, end):

p1, p2 = head, head.next # p2是遍历指针，p1是小数的指针

while p2 != end:

if p2.value < head.value:

p1 = p1.next

tmp = p2.value

p2.value = p1.value

p1.value = tmp

p2 = p2.next

tmp = head.value

head.value = p1.value

p1.value = tmp

return p1

class Solution1():

"""归并排序类"""

def __init__(self):

pass

def mergesort(self, head):

if head is None or head.next is None:

"""链表为空或仅有一个节点，直接返回结果"""

return head

mid = self.getmid(head)

right = mid.next

mid.next = None

mer1 = self.mergesort(head)

mer2 = self.mergesort(right)

result = self.merge(mer1, mer2)

return result

def getmid(self, head):

"""使用快慢指针寻找链表中间节点"""

if head is None or head.next is None:

return head

fast = head

slow = head

try:

while fast.next.next is not None and slow.next is not None:

fast = fast.next.next

slow = slow.next

except:

pass

return slow

def merge(self, head1, head2):

"""对两个链表进行归并，比较两个链表当中的值，合并到一个新的链表当中"""

p1 = head1

p2 = head2

if head1.value < head2.value:

head = head1

p1 = p1.next

else:

head = head2

p2 = p2.next

p = head # 新生成的头指针不能动, 由p来进行移动

while p1 is not None and p2 is not None:

if p1.value < p2.value:

p.next = p1

p1 = p1.next

p = p.next

else:

p.next = p2

p2 = p2.next

p = p.next

if p1 is not None:

p.next = p1

else:

p.next = p2

return head

if __name__ == '__main__':

"""代码直接可以跑，python3."""

nodelist = NodeList()

nodelist.nodelist_init([3, 5, 7, 3, 2, 5, 1])

nodelist.listsort()

nodelist.printListnode()图解排序算法(四)之归并排序 - dreamcatcher-cx - 博客园（侵删）

自己画了一个快速排序的简单例子示意图，比较粗糙大家凑合看一下吧：

初始链表值为【3 5 7 3 1 2】

再附一张各类排序算法的比较列表：

以上