python 单向链表实现快速排序_python 单向链表实现快速排序

快速排序的基本思想：

从序列当中选择一个基准数

在这里我们选择序列当中第一个数作为基准数

将序列当中的所有数依次遍历，比基准数大的位于其右侧，比基准数小的位于其左侧

重复步骤1.2，直到所有子集当中只有一个元素为止。

以【4，2，5，3，7，9，0，1】为例，我们来模拟一趟快排的过程。

1、初始化时，i指向链表首元素4；j = i +1，指向2。基准数字为当前i 指向的数字：4。

j

4

2

5

3

7

9

0

1

i

2、随后开始循环，j 当前指向2，因为2小于4，所以要把2移动到前面去。按照我们的算法步骤操作：

i ++，首先 i 向后移动一位，指向2

swap(i， j) ，随后交换 i、j 位置的值，这里面是2和2自己交换

j ++，然后 j 向后移动一位，指向5

执行一次交换后的结果如下：

j

4

2

5

3

7

9

0

1

i

3、接下来，由于 j 指向的值5 大于4，直接跳过，执行j++，此时 j 指向3

j

4

2

5

3

7

9

0

1

i

4、 j 指向的值为3，小于4，仿照步骤2，我们再次执行一次交换移动过程。

i ++，首先 i 向后移动一位，指向5

swap(i， j) ，随后交换 i、j 位置的值，这里面是5和3交换

j ++，然后 j 向后移动一位，指向7

交换后的结果如下：

j

4

2

3

5

7

9

0

1

i

5、 j指向的值为7，大于4，所以直接跳过，执行 j++，j 指向9

j

4

2

3

5

7

9

0

1

i

6、同理，j 指向的值为9，也大于4，跳过，执行 j++，j 指向0

j

4

2

3

5

7

9

0

1

i

7、 j 指向的值为0，小于4，执行一次交换过程

i ++，首先 i 向后移动一位，指向5

swap(i， j) ，随后交换 i、j 位置的值，这里面是5和0交换

j ++，然后 j 向后移动一位，指向1

交换后的结果如下：

j

4

2

3

0

7

9

5

1

i

8、 j 指向的值为1，小于4，我们再执行一次交换过程

i ++，首先 i 向后移动一位，指向7

swap(i， j) ，随后交换 i、j 位置的值，这里面是7和1交换

j ++，然后 j 向后移动一位，已经超过了链表的长度，不再向后移动。

交换后的结果如下：

j

4

2

3

0

1

9

5

7

i

9、最后，交换当前 i指向的值1，和4。得到【1、2、3、0、4、9、5、7】，一趟排序结束。

j

1

2

3

0

4

9

5

7

i

我们发现，4的左边都是小于4的数字，右边都是大于4的数字。

接下来，对左边和右边分别排序，不断递归下去，直到元素全部有序。

// 链表结点类

class Node():

def __init__(self, item=None):

self.item = item // 数据域

self.next = None // 指针域

// 链表类，生成链表以及定义相关方法

class LinkList():

def __init__(self):

self.head = None

// 生成链表，这里使用list来生成

def create(self, item):

self.head = Node(item[0])

p = self.head

for i in item[1:]:

p.next = Node(i)

p = p.next

// 遍历显示

def print(self):

p = self.head

while p != None:

print(p.item, end=' ')

p = p.next

print()

// 根据索引取值

def getItem(self, index):

p = self.head

count = 0

while count != index:

p = p.next

count += 1

return p.item

// 根据索引设值

def setItem(self, index, item):

p = self.head

count = -1

while count < index-1:

p = p.next

count += 1

p.item = item

// 互换

def swapItem(self, i, j):

t = self.getItem(j)

self.setItem(j, self.getItem(i))

self.setItem(i, t)

def quicksortofloop(self, left, right):

if left < right:

// 初始化

i = left

j = i+1

start = self.getItem(i)

// 大循环条件，j不能超过链表长度

while (j <= right):

// 如果 j 指向的值大于等于基准数字，直接跳过

while (j <= right and self.getItem(j) >= start):

j += 1

// 否则，j 指向的值小于基准，则交换

if (j <= right):

i += 1

self.swapItem(i, j)

self.print()

j += 1

self.swapItem(left, i)

self.quicksortofloop(left, i-1)

self.quicksortofloop(i+1, right)

if __name__ == "__main__":

L = LinkList()

L.create([4, 2, 5, 3, 7, 9, 0, 1])

L.quicksortofloop(0, 7)

L.print()

4 2 5 3 7 9 0 1

4 2 3 5 7 9 0 1

4 2 3 0 7 9 5 1

4 2 3 0 1 9 5 7

1 0 3 2 4 9 5 7

0 1 3 2 4 9 5 7

0 1 2 3 4 9 5 7

0 1 2 3 4 9 5 7

0 1 2 3 4 7 5 9

0 1 2 3 4 5 7 9

参考：https://www.cnblogs.com/wuxinyan/p/8615127.html

参考：https://blog.csdn.net/u010429424/article/details/77776731