几种常见算法（基于Python）

1.冒泡排序

冒泡排序(dubble sort)：它重复地遍历要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序算法的运作如下：

1.比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

实现：

def bubble_sort(alist):
    for j in range(len(alist)-1,0,-1):
        # j表示每次遍历需要比较的次数，是逐渐减小的
        for i in range(j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]

li = [54,26,93,17,77,31,44,55,20]
bubble_sort(li)

2.选择排序

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

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

def select_sort(aList):
    for i in range(len(aList)):
        max_index = i     # 当前值为最大
        for j in range(i, len(aList)):
            if aList[j] > aList[max_index]:
                aList[j], aList[max_index] = aList[max_index], aList[j]
    return aList

插入排序

插入排序(Insertion Sort)：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

def insert_sort(aList):
    for i in range(len(aList)):
        for j in range(i, len(aList)):
            if aList[i] > aList[j]:
                aList[i:j + 1] = [aList[j]] + aList[i:j]
    return aList

希尔排序

希尔排序(Shell Sort)：将数组列在一个表中并对列分别进行插入排序，重复这个过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

def shell_sort(aList):
    gap = len(aList) // 2
    while gap > 0:
        for i in range(gap, len(aList)):
            while i >= gap and aList[i-gap] > aList[i]:
                aList[i-gap], aList[i] = aList[i], aList[i-gap]
                i -= gap
        gap //= 2
    return aList

快速排序

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

步骤为：

从数列中挑出一个元素，称为"基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

def quick_sort(aList, start, end):
    if start >= end:
        return
    i, j = start, end
    base = aList[i]    # 设置基准数字
    while i < j:
        while (i < j) and (aList[j] >= base):
            j -= 1
        aList[i] = aList[j]
        while (i < j) and (aList[i] <= base):
            i += 1
        aList[j] = aList[i]
    aList[i] = base
    quick_sort(aList, start, i - 1)
    quick_sort(aList, i + 1, end)
    return aList

归并排序

归并排序(merge sort):采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

def merge_sort(aList):
    if len(aList) <= 1:
        return aList
    num = len(aList) // 2
    left = merge_sort(aList[:num])
    right = merge_sort(aList[num:])
    return merge(left, right)


def merge(left, right):
    res = []
    l, r = 0, 0
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            res.append(left[l])
            l += 1
        else:
            res.append(right[r])
            r += 1
    res += left[l:]
    res += right[r:]
    return res

算法比较