三大经典排序: 冒泡排序，选择排序，快速排序

1.冒泡排序
冒泡排序（Bubble Sort） 最为简单的一种排序，通过重复走完数组的所有元素，通过打擂台的方式两个两个比较，直到没有数可以交换的时候结束这个数，再到下个数，直到整个数组排好顺序。因一个个浮出所以叫冒泡排序。双重循环时间 O(n^2)

算法描述：

1. 比较相邻两个数据如果。第一个比第二个大，就交换两个数
2. 对每一个相邻的数做同样1的工作，这样从开始一队到结尾一队在最后的数就是最大的数。
3. 针对所有元素上面的操作，除了最后一个。
4. 重复1~3步骤，知道顺序完成。

def bubble_sort(arr):
    if not arr or len(arr)<=0:
        return 
    for i in range(0, len(arr)-1):
        for j in range(i+1, len(arr)):
            if arr[i] > arr[j]:
                temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
    return arr 

def bubble_sort(arr):
    if not arr or len(arr)<=0:
        return 
    for i in range(0, len(arr)):
        for j in range(0, len(arr)-i-1):
            if arr[j] > arr[j+1]:
                temp = arr[j]
                arr[j] = arr[j+1]
                arr[j+1] = temp
    return arr 

2.选择排序
选择排序（Select Sort） 是直观的排序，通过确定一个 Key 最大或最小值，再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之。双重循环时间复杂度为 O(n^2)

算法描述：

1. 在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
2. 第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
3. 重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。

def select_sort(arr):
    if not arr or len(arr)<=0:
        return 
    for i in range(0, len(arr)):
        minKey = arr[i]
        for j in range(i+1, len(arr)):
            if minKey > arr[j]:
                temp = arr[j]
                arr[j] = minKey
                minKey = temp
        arr[i] = minKey
    
    return arr 

3.快速排序
快速排序（QuickSort）是排除稳定性因素后最常用的排序。给看官介绍两种使用方法，一种值直接在我文件 stdlib.h 头文件中的 qsort 函数实现是和正常写代码一样的。通过使用qsort（数组名，长度，sizeof（第一个数长度），compInc/comoDec) 进行实现数组的排序。后面的是通过递归调用的形式。

算法描述：

1. 从数列中挑出一个元素作为基准。
2. 重新排列数列，把所有的比基准小的放在基准前面，反之放在后面（一样大可任意一边）完成后基准处在分区的中间位置。
3. 通过递归调用把小于基准元素和大雨基准元素的子序列进行排序。

def get_index(arr, low, high):
    # 获取基准数据，即最左边的数据
    base = arr[low]
    while low<high:
        # 当队尾的元素大于等于基准数据时,向前挪动high指针, 顺序不能错，先从队尾找
        while low<high and arr[high]>=base:
            high -= 1
        # 跳出循环说明arr[high]元素小于base了,需要将其赋值给low
        arr[low] = arr[high]
        
        # 当队首元素小于等于base时,向前挪动low指针
        while low<high and arr[low]<=base:
            low += 1
        # 当队首元素大于base时,需要将其赋值给high 
        arr[high] = arr[low]
        
    # 跳出循环时low和high相等,此时的low或high就是base的正确索引位置
    # 由原理部分可以很清楚的知道low位置的值并不是base,所以需要将base赋值给arr[low]
    arr[low] = base
    
    return low # 返回arr的正确位置

def quick_sort(arr, low, high):
    if low < high:
        # 找寻基准数据的正确索引
        index = get_index(arr, low, high)

        # 进行迭代对index之前和之后的数组进行相同的操作使整个数组变成有序
        quick_sort(arr, 0, index - 1)
        quick_sort(arr, index + 1, high)
    return arr