使用Python实现五大排序算法

最新推荐文章于 2020-12-06 15:02:15 发布

原创最新推荐文章于 2020-12-06 15:02:15 发布 · 350 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Python #数据结构 #排序算法

本文介绍了Python中实现的五种排序算法：选择排序、冒泡排序、插入排序、分割排序（快速排序的一种）和合并排序。这些排序算法从简单到复杂，包括基本排序策略和分而治之的策略，帮助理解排序原理并可用于实际编程应用。

在数据结构中，对数据的排序是基础，在一些面试中也有会问到。基本排序算法有选择排序、冒泡排序和插入排序，这三种排序算法是最简单的排序算法，平均复杂度都在 $o(n^{^{2}})$ 。为了使用更小的复杂度对数据进行排序，有些聪明的人利用分而治之的思想设计了分割排序和组合排序，他们的复杂度为 $o(nlog_{_{2}}n)$ 。下面依次介绍这几种排序算法和程序。

1、选择排序

选择排序是最简单的排序策略，就是搜索整个列表，找到最小值的位置。如果该位置不是列表的第1个位置，算法就会交换两个位置的项。然后，再依次计算第二个最小值的位置、第三个最小值的位置，等等。

def seletSort(self):
        i = 0
        sortList = self.sortList
        while i<len(sortList)-1:
            minIndex = i
            j = i+1
            while j<len(sortList):
                if sortList[minIndex]>sortList[j]:
                    minIndex = j
                j += 1
            if minIndex != i:
                self.swap(sortList,i,minIndex)
            i += 1
        return sortList

2、冒泡排序

冒泡排序也是比较容易理解的算法。其策略是从列表的开头处开始，依次比较一对数据项，直到移动到列表的末尾。当成对的两项之间的顺序不正确的时候，算法就交换其位置。此算法为了减少不必要的运算，当遍历完一遍如果列表的排序没有改变说明已经完成排序，会跳出循环。

def bubleSort(self):
        sortList = self.sortList
        n = len(sortList)
        while n > 1:
            i = 0
            swapInit = False
            while i < len(sortList)-1:
                if sortList[i]>sortList[i+1]:
                    self.swap(sortList,i,i+1)
                    swapInit = True
                i +=1
            if not(swapInit):
                break
            n -=1
        return sortList

3、插入排序

插入排序是一种不同方式的排序策略。首先将指针指向列表的第二项，与第一项做比较，如果第二项小于第一项，将第一项后移，然后将第二项插入第一项。然后将指针后移，目前指针前面的项均为排序好的，所以如果指针上一项小于指针项，指针后移，如果大于的话，指针上一项后移，然后再与其上一项比较，直到找到不小于的项，插入指针项。这么说起来有点乱，结合代码看好了。

    def insertionSort(self):
        sortList = self.sortList
        i = 1
        while i < len(sortList):
            j = i-1
            initTemp = sortList[i]
            while j >= 0:
                if initTemp < sortList[j]:
                    sortList[j+1] = sortList[j]
                    j -= 1
                else:
                    break
            sortList[j+1] = initTemp
            i += 1
        return sortList

4、分割排序

分割排序属于快速排序算法，快速排序的主要思想为分而治之。分割排序是先在序列中找到一个中间项，将小于中间项的项放在左边，大于中间项的项放在右边。依次对子序列进行分割直到每个子序列只包含一项位置。

    def segmentation(self, List):
        sortList = List
        datumPoint = int(len(sortList) / 2)
        maxIndex = len(sortList) - 1
        self.swap(sortList, datumPoint, maxIndex)
        borderIndex = 0
        sortList.insert(borderIndex,':')
        maxIndex += 1
        while 1:
            i = borderIndex + 1
            haveLitte = False
            while i < maxIndex:
                if sortList[i] < sortList[maxIndex]:
                    self.swap(sortList, i, (borderIndex + 1))
                    self.swap(sortList, borderIndex, (borderIndex + 1))
                    borderIndex += 1
                    haveLitte = True
                    break
                i += 1
            if not(haveLitte):
                self.swap(sortList,(borderIndex+1),maxIndex)
                break
        segmenList_1 = sortList[0 : borderIndex]
        segmenList_2 = sortList[borderIndex+1 : maxIndex+1]
        return segmenList_1 ,segmenList_2

    def segmentationSort(self):
        sortList = self.sortList
        List = [sortList]
        while 1:
            haveBigerOne = False
            lastList = []
            for element in List:
                if len(element) > 1:
                    haveBigerOne = True
                    segmenList_1, segmenList_2 = self.segmentation(element)
                    if len(segmenList_1) > 0:
                        lastList.append(segmenList_1)
                    if len(segmenList_2) > 0:
                        lastList.append(segmenList_2)
                else:
                    lastList.append(element)
            if not(haveBigerOne):
                break
            else:
                List = lastList
        return lastList

5、合并排序

合并排序是先将序列进行分割，形成单个项，然后对项进行两两组合排序。

    def splitList(self):
        sortList = self.sortList
        List = [sortList]
        while 1:
            split = []
            haveNotOne = False
            for subList in List:
                elementNumber = len(subList)
                if elementNumber > 1:
                    subList_1 = subList[0 : int(elementNumber / 2)]
                    subList_2 = subList[int(elementNumber / 2) : elementNumber]
                    split.append(subList_1)
                    split.append(subList_2)
                    haveNotOne = True
                else:
                    split.append(subList)
            if not(haveNotOne):
                break
            else:
                List = split
        return split

    def mergeSort(self,split):
        while 1:
            subListNumber = int(len(split) / 2)
            tempList = []
            for index in range(subListNumber):
                subTempList = []
                subList_1 = split[index * 2]
                subList_2 = split[index * 2 + 1]
                pointer_1 = 0
                pointer_2 = 0
                while (pointer_1 < len(subList_1)) and (pointer_2 < len(subList_2)):
                    if subList_1[pointer_1] < subList_2[pointer_2]:
                        subTempList.append(subList_1[pointer_1])
                        pointer_1 += 1
                    else:
                        subTempList.append(subList_2[pointer_2])
                        pointer_2 += 1
                    if pointer_1 >= len(subList_1):
                        subTempList.extend(subList_2[pointer_2 : len(subList_2)])
                    elif pointer_2 >= len(subList_2):
                        subTempList.extend(subList_1[pointer_1 : len(subList_1)])  
                tempList.append(subTempList)
            if subListNumber == 1:
                break
            else:
                split = tempList
        lastList = tempList[0]
        return lastList

以上给出的是各个排序算法的子程序，下面给出所有程序，其中包括排序类和主函数：


class ListSort:
    def __init__(self,sortList):
        self.sortList = sortList
        
    def swap(self,lyst,minIndex,iIndex):
        minNum = lyst[minIndex]
        lyst[minIndex] = lyst[iIndex]
        lyst[iIndex] = minNum
    
    def seletSort(self):
        i = 0
        sortList = self.sortList
        while i<len(sortList)-1:
            minIndex = i
            j = i+1
            while j<len(sortList):
                if sortList[minIndex]>sortList[j]:
                    minIndex = j
                j += 1
            if minIndex != i:
                self.swap(sortList,i,minIndex)
            i += 1
        return sortList
    
    def bubleSort(self):
        sortList = self.sortList
        n = len(sortList)
        while n > 1:
            i = 0
            swapInit = False
            while i < len(sortList)-1:
                if sortList[i]>sortList[i+1]:
                    self.swap(sortList,i,i+1)
                    swapInit = True
                i +=1
            if not(swapInit):
                break
            n -=1
        return sortList
    
    def insertionSort(self):
        sortList = self.sortList
        i = 1
        while i < len(sortList):
            j = i-1
            initTemp = sortList[i]
            while j >= 0:
                if initTemp < sortList[j]:
                    sortList[j+1] = sortList[j]
                    j -= 1
                else:
                    break
            sortList[j+1] = initTemp
            i += 1
        return sortList
    
    def segmentation(self, List):
        sortList = List
        datumPoint = int(len(sortList) / 2)
        maxIndex = len(sortList) - 1
        self.swap(sortList, datumPoint, maxIndex)
        borderIndex = 0
        sortList.insert(borderIndex,':')
        maxIndex += 1
        while 1:
            i = borderIndex + 1
            haveLitte = False
            while i < maxIndex:
                if sortList[i] < sortList[maxIndex]:
                    self.swap(sortList, i, (borderIndex + 1))
                    self.swap(sortList, borderIndex, (borderIndex + 1))
                    borderIndex += 1
                    haveLitte = True
                    break
                i += 1
            if not(haveLitte):
                self.swap(sortList,(borderIndex+1),maxIndex)
                break
        segmenList_1 = sortList[0 : borderIndex]
        segmenList_2 = sortList[borderIndex+1 : maxIndex+1]
        return segmenList_1 ,segmenList_2
    
    def segmentationSort(self):
        sortList = self.sortList
        List = [sortList]
        while 1:
            haveBigerOne = False
            lastList = []
            for element in List:
                if len(element) > 1:
                    haveBigerOne = True
                    segmenList_1, segmenList_2 = self.segmentation(element)
                    if len(segmenList_1) > 0:
                        lastList.append(segmenList_1)
                    if len(segmenList_2) > 0:
                        lastList.append(segmenList_2)
                else:
                    lastList.append(element)
            if not(haveBigerOne):
                break
            else:
                List = lastList
        return lastList
    
    def splitList(self):
        sortList = self.sortList
        List = [sortList]
        while 1:
            split = []
            haveNotOne = False
            for subList in List:
                elementNumber = len(subList)
                if elementNumber > 1:
                    subList_1 = subList[0 : int(elementNumber / 2)]
                    subList_2 = subList[int(elementNumber / 2) : elementNumber]
                    split.append(subList_1)
                    split.append(subList_2)
                    haveNotOne = True
                else:
                    split.append(subList)
            if not(haveNotOne):
                break
            else:
                List = split
        return split
         
    def mergeSort(self,split):
        while 1:
            subListNumber = int(len(split) / 2)
            tempList = []
            for index in range(subListNumber):
                subTempList = []
                subList_1 = split[index * 2]
                subList_2 = split[index * 2 + 1]
                pointer_1 = 0
                pointer_2 = 0
                while (pointer_1 < len(subList_1)) and (pointer_2 < len(subList_2)):
                    if subList_1[pointer_1] < subList_2[pointer_2]:
                        subTempList.append(subList_1[pointer_1])
                        pointer_1 += 1
                    else:
                        subTempList.append(subList_2[pointer_2])
                        pointer_2 += 1
                    if pointer_1 >= len(subList_1):
                        subTempList.extend(subList_2[pointer_2 : len(subList_2)])
                    elif pointer_2 >= len(subList_2):
                        subTempList.extend(subList_1[pointer_1 : len(subList_1)])  
                tempList.append(subTempList)
            if subListNumber == 1:
                break
            else:
                split = tempList
        lastList = tempList[0]
        return lastList
                    
if __name__ == '__main__':
    sortList = [12,17,18,14,11,15,13,16]
    sort = ListSort(sortList)
    splitList = sort.splitList()
    lastList = sort.mergeSort(splitList)
    print(lastList)