初学Python——基础篇子Python排序

排序是每个软件工程师和开发人员都需要掌握的技能。不仅要通过编程面试，还要对程序本身有一个全面的理解。不同的排序算法很好地展示了算法设计上如何强烈的影响程序的复杂度、运行速度和效率。
排序有很多种实现方法，比如冒泡排序、选择排序、归并排序、希尔排序、快速排序、插入排序、堆排序、基数排序等，今天就给大家介绍使用Python语言实现的其中4个排序算法。

import Sort

if __name__ == '__main__':
    try:
        arr =  [1,9,5,10,88,36,65,30];
        print('冒泡排序前：',arr)
        bubbleSortObj = Sort.sort(arr)
        bubbleSortObj.bubbleSort()
        print('冒泡排序后：',arr)

        print('选择排序前：',arr)
        selectionSortObj = Sort.sort(arr)
        selectionSortObj.selectionSort()
        print('选择排序后：',arr)
    except BaseException as Argument:
        print(Argument)
    except ValueError as Argument:
        print(Argument)

class sort:

    def __init__(self,arr):
        self.arr = arr

    def bubbleSort(self):
        for i in range(1, len(self.arr)):
            for j in range(0, len(self.arr)-i):
                if self.arr[j] > self.arr[j+1]:
                    self.arr[j], self.arr[j + 1] = self.arr[j + 1], self.arr[j]
        return self.arr

    def selectionSort(self):
        for i in range(len(self.arr) - 1):
            # 记录最小数的索引
            minIndex = i
            for j in range(i + 1, len(self.arr)):
                if self.arr[j] < self.arr[minIndex]:
                    minIndex = j
            # i 不是最小数时，将 i 和最小数进行交换
            if i != minIndex:
                self.arr[i], self.arr[minIndex] = self.arr[minIndex], self.arr[i]
        return self.arr

    def insertionSort(self):
        for i in range(len(self.arr)):
            preIndex = i-1
            current = self.arr[i]
            while preIndex >= 0 and self.arr[preIndex] > current:
                self.arr[preIndex+1] = self.arr[preIndex]
                preIndex-=1
            self.arr[preIndex+1] = current
        return self.arr


    def shellSort(self):
        import math
        gap = 1
        while (gap < len(self.arr) / 3):
            gap = gap * 3 + 1
        while gap > 0:
            for i in range(gap, len(self.arr)):
                temp = self.arr[i]
                j = i - gap
                while j >= 0 and self.arr[j] > temp:
                    self.arr[j + gap] = self.arr[j]
                    j -= gap
                self.arr[j + gap] = temp
            gap = math.floor(gap / 3)
        return self.arr

冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法步骤

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
   

选择排序

选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

算法步骤

1. 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 重复第二步，直到所有元素均排序完毕。
   

插入排序

插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法 [1] 。
插入排序的基本思想是：将数组的第一个数认为是有序数组，从后往前（从前往后）扫描该有序数组，把数组中其余n-1个数，根据数值的大小，插入到有序数组中，直至数组中的所有数有序排列为止。这样的话，n个元素需要进行n-1趟排序！！！

举个例子：4个数字4,6,7,5进行从大到小的排序。前插排序法具体过程如下：
把第一个数4插入到空的有序数组中的第一个位置上，得到新数字序列4；

第一趟：从后往前扫描有序数组，将第二个数字6和有序数组中的4进行比较，6大于4，此时将4后移一个位置。此时已经扫描完有序数组中的数，将6插入到4的前面（有序数组的第一个位置），得到新数字序列6,4；

第二趟：从后往前扫描有序数组，先将第三个数字7和有序数组中的4进行比较，7大于4，此时将4后移一个位置；再将7和有序数组中的6进行比较，7大于6，此时将6后移一个位置。此时已经扫描完有序数组中的数，将7插入到6的前面（有序数组的第一个位置），得到新数字序列7,6,4；

第三趟：从后往前扫描有序数组，先将第四个数字5和有序数组中的4进行比较，5大于4，此时将4后移一个位置；再将5和有序数组中的6进行比较，5小于6，由于有序数组就按照从大到小排列的，此时直接把5插入到4的前面即可！不需要再和7进行比较！最后，得到新数字序列7,6,5,4；

插入排序的关键点：
1、采用双层循环：时间复杂度也是O（n的平方）
（1）外层循环表示的是排序的趟数，n个数字需要n-1趟，因此，外层循环的次数是n-1次；同时也代表数的位置。
（2）内层循环表示的是每一趟排序的数字。根据插入排序的思想，第i趟排序时，有序数组中的数字就有i个，就需要进行i次比较，因此循环i次。注意采用的是从后往前进行比较。
2、从后往前扫描的时候，如果必须插入的数大于有序数组中当前位置的数，则有序数组中的数和它之后的数均往后移一个位置，否则，把插入的数插入到有序数组中。（稳定排序）

希尔排序（Shell Sort）
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

4.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列个数k，对序列进行k 趟排序；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1
  时，整个序列作为一个表来处理，表长度即为整个序列的长度。