排序算法及Python实现

本帖记录排序算法的原理和Python实现

持续更新中！！！

选择排序

# 基本排序算法：选择排序、冒泡排序、插入排序
# 一、选择排序
# 思想：搜索整个列表，找到最小项的位置，如果该位置不是列表的第一个位置，就会交换，
# 然后返回到列表第2个位置并重复该位置，重复该方法
def selectionSort(lyst):
    for i in range(len(lyst)):
        minIndex = i
        for j in range(i+1, len(lyst)):
            if lyst[minIndex] > lyst[j]:
                minIndex = j
        lyst[i], lyst[minIndex] = lyst[minIndex], lyst[i]
    return lyst

冒泡排序

# 冒泡排序：从列表的开头开始，比较一对数据项，直到移动到列表的末尾，每当成对的两项间顺序不正确的时候，就交换位置，该过程的效果就是将最大的项以冒泡的方式拍到列表的末尾
# 对已经排好序的列表来说，其性能比选择排序的性能要好
def bubbleSort(lyst):
    n = len(lyst)
    for i in range(n):
        for j in range(0, n-1-i):
            if lyst[j] > lyst[j+1]:
                lyst[j], lyst[j+1] = lyst[j+1], lyst[j]
    return lyst    

插入排序

# 插入排序：是一种简单直观的排序算法。
# 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 
def insertionSort(lyst):
    for i in range(1, len(lyst)):
#       当前需要插入的元素
        key = lyst[i]
#       比较元素位置
        j = i - 1
        while j >= 0 and key < lyst[j]:
#           当比较元素大于当前元素，则把比较元素后移
            lyst[j+1] = lyst[j]
#           往前选择下一个比较元素
            j -= 1
#       当比较元素小于当前元素，则将当前元素插在其后面
        lyst[j+1] = key
    return lyst

快速排序

# 更快的排序：快速排序和合并排序 复杂度为O(nlogn)
# 分而治之，将列表分解为更小的子列表，随后将这些子列表再递归地排序
# 快速排序：使用分治法（Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。
# 1. 在数列之中，选择一个元素作为”基准”（pivot），或者叫比较值。
# 2. 数列中所有元素都和这个基准值进行比较，如果比基准值小就移到基准值的左边，如果比基准值大就移到基准值的右边
# 3. 以基准值左右两边的子列作为新数列，不断重复第一步和第二步，直到所有子集只剩下一个元素为止
def partition(lyst, low, high):
#   最小元素索引,low为起始索引，high为结束索引
    i = low - 1
#   基准点
    pivot = lyst[high]
    for j in range(low, high):
#       当前元素小于或等于pivot
        if lyst[j] <= pivot:
            i = i + 1
            lyst[i], lyst[j] = lyst[j], lyst[i]
    lyst[i+1], lyst[high] = lyst[high], lyst[i+1]
    return (i + 1)
def quickSortHelper(lyst, low, high):
    if low < high:
        pivotLocation = partition(lyst, low, high)
        quickSortHelper(lyst, low, pivotLocation - 1)
        quickSortHelper(lyst, pivotLocation + 1, high)
    return lyst
        
def quickSort(lyst):
    quickSortHelper(lyst, 0, len(lyst) - 1)
    return lyst

# 快速排序——递归方法
def quicksort(lyst):
    if len(lyst) <= 1:
        return lyst
    pivot = lyst[len(lyst) // 2]
    left = [i for i in lyst if i < pivot]
    middle = [i for i in lyst if i == pivot]
    right = [i for i in lyst if i > pivot] 
    return quicksort(left) + middle + quicksort(right)

归并排序

# 合并排序或归并排序
#步骤：
# 计算一个列表的中间位置，并且递归地排序其左边和右边的子列表
# 将两个排好序的子列表重新合并为单个的排好序的列表
# 当子列表不再能够划分的时候，停止这个过程
def merge(a,b):
    c = []
    h = j = 0
    while j < len(a) and h < len(b):
        if a[j] < b[h]:
            c.append(a[j])
            j += 1
        else:
            c.append(b[h])
            h += 1
    if j == len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)
    return c
  def mergeSort(lyst):
    if len(lyst) <= 1:
        return lyst
    middle = len(lyst) // 2
    left = mergeSort(lyst[:middle])
    right = mergeSort(lyst[middle:])
    return merge(left, right)

---

全部代码：

---

# 一、选择排序
# 思想：搜索整个列表，找到最小项的位置，如果该位置不是列表的第一个位置，就会交换，
# 然后返回到列表第2个位置并重复该位置，重复该方法
def selectionSort(lyst):
    for i in range(len(lyst)):
        minIndex = i
        for j in range(i+1, len(lyst)):
            if lyst[minIndex] > lyst[j]:
                minIndex = j
        lyst[i], lyst[minIndex] = lyst[minIndex], lyst[i]
    return lyst
    
# 冒泡排序：从列表的开头开始，比较一对数据项，直到移动到列表的末尾，每当成对的两项间顺序不正确的时候，就交换位置，该过程的效果就是将最大的项以冒泡的方式拍到列表的末尾
# 对已经排好序的列表来说，其性能比选择排序的性能要好
def bubbleSort(lyst):
    n = len(lyst)
    for i in range(n):
        for j in range(0, n-1-i):
            if lyst[j] > lyst[j+1]:
                lyst[j], lyst[j+1] = lyst[j+1], lyst[j]
    return lyst  
    
# 插入排序：是一种简单直观的排序算法。
# 它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 
def insertionSort(lyst):
    for i in range(1, len(lyst)):
#       当前需要插入的元素
        key = lyst[i]
#       比较元素位置
        j = i - 1
        while j >= 0 and key < lyst[j]:
#           当比较元素大于当前元素，则把比较元素后移
            lyst[j+1] = lyst[j]
#           往前选择下一个比较元素
            j -= 1
#       当比较元素小于当前元素，则将当前元素插在其后面
        lyst[j+1] = key
    return lyst
    
# 更快的排序：快速排序和合并排序 复杂度为O(nlogn)
# 分而治之，将列表分解为更小的子列表，随后将这些子列表再递归地排序
# 快速排序：使用分治法（Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。
# 1. 在数列之中，选择一个元素作为”基准”（pivot），或者叫比较值。
# 2. 数列中所有元素都和这个基准值进行比较，如果比基准值小就移到基准值的左边，如果比基准值大就移到基准值的右边
# 3. 以基准值左右两边的子列作为新数列，不断重复第一步和第二步，直到所有子集只剩下一个元素为止
def partition(lyst, low, high):
#   最小元素索引,low为起始索引，high为结束索引
    i = low - 1
#   基准点
    pivot = lyst[high]
    for j in range(low, high):
#       当前元素小于或等于pivot
        if lyst[j] <= pivot:
            i = i + 1
            lyst[i], lyst[j] = lyst[j], lyst[i]
    lyst[i+1], lyst[high] = lyst[high], lyst[i+1]
    return (i + 1)
def quickSortHelper(lyst, low, high):
    if low < high:
        pivotLocation = partition(lyst, low, high)
        quickSortHelper(lyst, low, pivotLocation - 1)
        quickSortHelper(lyst, pivotLocation + 1, high)
    return lyst
def quickSort(lyst):
    quickSortHelper(lyst, 0, len(lyst) - 1)
    return lyst
    
# 快速排序——递归方法
def quicksort1(lyst):
    if len(lyst) <= 1:
        return lyst
    pivot = lyst[len(lyst) // 2]
    left = [i for i in lyst if i < pivot]
    middle = [i for i in lyst if i == pivot]
    right = [i for i in lyst if i > pivot] 
    return quicksort(left) + middle + quicksort(right)

# 合并排序或归并排序
# 计算一个列表的中间位置，并且递归地排序其左边和右边的子列表
# 将两个排好序的子列表重新合并为单个的排好序的列表
# 当子列表不再能够划分的时候，停止这个过程
def merge(a,b):
    c = []
    h = j = 0
    while j < len(a) and h < len(b):
        if a[j] < b[h]:
            c.append(a[j])
            j += 1
        else:
            c.append(b[h])
            h += 1
    if j == len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)
    return c
    
def mergeSort(lyst):
    if len(lyst) <= 1:
        return lyst
    middle = len(lyst) // 2
    left = mergeSort(lyst[:middle])
    right = mergeSort(lyst[middle:])
    return merge(left, right)

if __name__ == '__main__':
    lyst = [5,3,1,2,4]
    s_sort = selectionSort(lyst)
    print(s_sort)
    b_sort = bubbleSort(lyst)
    print(b_sort)
    i_sort = insertionSort(lyst)
    print(i_sort)
    q_sort = quickSort(lyst)
    print(q_sort)
    q_sort1 = quicksort1(lyst)
    print(q_sort1)
    m_sort = mergeSort(lyst)
    print(m_sort)

除了以上五大基本排序算法，还有堆排序、桶排序和希尔排序，总共八大排序算法，这八大排序算法的空间复杂度和时间复杂度如下：