python的常见排序

python内置方法sorted()

sorted(iterable, cmp=None, key=None, reverse=False)
参数说明：
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函数
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>>

#多个参数排序：
>>> from operator import itemgetter    #要用到itemgetter函数
>>> e = [('hi', 'A', 27),('hello', 'C', 90),('yo', 'D', 8)]
>>> sorted(e, key=itemgetter(2))     #以第三列排序
[('yo', 'D', 8), ('hi', 'A', 27), ('hello', 'C', 90)]
>>> sorted(e, key=itemgetter(1,2))   #结合第二和第三列拍，先排第二列
[('hi', 'A', 27), ('hello', 'C', 90), ('yo', 'D', 8)]
>>> 

快速排序其实就是一个递归的过程，取一个数组中的特定值，比这个特定值小的放到左边，大的放到右边。再继续对左右进行该过程

#快速排序是不稳定算法

data = [45, 3, 2, 6, 3, 78, 5, 44, 22, 65, 46]
def quickSort(data, start, end):
    if start>=end:
        return
    record=data[start]
    i=start
    j=end
    while i<j:
        while  data[j]>=record and i<j:
            j=j-1
        data[i] = data[j]
        while data[i]<record and i<j:
            i=i+1
        data[j] = data[i]
    data[i]=record
    quickSort(data,start,j-1)
    quickSort(data,i+1,end)
quickSort(data, 0, len(data) - 1)
print(data)

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，

对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

def insertionSort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
arr = [18,16,12,12, 11, 13, 5, 6]
insertionSort(arr)
print(arr)

选择排序是一种简单直观的排序算法。 它的工作原理如下。首先在未排序序列中找到最小（大）元素， 存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

def Selectionsort(arr):
    for i in range(len(arr)):

        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[min_idx] > arr[j]:
                min_idx = j

        arr[i], arr[min_idx] = arr[min_idx],arr[i]

arr = [18,16,12,12, 11, 13, 5, 6]
Selectionsort(arr)
print(arr)

冒泡排序也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

def bubbleSort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(arr)
print(arr)

归并排序，是创建在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用

分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

分治法:

分割：递归地把当前序列平均分割成两半。

集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

# 合并，相当于是两个升序有序数组合并为一个升序数组，在这里需要借助一个辅助的数组，保存排好序的数组.
def merge(left, right):
    print(left, right)
    tmp = []
    h = j = 0
    while h < len(left) and j < len(right):
        if left[h] < right[j]:
            tmp.append(left[h])
            h += 1
        else:
            tmp.append(right[j])
            j += 1

    if h == len(left):
        for i in right[j:]:
            tmp.append(i)
    else:
        for i in left[h:]:
            tmp.append(i)

    return tmp


# 拆分的时候，直到当前分的段中只剩一个元素
def sort(arr):
    if len(arr) <= 1:
        return arr
    middle = len(arr) // 2
    left = sort(arr[0:middle])
    right = sort(arr[middle:])
    return merge(left, right)


print(sort([20, 32, 1, 45, 21, 98, 34]))