python 各种排序算法

python各种排序算法

from pysnooper import snoop
from typing import List
import random
import numpy as np

class sort:
    def BubbleSort(self,array:List):
        '''
        Bubble sort
        :param array:
        :return:
        '''
        arrayLen=len(array)
        for i in reversed(range(arrayLen)):
            print(i)
            for j in range(i):
                if array[j+1]<array[j]:
                    self.Swap(array,j+1,j)

    def ChooseSort(self,array:List):
        '''
        Choose sort
        :param array:
        :return:
        '''
        arrayLen=len(array)
        for i in range(arrayLen-1):
            minIndex=i
            minValue=array[i]
            for j in range(i+1,arrayLen):
                if minValue > array[j]:
                    minValue,minIndex=array[j],j
                    self.Swap(array,i,minIndex)

    def InsertSort(self,array:List):
        arrayLen=len(array)
        if arrayLen<2: return array
        for i in range(arrayLen):
            for j in range(i):
                if array[j]>=array[i]:
                    tmp=array[j:i]
                    array[j]=array[i]
                    array[j+1:i+1]=tmp

    @snoop()
    def MergeSort(self,array:List, L:int, R:int):
        if len(array)<2:
            return array
        # mid=L+int(round((R-L)/2+0.01))
        mid = L + int((R - L) / 2 )
        mergeLeft=self.MergeSort(array[L:mid],0,mid-L)
        mergeRight=self.MergeSort(array[mid:R],0,R-mid)
        return self.Merge(mergeLeft,mergeRight)

    def Merge(self,array1:List,array2:List):
        help=[]
        while array1 and array2:
            if array1[-1]>=array2[-1]:
                help.append(array1.pop())
            else:
                help.append(array2.pop())
        help.extend(array1[::-1])
        help.extend(array2[::-1])
        return help[::-1]

    def Swap(self,array:List,i:int,j:int):
        tmp=array[i]
        array[i]=array[j]
        array[j]=tmp

class quickSort:
    @snoop()
    def quickSortBasic(self,arr,L,R):
        '''基于普通版本荷兰国旗改进得快速排序算法,arr=[1,5,2,3],L=0,R=4
        L:待排序子区间的左边界
        R:待排序子区间的右边界
        '''
        if L<R:
            self.sweep(arr,R,random.randint(L,R-1)) #加上这一行为随机快速排序，
            # 随机选择一个数和最后的数进行交换之后再进行排序
            mid= self.solutionBasic(arr, L, R)  #找出边界所在位置
            self.quickSortBasic(arr,L,mid) #不用再对mid位置上进行排序
            self.quickSortBasic(arr,mid+1,R)

    def quickSortPro(self,arr,L,R):
        '''基于改进版本荷兰国旗改进得快速排序算法,arr=[1,5,2,3],L=0,R=4
        L:待排序子区间的左边界
        R:待排序子区间的右边界
        '''
        if L<R:
            self.sweep(arr,R,random.randint(L,R-1)) #加上这一行为随机快速排序，
            # 随机选择一个数和最后的数进行交换之后再进行排序
            mid=self.solutionPro(arr,L,R)
            self.quickSortPro(arr,L,mid[0])
            self.quickSortPro(arr,mid[1]+1,R)

    def solutionBasic(self,arr,L,R):
        '''
        :param arr: 待排序的数组,arr=[1,5,2,3],L=0,R=4
        :param L: 待排序的左边界
        :param R: 待排序的右边界
        :return: 中间分界线的位置
        '''

        num=arr[R-1] # 比较数
        P=L
        L-=1
        for index in range(len(arr[L+1:R])):
            if arr[P]<=num:
                self.sweep(arr,L+1,P)
                L+=1
            P+=1
        return L

    def solutionPro(self,arr,L,R)->List[int]:
        '''
        解决荷兰国旗问题，小的放左边，等于的放中间，大于的放右边
        :param arr: 待排序数组
        :param L: 待排序左边界
        :param R: 待排序右边界
        :return: 等于区间的边界
        '''
        P=L
        L-=1
        num=arr[R-1]
        while P<R:
            if arr[P]<num:
                self.sweep(arr,P,L+1)
                P+=1
                L+=1
            elif arr[P]>num:
                self.sweep(arr,R-1,P)
                R-=1
            else:
                P+=1
        return [L+1,R-1]

    def sweep(self,arr,i,j):
        tmp = arr[i]
        arr[i] = arr[j]
        arr[j] = tmp

class HeapSort:

    def heapBuild(self,arr,indexRange=None):
        '''建立大根堆的过程,在arr[:index]范围上构建大根堆'''
        if indexRange==None: indexRange=len(arr)
        for i in range(indexRange):
            index=i
            while arr[index] > arr[int((index - 1) / 2)]:  # 当前节点的值大于父节点的值
                self.swap(arr, index, int((index - 1) / 2))
                index = int((index - 1) / 2)
        return arr

    def swap(self, arr, i, j):
        tmp = arr[i]
        arr[i] = arr[j]
        arr[j] = tmp

    def heapify(self,arr: List, index: int, heapSize: int):
        '''
        将大根堆上某节点的值变小，将修改的节点往下沉，直到不能再修改为止
        在arr[0],arr[1],arr[2]....arr[heapSize-1]上使用heapify
        :param arr: 数组
        :param index: 修改的节点
        :param heapSize: 构建的大根堆在arr当中的长度，heapSize<=len(arr)-1, 常见的为len(arr)
        :return:
        '''
        if heapSize>len(arr): raise ValueError
        leftNode=index*2+1 # 左孩子节点
        rightNode=leftNode+1 # 右孩子节点
        while leftNode<heapSize and rightNode<heapSize:
            if arr[index]>=arr[leftNode] and arr[rightNode]:
                break # 无需下沉
            largeIndex=leftNode if max(arr[leftNode],arr[rightNode])==arr[leftNode] else rightNode
            self.swap(arr,largeIndex,index) # 和孩子节点中值最大的位置进行交换
            index=largeIndex
            leftNode = index * 2 + 1  # 左孩子节点
            rightNode = leftNode + 1  # 右孩子节点
        return arr

    def heapSort(self,arr):
        for i in range(len(arr),0,-1): #1,2,...,len(arr),heapify必须是在至少两个元素的数组上才能使用
            arr=self.heapBuild(arr,indexRange=i) #构建大根堆
            self.swap(arr,i-1,0) # 交换堆顶和堆尾元素，此时堆尾元素一定是当前堆的最大值
            arr=self.heapify(arr,0,i-1) # 在0~i-1范围上使用heapify调整堆结构，使得堆顶再次是最大值
        return arr




h=HeapSort()
arr=[0,4,6,1,-3,5,9,8,7,10,21,5,6,3,2]
h.heapSort(arr)