018 Python语法之八大排序算法以及对比

八大排序算法

1. 冒泡算法

1. 算法原理

1. 第一轮比较，将前后两个元素两两比较，然后大的元素往后排列
2. 进过N轮比较后，得到的是排序过的列表

2. 冒泡排序的三大实现

实现1：

普通冒泡排序(比较次数42)

list1 = [7, 1, 2, 3, 4, 5, 6]
length = len(list1)
for x in range(0, length - 1):
    for y in range(0, length - 1):
        if list1[y] > list1[y + 1]:
            list1[y], list1[y + 1] = list1[y + 1], list1[y]
        print(list1)

实现2：

更新版冒泡排序(比较次数21)

list1 = [7, 1, 2, 3, 4, 5, 6]
for x in range(0, length - 1):
    for y in range(0, length - 1 - x):
        if list1[y] > list1[y + 1]:
            list1[y], list1[y + 1] = list1[y + 1], list1[y]
        print(list1)

实现3：

究极版冒泡排序(比较次数11)

list1 = [7, 1, 2, 3, 4, 5, 6]
length = len(list1)
for i in range(0, length - 1):
    bool = True
    for j in range(0, length - 1 - i):
        print(list1)
        if list1[j] > list1[j + 1]:
            list1[j], list1[j + 1] = list1[j + 1], list1[j]
            bool = False
    if bool:
        break

2. 插入排序

1. 算法原理

1. 进行len-1次循环，每次都将下标为i的元素插入到它前面排好序的列表中
2. 直到下标到最后一个元素就排序好了

2. 插入排序的实现

def insertSort(list1):
    length = len(list1)
    temp = 0
    # 进行len - 1 次循环，每次循环都将下标为i的元素插入到它前面已经排好序的队列中
    for i in range(1, length):
        if list1[i] < list1[i-1]:
            temp = list1[i]
            while i > 0 and temp < list1[i-1]:
                list1[i] = list1[i-1]
                i -= 1
                list1[i] = temp

list1 = [7, 1, 2, 3, 4, 5, 6]
insertSort(list1)
print(list1)

3. 选择排序

1. 算法原理

1. 首先找到最小的元素，然后将最小的元素排到第一个位置
2. 然后第二个最小的元素排在第二个位置
3. 以此类推...

2. 选择排序的实现

def selectSort(list1):
    length = len(list1)
    for i in range(0, length):
        minIndex = i
        for j in range(i + 1, length):
            if list1[minIndex] > list1[j]:
                minIndex = j
        list1[minIndex], list1[i] = list1[i], list1[minIndex]   # 将最小值排到前面的位置

4. 快速排序

1. 算法原理

1. 首先进行一轮排序，将数据分成左右两部分，左边所有数据都比右边的数据要小
2. 然后再递归对这两部分数据进行快速排序

2. 快速排序的实现

import random
import time
import sys


def quickSort(list1, left, right):
    if left >= right:
        return
    key = list1[left]
    low = left
    high = right
    while left < right:
        while left < right and list1[right] >= key:
            right -= 1
        list1[left] = list1[right]
        while left < right and list1[left] <= key:
            left += 1
        list1[right] = list1[left]
    list1[right] = key
    quickSort(list1, low, left - 1)
    quickSort(list1, left + 1, high)


def quickSort2(list1, left, right):
    if left >= right:
        return
    key = list1[left]
    low = left
    high = right
    while left < right:
        while left < right and list1[right] >= key:
            right -= 1
        list1[left] = list1[right]
        while left < right and list1[left] <= key:
            left += 1
        list1[right] = list1[left]
    list1[right] = key
    if low < left - 1:
        quickSort(list1, low, left - 1)
    if left + 1 < high:
        quickSort(list1, left + 1, high)


list1 = []
for i in range(1, 2500):
    list1.append(random.randrange(1, 2000))

sys.setrecursionlimit(3000)
time1 = time.time()
quickSort(list1, 0, len(list1) - 1)
time2 = time.time()

sys.setrecursionlimit(3000)
time3 = time.time()
quickSort2(list1, 0, len(list1) - 1)
time4 = time.time()

print("1总共用了：%.2f秒" % (time2 - time1))
print("2总共用了：%.2f秒" % (time4 - time3))

3. 两种快速排序的对比

1. 第一种quickSort所用的时间大概是第二种排序的时间的 1 / 30.
2. 第一种方式会比第二种方式多调用很多次方法占用内存相对会高一点.

• 1总共用了：0.01秒
• 2总共用了：0.36秒