常用排序算法的实现 （Python实现）

 摘要：本文主要采用Python语言实现冒泡排序、插入排序、选择排序、归并排序、快速排序、堆排序、桶排序。

# -*- coding: utf-8 -*-
"""
@project :   Python_
@author  :   'Zheng Guoliang'
@File    :   Class1.py
@Time    :   2018/12/23 13:26

"""

import  random
import  copy


class My_Sort(object):
    # 冒泡排序  时间复杂度O(N^2) 空间复杂度0(1) 稳定排序
    def Bubble_Sort(self,nums):
        if len(nums)<2:
            return
        flag=True
        i=0
        while i<len(nums) and flag:
            flag=False
            for j in range(len(nums)-1,i,-1):
                if nums[j]<nums[j-1]:
                    flag=True
                    nums[j],nums[j-1]=nums[j-1],nums[j]

    # 选择排序  时间复杂度O(N^2) 空间复杂度0(1) 不稳定排序
    def Choice_Sort(self,nums):
        if len(nums)<2:
            return
        for i in range(0,len(nums)):
            temp=i
            for j in range(i+1,len(nums)):
                if nums[temp]>nums[j]:
                    temp=j
            nums[temp],nums[i]=nums[i],nums[temp]

    # 插入排序  时间复杂度O(N^2) 空间复杂度0(1) 稳定排序
    def Insert_Sort(self,nums):
        if len(nums)<2:
            return
        for i in range(1,len(nums)):
            for j in range(i-1,-1,-1):
                if nums[j+1]>=nums[j]:
                    break
                nums[j+1],nums[j]=nums[j],nums[j+1]

    # 归并排序  时间复杂度O(NlogN) 空间复杂度0(N) 稳定排序
    def Merge_Sort(self,nums):
        if len(nums)<2:
            return
        self.Merge_Sort1(nums,0,len(nums)-1)

    def Merge_Sort1(self,nums,L,R):
        if L>=R:
            return
        mid=L+((R-L)>>1)
        self.Merge_Sort1(nums,L,mid)
        self.Merge_Sort1(nums,mid+1,R)
        self.Merges(nums,L,mid,R)
    def Merges(self,nums,L,mid,R):
        help=[]
        i=L
        j=mid+1
        while i<=mid and j<=R:
            if nums[i]<nums[j]:
                help.append(nums[i])
                i+=1
            else:
                help.append(nums[j])
                j+=1
        while i<=mid:
            help.append(nums[i])
            i+=1
        while j<=R:
            help.append(nums[j])
            j+=1
        for i in range(0,R-L+1):
            nums[i+L]=help[i]

    # 快速排序  时间复杂度O(NlogN) 空间复杂度0(logN)  不稳定排序
    def Partion_Sort(self,nums):
        if len(nums)<2:
            return
        self.Partion_Sort1(nums,0,len(nums)-1)

    def Partion_Sort1(self,nums,L,R):
        if L<R:
            temp=random.randint(L,R)
            nums[R],nums[temp]=nums[temp],nums[R]
            res=self.Partions(nums,L,R)
            self.Partion_Sort1(nums,L,res[0]-1)
            self.Partion_Sort1(nums,res[1]+1,R)
    def Partions(self,nums,L,R):
        less=L-1
        more=R+1
        temp=nums[R]
        while L<more:
            if nums[L]<temp:
                less+=1
                nums[L],nums[less]=nums[less],nums[L]
                L+=1
            elif nums[L]==temp:
                L+=1
            else:
                more-=1
                nums[L],nums[more]=nums[more],nums[L]
        list=[]
        list.append(less+1)
        list.append(more-1)
        return list

    # 堆排序  时间复杂度O(NlogN) 空间复杂度0(1) 稳定排序
    def Heap_Sort(self,nums):
        if len(nums)<2:
            return ;
        for i in range(1,len(nums)):
            self.Heap_Insert(nums,i)
        length=len(nums)-1
        nums[0],nums[length]=nums[length],nums[0]
        while length>0:
            self.Heapfy(nums,0,length)
            length-=1
            nums[0],nums[length]=nums[length],nums[0]

    def Heap_Insert(self,nums,index):
        while nums[index]>nums[int((index-1)/2)]:
            nums[index],nums[int((index-1)/2)]=nums[int((index-1)/2)],nums[index]
            index=int((index-1)/2)

    def Heapfy(self,nums,index,Size):
        left=2*index+1
        while left<Size:
            lagest=left+1 if left+1<Size and nums[left+1]>nums[left] else left
            lagest=lagest if nums[lagest]>nums[index] else index
            if lagest == index:
                return
            nums[index],nums[lagest]=nums[lagest],nums[index]
            index=lagest
            left=2*index+1

    # 桶排序  时间复杂度O(N) 空间复杂度0(N) 不稳定排序
    def  Bucket_Sort(self,nums):
        if len(nums)<2:
            return
        MAX=nums[0]
        MIN=nums[0]
        for i in range(1,len(nums)):
            MAX=max(MAX,nums[i])
            MIN=min(MIN,nums[i])
        if MAX==MIN:
            return
        help=[0 for i in range(0,MAX-MIN+1)]
        for i in range(0,len(nums)):
            help[nums[i]-MIN]+=1
        index=0;
        for i in range(0,MAX-MIN+1):
            while help[i]>0:
                nums[index]=i+MIN
                index+=1
                help[i]-=1


def generate_data(n,L,R):
    list=[]
    for i in range(n):
        a=random.randint(L,R)
        list.append(a)
        #print(a,end=" ")
    #print(end="\n")
    return list

def Print_data(nums):
    for i in nums:
        print(i,end=" ")

if __name__=='__main__':
    zgl=My_Sort()
    flag=True
    for i in range(1,2000):
        if not flag:
            break
        nums = generate_data(100, -100, 100)
        nums1 = copy.deepcopy(nums)
        zgl.Merge_Sort(nums)
        nums1.sort()
        for j in range(0,len(nums)):
            if nums[j]!=nums1[j]:
                print("error")
                flag=False
                break
    if not flag:
         print("error")
    else:
        print("ok")

    #Print_data(nums)