经典排序算法

1、冒泡排序：

      算法描述：

• 比较相邻元素，如果前序元素大于（或小于，看需求而定）后序元素，就交换两个元素的位置
• 对每对相邻元素重复上面工作，从第一对到最后一对，这样，在经过一轮比较厚，最后一个元素就是最大（或最小）
• 对所有元素重复以上工作，除了已经确定了的前n大（或小）的元素，直到完成排序

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

2、选择排序

     算法描述：

• 初始状态：有序区为空，无序区为待排序所有元素
• 遍历无序区，找出最大（或最小）元素，将其和无序区第一个元素交换，有序区元素个数增加，无序区减少 
• 重复上面工作n-1次，排序完成

def selectionSort(arr):
    for i in range(len(arr)):
        tagIndex = i
        for j in range(i,len(arr)):
            if arr[j] < tag:
                tagIndex = j
        tmpValue = arr[i]
        arr[i] = arr[tagIndex]
        arr[j] = tmpValue
    return arr

3、插入排序

     算法描述：

• 从第一个元素开始，初始认为第一个元素已经排好序
• 取出下一个元素，在已排序的序列中从后向前扫描，如果扫描到的元素大于新元素，继续向前扫描，直到扫描元素小于或等于新元素，将新元素插入扫描元素后，否则，将新元素插入最前端
• 重复上述工作，直至所有元素排序完成 

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

4、快速排序

     算法描述：

• 从所有元素中挑出一个元素作为基准，一般情况选取第一个元素
• 访问序列中所有元素，比较元素跟基准元素的大小，比基准元素大则放置在其后面，比基准元素小则放在其前面，一次遍历过后，基准元素将序列分成一个比他大、一个比他小的两个子序列
• 对两个子序列递归快速排序，直到子序列中最大值等于最小值

def quickSort(arr,start=None,end=None):
    if start == None and end == None:
        left = start = 0
        right = end = len(arr) - 1
    else:
        left = start
        right = end
    if left >= right:
        return
    tag = arr[left]
    while left < right:
        while left < right and arr[right] >= tag:
            right -= 1
        arr[left] = arr[right]
        while left < right and arr[left] <= tag:
            left += 1
        arr[right] = arr[left]
    arr[left] = tag
    quickSort(arr,start,left-1)
    quickSort(arr,left+1,end)
    return arr

5、希尔排序

     算法描述

• 希尔排序是对插入排序的优化版，又称缩小增量排序（对整个待排序序列进行分组，然后对每一组进行直接插入排序）
• 选择一个增量，和一个缩小增量的方式，有多种选择方式，比如：gap = length/3 + 1，gap = gap - 1；或者gap = length/2，gap = gap / 2。他们的选择和证明事实上是一个数学难题。其余的增量序列还有Hibbard：{1, 3, ..., 2^k-1}，Sedgewick：{1, 5, 19, 41, 109...}该序列中的项或者是9*4^i - 9*2^i + 1或者是4^i - 3*2^i + 1。使用不同的增量对希尔排序的时间复杂度的改进将不一样，甚至一点小的改变都将引起算法性能剧烈的改变。
• 按增量序列对待排序序列进行分组，排序，直到增量为1，进行最后一次插入排序。

def shellSort(arr):
    length = len(arr)
    gap = length / 2
    while gap > 0:
        i = gap
        while i < length:
            temp = arr[i]
            preIndex = i - gap
            while preIndex >= 0 and arr[preIndex] > temp:
                arr[preIndex+gap] = arr[preIndex]
                preIndex -= gap
            arr[preIndex+gap] = temp
            i += 1
        gap = int(gap/2)
    return arr
                

6、归并排序

     算法描述：

• 把待排序序列分成长度为n/2的两个序列
• 递归地对两个子序列做归并排序，直到所有子序列长度为1
• 把两个排好序的序列合并，返回

def merge(arr1,arr2):
    returnArr = []
    index1 = index2 = 0
    while index1 < len(arr1) or index2 < len(arr2):
        if index1 == len(arr1):
            returnArr.extend(arr2[index2:])
            break
        elif index2 == len(arr2):
            returnArr.extend(arr1[index1:])
            break
        else:
            if arr1[index1] > arr2[index2]:
                returnArr.append(arr2[index2])
                index2 += 1
            else:
                returnArr.append(arr1[index1])
                index1 += 1
    return returnArr

def mergeSort(arr):
    length = len(arr)
    if length == 1:
        return arr
    mid = int(length/2)
    left = arr[:mid]
    right = arr[mid:]
    return merge(mergeSort(left),mergeSort(right))