python之十大排序算法

　　　　　　　　　　排序算法　　　　　　　　

排序算法分为内排和外排。

内部排序:数据记录在内存中进行排序。

外部排序:因排序的数据量很大，一次不能容纳全部的排序记录在排序的过程中需要访问外存。

内部排序算法：插入排序，希尔排序，选择排序，冒泡排序，归并排序，快速排序，堆排序，基数排序

1.冒泡排序

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

2.选择排序(数据规模尽量小)

步骤：

1. 首先在未排序序列中找到最小或最大元素，存放在排序序列的起始位置
2. 从剩下的未排序元素中继续寻找最大或最小元素，放到已排序序列的末尾。
3. 重复2>直到全部排完为止即可。

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

3.插入排序

步骤:

1. 将第一待排序序列第一个元素看做一个有序序列，把第二个至最后一个元素看作是未排序序列。
2. 从头到尾依次扫描未排序序列，将扫描到的每一个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等，则就爱那个带插入元素插入到相等元素的后面。

def insertSort(arr):
    for i in range(1, len(arr)):
        preIndex = i - 1  # 0
        current = arr[i]  # arr[1]
        while arr[preIndex] > current:
            arr[preIndex + 1] = arr[preIndex]
            preIndex -= 1
            arr[preIndex + 1] = current
    return arr

arr=[9,5,3,7,18,2,5,2]
print(insertSort(arr))

4.希尔排序(递减增量排序算法，不稳定，高效)

　　先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个人序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。

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

5.归并排序（需要额外的内存空间）

　　建立在归并操作上的一种有效排序算法。采用分而治之法的典型的应用。
　　归并排序的实现有两种方法：自上而下的递归，自下而上的迭代.

def mergeSort(arr):
    import math
    if (len(arr)) < 2:
        return arr
    middle = math.floor(len(arr) / 2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))


def merge(left, right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0))
    return result

6.快速排序（用于处理大数据最快的排序算法之一）

快速排序使用分治法策略来把一个串行分为两个子串行。
步骤:

1. 在数列中挑出一个元素，称为基准
2. 重新排序数列，所有元素比基准值小的摆放在基准值的前面，反之放在之后（相同可任意到一边），在这个分区退出之后，该基准就处于数列的中间位置，称此过程为分区操作。
3. 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

def quickSort(arr, lef=None):
    left = 0 if not isinstance(left, (int, float)) else left
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex - 1)
        quickSort(arr, partitionIndex + 1, right)
    return arr


def partition(arr, left, right):
    pivot = left
    index = pivot + 1
    i = index
    while i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index += 1
        i += 1
        swap(arr, pivot, index - 1)
        return index - 1


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

7.堆排序

　　利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质，：即子结点的键值或索引总是小于（或大于）它的父节点。
　　可认为是一种利用堆的概念来排序的选择排序。分两种方法：

1>大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列。
2>小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序

算法步骤：

1.创建一个堆H[0……n-1];
2.把堆首(最大值)和堆尾互换；
3.把对的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置；
4.重复2，直到堆的尺寸为1；

def buildMaxHeap(arr):
    import math
    for i in range(math.floor(len(arr) / 2), -1, -1):
        heapify(arr, i)


def heapify(arr, i):
    left = 2 * i + 1
    right = 2 * i + 2
    largest = i
    if left < arrLen and arr[left] > arr[largest]:
        largest = left
    if right < arrLen and arr[right] > arr[largest]:
        largest = right

    if largest != i:
        swap(arr, i, largest)
        heapify(arr, largest)


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


def heapSort(arr):
    global arrLen
    arrLen = len(arr)
    buildMaxHeap(arr)
    for i in range(len(arr) - 1, 0, -1):
        swap(arr, 0, i)
        arrLen -= 1
        heapify(arr, 0)
    return arr

8.计数排序

　　核心在于将输入的的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，基数排序要求输入的数据必须是有确定范围的整数。

def countingSort(arr,maxValue):
    bucketLen = maxValue + 1
    bucket = [0] * bucketLen
    sortedIndex = 0
    arrLen = len(arr)
    for i in range(arrLen):
        if not bucket[arr[i]]:
            bucket[arr[i]] = 0
            bucket[arr[i]] += 1
            for j in range(bucketLen):
                while bucket[j] > 0:
                    arr[sortedIndex] = j
                    sortedIndex += 1
                    bucket[j] -= 1
    return arr

9.桶排序

计数排序升级版，他利用了函数映射关系，高效与映射函数的确定有关，为了使其高效，需做到两点：

1>在额外空间充足的情况下，尽量增大桶的数量
2>使用的映射函数能够将输入的N个数据均匀分配到k个桶里。

何时最快：当输入数据可以均匀分配到每一个桶里。
何时最慢：当输入的数据被分配到了同一个桶里。

def bucket_sort(s):
    """桶排序"""
    min_num = min(s)
    max_num = max(s)
    # 桶的大小
    bucket_range = (max_num - min_num) / len(s)
    # 桶数组
    count_list = [[] for i in range(len(s) + 1)]
    # 向桶数组填数
    for i in s:
        count_list[int((i - min_num) // bucket_range)].append(i)
    s.clear()
    # 回填，这里桶内部排序直接调用了sorted
    for i in count_list:
        for j in sorted(i):
            s.append(j)
            
            
if __name__ == __main__:
    a = [3.2, 6, 8, 4, 2, 6, 7, 3]
    bucket_sort(a)
    print(a)  # [2, 3, 3.2, 4, 6, 6, 7, 8]

基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法：
这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：
基数排序：根据键值的每位数字来分配桶；
计数排序：每个桶只存储单一键值；
桶排序：每个桶存储一定范围的数值；

10.基数排序

基数排序是一种非比较型整数排序算法，原理：将整数按位数切割成不同的数字，然后按每个位数分别比较，由于整数可以表达字符串和特定格式的浮点数，所以基数排序也不是只能使用于整数。

def RadixSort(list):
    i = 0  # 初始为个位排序
    n = 1  # 最小的位数置为1（包含0）
    max_num = max(list)  # 得到带排序数组中最大数
    while max_num > 10 ** n:  # 得到最大数是几位数
        n += 1
    while i < n:
        bucket = {}  # 用字典构建桶
        for x in range(10):
            bucket.setdefault(x, [])  # 将每个桶置空
        for x in list:  # 对每一位进行排序
            radix = int((x / (10 ** i)) % 10)  # 得到每位的基数
            bucket[radix].append(x)  # 将对应的数组元素加入到相 #应位基数的桶中
        j = 0
        for k in range(10):
            if len(bucket[k]) != 0:  # 若桶不为空
                for y in bucket[k]:  # 将该桶中每个元素
                    list[j] = y  # 放回到数组中
                    j += 1
        i += 1
    return list