常见的排序算法及python实现

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。

内排序有可以分为以下几类：

　　(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。

　　(2)、选择排序：简单选择排序、堆排序。

　　(3)、交换排序：冒泡排序、快速排序。

　　(4)、归并排序

　　(5)、基数排序

在学习了python一段时间后，自己尝试用python实现：插入排序、冒泡排序、快速排序、直接选择排序、归并排序。

一、插入排序

　　插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为 O(n^2)。是稳定的排序方法。

　　插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插 入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中

#插入排序
def insert_sort(sort_array):
    n=len(sort_array)
    for i in range(1,n):
        temp=sort_array[i]  #保存当前位置
        #寻找要插入的顺序
        jj = 0
        for j in range(i-1,-1,-1):
            if(temp>=sort_array[j]):
                jj=j+1
                break
        #将该位置后的元素后移
        for m in range(i,jj,-1):
            sort_array[m] = sort_array[m-1]
        #插入当前值
        sort_array[jj] = temp
    return sort_array

 

二、冒泡排序

　　它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

　　#冒泡排序
def maopao_sort(sort_array):
    
    n=len(sort_array)
    for i in range(n):
        flag=True
        for j in range(n-i-1):
            if sort_array[j]>sort_array[j+1]:
                flag=False
                sort_array[j],sort_array[j+1]=sort_array[j+1],sort_array[j]
        if flag==True:
            break
    return sort_array

 

三、快速排序

　　通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

#快速排序
def kuaisu_sort(sort_array,left,right):
    if left>=right:
        return
    key=sort_array[left]
    low=left
    high=right
    while left<right:
        while left<right and sort_array[right]>=key:
            right -= 1
        sort_array[left]=sort_array[right]
        
        while left<right and sort_array[right]<=key:
            left += 1
        sort_array[right]=sort_array[left]
    sort_array[right] = key
    kuaisu_sort(sort_array, low, left - 1)
    kuaisu_sort(sort_array, left + 1, high)
    return sort_array

四、直接选择排序

　　基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。

#选择排序
def xuanze_sort(sort_array):
    n=len(sort_array)  
    for i in range(n-1):
        min=sort_array[i]
        minindex=i
        for j in range(i+1,n):
            if sort_array[j]<min:
                minindex=j
                min=sort_array[minindex]
        sort_array[minindex],sort_array[i]=sort_array[i],sort_array[minindex]
    return sort_array

 

五、归并排序

　　归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一 个有序表，称为二路归并。

　　归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否 则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复 制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序， 最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

#合并排序
def merge_sort(array1,array2):
    result = []
    i,j=0,0
    while i<len(array1) and j<len(array2):
        if array1[i]<=array2[j]:
            result.append(array1[i])
            i +=1
        else:
            result.append(array2[j])
            j +=1
    result += array1[i:]
    result += array2[j:]
    return result
   

 

 

验证结果：

if __name__ == '__main__':
    array1=[21,34,56,9,12,3]
    array2=[21,34,56,9,12,3]
    array3=[21,34,56,9,12,3]
    array4=[21,34,56,9,12,3]
    
    array5=[21,34,56,9,12,3]
    array6=[3,4,5,9,22,1,222,444,666]
    print "berore sort is:",array1
    
    print "after sort is :",maopao_sort(array1)  
                 
    print "after sort is :",xuanze_sort(array2)
    
    print "after sort is :",insert_sort(array3)
    
    print "after sort is :",kuaisu_sort(array4,0,5)
    
    print "after sort is :",merge_sort(maopao_sort(array5),maopao_sort(array6))