python 数据结构各种排序算法

直接上代码

#  注意三个冒名双引起来是对一段进行注释。
import random
arr = [5,8,6,9,4,10,1,3,6]

"""
冒泡排序
"""
def BubbleSort(arr):
    m = len(arr)
    i = 0
    temp = 0
    while( i < m-1):
        for j in range(0,len(arr)-1,1):
            if(arr[j] > arr[j+1]):
                temp = arr[j+1]
                arr[j+1] = arr[j]
                arr[j] = temp
        i = i+1

#print(arr)
#BubbleSort(arr)
#print(arr)
"""
冒泡排序
"""
def BubbleSort2(arr):
    arrlen = len(arr)
    for i in range(arrlen -1):
        for j in range(arrlen-i-1):
            if(arr[j] > arr[j+1]):
                arr[j],arr[j+1] = arr[j+1],arr[j]


"""
print(arr)
BubbleSort2(arr)
print(arr)
"""

"""
归并排序。。。
"""
# 归并a[left,mid]  和 a[mid+1,right]
def Merge(arr,left,mid,right):
    result =[]
    arrA = arr[left:mid+1]   #元素个数 为mid+1 - left        arr[left] ~ arr[mid]
    arrB = arr[mid+1:right+1]#元素个数 为right + 1- mid+1    arr[mid]  ~ arr[right]
    while(len(arrA) > 0 and len(arrB)>0):
        if(arrA[0] > arrB[0]):
            result.append(arrB.pop(0))
        else:
            result.append(arrA.pop(0))
    if(len(arrA) > 0):
        result.extend(arrA)
    if(len(arrB) > 0):
        result.extend(arrB)
    arr[left:right+1] = result      # 注意列表最后一个下标  类似   C++ 迭代器的end

def MergeSort(arr,left,right):
    if(left < right):
        mid = int(left + (right - left)/2)
        MergeSort(arr,left,mid)
        MergeSort(arr,mid+1,right)
        Merge(arr,left,mid,right)
    
"""
print(arr)
MergeSort(arr,0,len(arr)-1)
print(arr)
"""


#插入排序

def  insertSort(a):
    length = len(a)
    for i in range(1,length,1):
        data = a[i]
        j = i -1
        while(j >= 0):
            if(a[j] > data):
                a[j+1] = a[j]
            else:
                break
            j = j-1           
        a[j+1] = data     #j = -1 时，a[0]  = data
    print("i =",i)        #注意最终i的值与for循环不一样。i = len(a)
"""   
print(arr)
insertSort(arr)
print(arr)
"""


#选择排序

def selectSort(a):
    length = len(a)
    for i in range(0,length-1,1):
        k = i
        for j in range(i+1,length,1):      #找到最大数的下标K  与  a[i]  交换
            if(a[j] < a[k]):
                k = j
        if(k != i):
            a[i],a[k] = a[k],a[i]

"""
print(arr)
selectSort(arr)
print(arr)
"""

#堆排序
#调整i结点为最大堆结点
def HeapAdjust(arr,i,N):#对i结点进行堆调整,树的最大下标为N
    temp = arr[i]
    j = 2*i+1#这是左孩子下标
    while(j <= N):#说明至少有一个孩子
        if(j < N and arr[j+1] > arr[j]):#j < N  说明有右孩子  且右孩子》左孩子时，j++
            j = j+1
        if(temp > arr[j]):#最大孩子与调整结点temp比较
            break
        else:
            arr[i] = arr[j]#最大孩子上调
            i= j   # 对j位置及孩子再次调整
            j = 2*j +1
    arr[i]=temp
   
     
                

def HeapSort(arr):
    length = len(arr)
    mid = int(length/2)
    for i in range(mid,-1,-1):  #  从结点length/2  至  0  依次调整使得每个结点都是大顶堆。
        HeapAdjust(arr,i,length-1)
    j = length -1
    for j in range(j,0,-1):#只需要交换到arr[1] 处即可。arr[1]  ~ arr[length-1]已经有序,所以a[0]  也有序
        arr[j],arr[0] = arr[0],arr[j]  #将最大值依次调到后面有序存放
        HeapAdjust(arr,0,j-1)  #从  arr[0] ~ arr[j-1]这一段元素进行堆调整


"""
print(arr)
HeapSort(arr)
print(arr)
"""



def partion(a,left,right):
    r = random.randint(left,right)
    a[left],a[r] = a[r],a[left]
    data = a[left]
    i = left
    j =right
    while(i < j):
        while(i < j and a[j] >= data):
            j = j-1
        a[i] = a[j]     # 首次循环将a[j] 放在  left位置   后面循环将a[j] 放到前面空缺的i位置
        while(i < j and a[i] <= data):
            i = i+1
        a[j] = a[i] # 将a[i] 放到后面空缺的j位置
    a[i] = data         # 循环结束 i = j  这是一个空缺位置
    return i      #莫忘记返回中间位置

        
        
    
    

def QuickSort(arr,left,right):
    if(left < right):
        pivot = partion(arr,left,right)    #  pivot左边的数比arr[pivot]小，pivot右边的数比arr[pivot]大
        QuickSort(arr,left,pivot-1)
        QuickSort(arr,pivot+1,right)




print(arr)
QuickSort(arr,0,len(arr)-1)
print(arr)