排序算法的python实现（持续更新中...）

排序的python实现

时间复杂度排序：
O(1) < O(logn) < O(n)< O(nlogn) < O(n^2)< O(n^2logn) < O(n^3)

list1 = [12,34,1,25,78]

1 .插入排序（insertSort）

将一个数据插入到已经排好的有序数列中，从而得到一个新的有序序列，从而得到一个新的、个数加一的有序数据,适用于少量数据的排序，时间复杂度为O(n^2)。是一个稳定的排序方法

第一次循环 12 34 1 25 78 —-> 12 34 1 25 78
第二次循环 12 34 1 25 78 —-> 1 12 34 25 78
第三次循环 1 12 34 25 78 —-> 1 12 25 34 78
第四次循环 1 12 25 34 78 —-> 1 12 25 34 78

def insertSort(lists):
    count = len(lists)   #得到列表长度
    for i in range(1,count):   #循环count-1次
        key = lists[i]       #每次取出一个值，默认为第二个值
        j = i - 1       #求取出的值的前一个值的索引
        while j >=0:     #当列表中存在值时
            if lists[j] > key:  #判断取出的值是否比列表中前一个值小
                lists[j+1] = lists[j]  #是的直接交换，
                lists[j] = key
            j -=1     #不是的话，列表顺序不用改变，不管是不是，都要求出前一个值的索引，进行下一次比较
    return lists
insertSort(list1)
print(insertSort(list1))

2 选择排序（selecSort）

基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i+1,…n-1] 中找出其中的最小值，然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值/最小值的子流程，所以形象地称之为选择排序。
时间复杂度和空间复杂度分别为O(n^2)和O(1)。
第一次循环 12 34 1 25 78 —-> 1 34 12 25 78
第二次循环 1 34 12 25 78 —-> 1 12 34 25 78
第三次循环 1 12 34 25 78 —-> 1 12 25 34 78
第四次循环 1 12 25 34 78 —-> 1 12 25 34 78

def selectSort(lists):
    for i in range(len(lists)):   #遍历整个列表
        min = i                   #定义一个变量暂存下标
        for j in range(i + 1, len(lists)):  #遍历数组lists[i]后边的数组
            if lists[min] > lists[j]:       #判断大小
                min = j 
        lists[min],lists[i] = lists[i],lists[min]
    return lists 

print(selectSort(list1))

3,冒泡排序（bubbleSort）

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
时间复杂度O(n^2)，空间复杂度O(1)
第一次循环 12 34 1 25 78 —-> 12 1 25 34 78
第二次循环 12 1 25 34 78 —-> 1 12 25 34 78
第三次循环 1 12 25 34 78 —-> 1 12 25 34 78
第四次循环 1 12 25 34 78 —-> 1 12 25 34 78
当进行两次之后列表顺序已经确定可以设置函数使其跳出比较循环

def bubbleSort(lists):
    for i in range(len(lists)):   #循环遍历列表中的每个元素
        exchange = False       #给定一个变量，检测是否进行交换
        for j in range(len(lists) - i - 1):  #获得相邻的两个元素进行比较
            if lists[j] > lists[j + 1]:
                lists[j], lists[j + 1] = lists[j + 1], lists[j]
                exchange = True
        if not exchange:
            break 
    return lists

4 快速排序（quickSort）
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

def quickSort(lists,left,right):
    if left >= right:
        return lists
    key = lists[left]
    low = left
    high = right
    while left < right:
        while left < right and lists[right] >= key:
            right -=1
        lists[left] = lists[right]
        while left < right and lists[left] <= key:
            left +=1
        lists[right] = lists[left]
    lists[right] = key
    #递归调用
    quickSort(lists, low, left - 1)
    quickSort(lists, left + 1, high)
    return lists