python排序算法简述

1.冒泡排序

定义：冒泡排序（Bubble Sort）是把一组数据从左边开始进行两两比较，小的放前面，大的放后面，通过反复比较一直到没有数据交换为止。

def bubbleSort(s1):
    n = len(s1)
    for i in range(n):        #冒泡循环次数控制
        for j in range(n-i-1):#冒泡循环一次，范围往前缩1
            if s1[j]>s1[j+1]:
                c1=s1[j]      #把前面大数赋值给临时变量c1
                s1[j]=s1[j+1] #把后面小数放到列表前面
                s1[j+1]=c1    #把临时变量的大数放到列表的后面

l1=[9,0,6,5,3,10,36,2,1]
print('排序前的数列：',l1)
bubbleSort(l1)
print('排序后的数列：',l1)

需求规则：

1. 从队首开始，两两比较数值，把大的往后交换，一直到队尾，第一个最大值固定到最后；
2. 再从队首开始，依次两两比较，把次最大放到倒数第二位置；
3. 依次循环比较，直到完成所有数的比较和交换，完成冒泡排序。

2. 选择排序

定义：选择排序，在数据集合里，通过一轮循环找到最小值，把它放到第一个位置，然后在剩余的数据中再找最小值，放在第二个位置，以此类推，直到将所有值排序完成。

def SelectSort(arr):
    n=len(arr)
    if n==1:
        return 1
    for i in range(n):
        mid = i        #获得每次循环第一个比较值的下标
        for j in range(i,n-1):   #每次循环里寻找最小值
            if arr[mid]>arr[j+1]:#循环过程判断最小值
                mid=j+1          #获取更小值的下标
            arr[i],arr[mid]=arr[mid],arr[i]#把最小的放到最前面

s1=[3,15,10,5,7,78,43,22]
print('排序前的数列：',s1)
SelectSort(s1)
print('排序后的数列：',s1)

需求规则：

1. 输入n个数值的列表，开始0到n-1轮的循环；
2. 每轮循环记住最小值的下标，当前循环结束，把最小值放到最前面；
3. 接着进行下一轮循环，把最小值下标进行标记，最后把最小值放到当前轮循环开始的位置；
4. 一直到n-1轮，结束所有最小值的选择。

3.插入排序

定义：插入排序的原理是数列前面为排序完成的值，数列后面为未排序的值。取已排序的值右边第一个未排序的值c1，与已经排序的值进行比较，当c1大于当前值时，把当前值向后移动一位，完成一个循环的插入比较。接着进行下一轮的循环插入比较，一直到所有未排序的值都完成插入操作。第一次循环时，可以把数列第一个值作为已经排序的数来看待，从第二个值开始进行插入操作。

def InsertSort(arr):
    n=len(arr)
    if n==1:
        return 1
    for i in range(1,n):
        c1=arr[i]
        j=i
        while j>0 and c1<arr[j-1]:
            arr[j]=arr[j-1]
            j-=1
        arr[j]=c1
l2=[9,3,1,5,6]
print('排序前的列表值：', l2)
InsertSort(l2)
print('排序后的列表值：', l2)

需求规则：

1. 输入n个数值的列表；
2. 先进行下标是0和1的数值比较，把大的放后面，小的插入前面，第一轮插入比较结束；
3. 继续选择下标是2的数值和下标是1的数值进行比较，大的后移一位，小的放到临时变量c1中；然后继续比较c1和下标是0的数值，大的后移1位，小的插入前面；
4. 依次比较插入，一直到n-1轮结束比较，获得最终排序结果。

4.希尔排序

定义：希尔排序（Shell Sort)又叫作缩小增量排序法，是插入算法的一种更高效的改进算法。

def SellSort(arr):
    n=len(arr)
    endi=0                 #最后修改下标
    if n==1:
        return 1
    space=n//3             #以列表中1/3位置作为增量
    
    while space>0:
        for i in range(space):    #控制一个增量循环space次
            key = arr[i]
            j = 0                 #控制每个key元素在列表里的比较次数
            while i+(j+1)*space<n:
                print('交换开始下标数%d，交换结束%d'%(j,i+1)*space)
                if space>1:
                    if arr[i+(j+1)*space]<key:
                        arr[i+j*space] = arr[i+(j+1)*space]
                        endi=i+(j+1)*space
                else:                            #当增量为1时，相邻元素比较调整
                    if arr[j]>arr[j+1]:
                        arr[j],arr[j+1]=arr[j+1],arr[j]
                j+=1
            if arr[i]!=key:                      #必须考虑无需交换情况
                arr[endi] = key
        space-=1
s1 = [18,3,5,0,5,2,10,7,15,38,100]
print('排序前的列表值:',s1)
SellSort(s1)
print('排序后的列表值:',s1)

需求规则：
希尔排序的基本思想是：在n个元素的数列里，取增量space=n//2，数列开始值和增量尾值之间进行比较，小的放前面，大的放后面；把增量前后的数值都比较一遍，然后增量数减1，继续从头到尾作比较，并调整大小；一直到space=1，就完成了所有元素的大小调整和排序。
增量space的取法有各种方案。最初Shell提出取space=n//2向下取整，space=space//2向下取整，直到incremen=1。但由于直到最后一遍，奇数位置的元素才会与偶数位置的元素进行比较，这样使用这个序列的效率会很低。

5.快速排序

定义：快速排序（Quick Sort）是对冒泡排序的一种改进，其基本思想是：通过一轮排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的数据小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，直到整个数据变成有序序列。
分割时，先选择一个元素作为比较大小的基准数。把数列里小于Pivot数的元素放到前面，大于Pivot数的元素放到后面。这个基准数可以任意取一个，一般取开始、结束或中间位置的一个元素。

def MovePivot(arr,low,high):                    #移动基数方式比较排序
    Pivot=arr[high]                             #取最右边一个值作为基数
    imove=(low-1)                               #从最左边减1开始（下标为-1，准备与下标为0的值进行比较）
    for i in range(low,high):                   #1
        if arr[i]<=Pivot:
            imove+=1                            #记录最近一个交换值下标
            arr[imove],arr[i]=arr[i],arr[imove] #大的放后面，小的放imove处
    arr[imove+1],arr[high]=arr[high],arr[imove+1] #最后一次，把Pivot值放到imove+1处（分界处）2
    return imove+1
def QuickSort(arr,low,high):
    if low<high:                                #low=high停止递归排序
        pivot=MovePivot(arr,low,high)           #一次比较排序
        QuickSort(arr,low,pivot-1)              #递归前一部分排序
        QuickSort(arr,pivot+1,high)             #递归后一部分排序

s1=[10,3,28,4,12,20]
print('排序前列表', s1)
h=len(s1)
QuickSort(s1,0,h-1)
print('排序后列表', s1)

需求规则：

1. 选取列表最后一个数值作为基准数P，把比P小的数放前面，比P大的数放后面；
2. 分别对前面部分和后面部分的数据按照1的原则进行排列；
3. 一直到每部分的下标low=high，完成快速排序。

6.归并排序

定义：归并排序（Merge Sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个典型应用。

def MergeSort(arr):
    if len(arr) <= 1:                   #当长度为1时，并归结束
        return arr
    mid = len(arr)//2                   #对半方式并归
    left = MergeSort(arr[:mid])         #递归方法并归左边列表
    right = MergeSort(arr[mid:])        #递归方法并归右边列表
    return Merge(left, right)           #并归并返回列表
def Merge(left, right):                 #对两部分数组进行并归排序
    r, l = 0, 0
    temp = []                           #临时列表记录归并过程
    lmax = len(left)
    rmax = len(right)
    while l<lmax and r<rmax:
        if left[l] <= right[r]:         #小于等于的放左边
            temp.append(left[l])
            l += 1
        else:                           #大于的放右边
            temp.append(right[r])
            r += 1
    temp += list(left[1:])
    temp += list(right[1:])
    return temp
s1 = [1,9,10,4,50,6,7,90,21,23,45]
print('排序前列表', s1)
print('并归排序后列表', MergeSort())

需求规则：
分治法先把数列分成相对均衡的两部分n//2，然后再把左边的（left）子数列和右边的（right）子数列再各分成两部分；继续如此等分，直到只有一个元素。
等分过程采用递归方法，每分一次，在内存开辟临时的记录区域。所有元素分完后，开始大小比较归并，从两个元素比较归并到n//2比较归并。