排序大全之冒泡排序及其改进排序

冒泡排序简介：

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

0.冒泡排序

规则

假设数组名为A，长度为n，让整型变量i从0开始，进行以下操作：
1.让j = n - 1，进入第2步。
2.若j == i，进入第4步；否则，进入第3步。
3.若A[j - 1] > A[j]，则交换A[j - 1]与A[j]。j = j - 1，进入第2步。
4.i = i + 1，若i == n - 1，结束排序；否则，进入第1步。

def bubbleSort(A, n):
    for i in range(n):
        for j in range(n - 1, i, -1):
            if A[j - 1] > A[j]:
                t = A[j - 1]; A[j - 1] = A[j]; A[j] = t

1.地精排序

规则

假设数组名为A，长度为n，让整型变量i从1开始，进行以下操作：
1.若i > 0且A[i - 1] > A[i]，则交换A[i - 1]与A[i]并让i后退一步（自减），重复第1步；否则，进入第2步。
2.让i前进一步，进入第3步。
3.若i与n - 1相等，结束排序；否则，回到第1步。

def gnomeSort(A, n):
    i = 1
    while  i < n:
        if i > 0 and A[i - 1] > A[i]:
            t = A[i - 1]; A[i - 1] = A[i]; A[i] = t
            i -= 1
        else:
            i += 1

2.奇偶排序

规则

假设数组名为A，长度为n，让整型变量i从1开始，进行以下操作：
1.依次以0与1为起始点，2为间隔，比较相邻两个元素的大小。若存在大小颠倒，则交换相邻两个元素。进入第2步。
2.若第一步中没有交换，则结束排序；否则，返回第1步。

def odd_even_swap(A, n, begin):
    flag = False
    for i in range(begin + 1, n, 2):
        if A[i - 1] > A[i]:
            flag = True
            t = A[i - 1]; A[i - 1] = A[i]; A[i] = t
    return flag

def odd_evenSort(A, n):
    while odd_even_swap(A, n, 0) or odd_even_swap(A, n, 1):
        continue

3.梳子排序

规则

假设数组名为A，长度为n，让整型变量g从n开始，进行以下操作：
1.g = int(g / 1.3)（即把g变成g除以1.3取整）让i = n - 1，进入第2步（以g为间隔，对数组进行一轮冒泡）。
2.若i == g，进入第4步；否则，进入第3步。
3.若A[i - g] > A[i]，则交换A[i - g]与A[i]。i = i - 1，进入第2步。
4.若次轮冒泡没有产生交换且g == 1，结束排序；否则，进入第1步。

def bubbleSort(a, n, gap):
    flag = False
    for i in range(n - 1, gap - 1, -1):
        if a[i - gap] > a[i]:
            flag = True
            a[i - gap], a[i] = a[i], a[i - gap]
    return flag

def combSort(A, n):
    factor = 1.3
    g = n
    flag = True
    while g > 1 or flag:
        if g > 1:
            g = int(g / factor)
        flag = bubbleSort(A, n, g)

4.快速排序

规则

假设数组名为A，长度为n，进行以下操作：
1.以最右边的数为基数，让i = 左边界 - 1，从左向右遍历数组。若当前数小于基数，则使i = i + 1，然后将当前数与A[i]交换（分割）。遍历完数组，将基数与A[i + 1]交换。进入第2步。
2.将第1步中的i + 1作为中间界线，将数组分割成两份，第一个数组的左右边界为上一次分割的数组的左边界与i，第二个数组的左右边界为i + 2与上一次分割的数组的右边界。将两个数组中满足左边界 < 右边界的进行第1步的分割。

def partition(a, l, r):
    x = a[r]
    i = l - 1
    for j in range(l, r):
        if a[j] <= x:
            i += 1
            t = a[j]; a[j] = a[i]; a[i] = t
    a[r] = a[i + 1]; a[i + 1] = x
    return i + 1

def quickSort(A, left, right):
    if left < right:
        mid = partition(A, left, right)
        quickSort(A, left, mid - 1)
        quickSort(A, mid + 1, right)