八大排序算法（python实现）

八大排序：（代码均用python实现）
算法分析

快排：

def QSort(A, low, high):
    if low<high:
        pivotpos = Findi(A, low, high)
        QSort(A, low, pivotpos-1)
        QSort(A, pivotpos+1, high)
def Findi(A, low, high):
    pivot = A[low]
    while(low<high):
        while(low<high and A[high]>=pivot):
            high -= 1
        A[low] = A[high]
        while(low<high and A[low]<=pivot):
            low += 1
        A[high] = A[low]
    A[low] = pivot
    return low

冒泡排序：

def bubbleSort(list1):
    for i in range(len(list1)-1):
        flag = False               //用来记录是否发生交换
        for j in range(len(list1)-i-1):
            if(list1[j]>list1[j+1]):
                list1[j],list1[j+1] = list1[j+1],list1[j]
                flag = True
        if(flag==False):            //未发生交换，数组中已有序，直接返回
            return

直接插入排序：

def insertSort(list2):
    for i in range(1, len(list2)):
        temp = list2[i]
        a = i-1
        for j in range(i-1, -1, -1):
            if(temp<list2[j]):
                list2[j+1] = list2[j]
                a = a-1
        print(a+1,end=" ")
        print(i)
        list2[a+1] = temp

简单选择排序：

def SelectSort(list3):
    for i in range(len(list3)):
        minl = i
        for j in range(i+1,len(list3)):
            if(list3[j]<list3[minl]):
                minl = j
        if(minl != i):
            list3[minl],list3[i] = list3[i],list3[minl]

希尔排序：

def ShellSort(list4):
    length = len(list4)
    gap = length//2
    while gap>0:
        for i in range(gap,length):
            j = i - gap
            temp = list4[i]
            while j>=0 and temp<list4[j]:
                list4[j+gap] = list4[j]
                j -= gap
            list4[j+gap] = temp
        gap //= 2
    return list4

归并排序：

def merge(arr, l, m, r): 
    n1 = m - l + 1
    n2 = r- m 
    # 创建临时数组
    L = [0] * (n1)
    R = [0] * (n2)
    # 拷贝数据到临时数组 arrays L[] 和 R[] 
    for i in range(0 , n1): 
        L[i] = arr[l + i] 
  
    for j in range(0 , n2): 
        R[j] = arr[m + 1 + j] 
  
    # 归并临时数组到 arr[l..r] 
    i = 0     # 初始化第一个子数组的索引
    j = 0     # 初始化第二个子数组的索引
    k = l     # 初始归并子数组的索引
  
    while i < n1 and j < n2 : 
        if L[i] <= R[j]: 
            arr[k] = L[i] 
            i += 1
        else: 
            arr[k] = R[j] 
            j += 1
        k += 1
  
    # 拷贝 L[] 的保留元素
    while i < n1: 
        arr[k] = L[i] 
        i += 1
        k += 1
  
    # 拷贝 R[] 的保留元素
    while j < n2: 
        arr[k] = R[j] 
        j += 1
        k += 1
  
def mergeSort(arr,l,r): 
    if l < r: 
        m = int((l+(r-1))/2)
     
        mergeSort(arr, l, m) 
        mergeSort(arr, m+1, r) 
        merge(arr, l, m, r) 
  
arr = [12, 11, 13, 5, 6, 7] 
n = len(arr) 
print ("给定的数组") 
for i in range(n): 
    print ("%d" %arr[i])
  
mergeSort(arr,0,n-1) 
print ("\n\n排序后的数组") 
for i in range(n): 
    print ("%d" %arr[i])

堆排序 ：

def heapify(arr, n, i): 
    largest = i  
    l = 2 * i + 1     # left = 2*i + 1 
    r = 2 * i + 2     # right = 2*i + 2 
  
    if l < n and arr[i] < arr[l]: 
        largest = l 
  
    if r < n and arr[largest] < arr[r]: 
        largest = r 
  
    if largest != i: 
        arr[i],arr[largest] = arr[largest],arr[i]  # 交换
  
        heapify(arr, n, largest) 
  
def heapSort(arr): 
    n = len(arr) 
  
    # Build a maxheap. 
    for i in range(n, -1, -1): 
        heapify(arr, n, i) 
  
    # 一个个交换元素
    for i in range(n-1, 0, -1): 
        arr[i], arr[0] = arr[0], arr[i]   # 交换
        heapify(arr, i, 0) 
  
arr = [ 12, 11, 13, 5, 6, 7] 
heapSort(arr) 
n = len(arr) 
print ("排序后") 
for i in range(n): 
    print ("%d" %arr[i])

排序方法总结：

1. 当代排序的关键字序列已经基本有序时，用直接插入排序最快，冒泡排序速度也比较快，快排的速度显著变慢。
2. 归并排序对待排序关键字得初始排列不敏感，故排序速度较稳定
3. 若待排序的记录个数n较小时，可采用直接插入或选择排序。由于直接插入所需移动记录的操作比简单选择多，所以当记录本身信息量较大时用简单选择较好。
4. 当n很大且关键字位数较少时，采用链接基数排序较好
5. 当n较大时，则应采用的时间复杂度为O（nlog2^n)得快排、堆排序、归并排序