列表排序问题

# 排序问题
# 问题描述：
# 给定一个序列a1,a2,...,an，将这个序列按照从小到大的顺序重新进行排列
# 1、直接插入排序
# 算法思想：
# 由于a1只有一个元素，认为a1为一个已经排好序的序列，将a2,a3,...an依次插入到前面已排好序的子序列中
def insert_sort(a):
    n = len(a)
    for i in range(1, n):
        if a[i] < a[i - 1]:
            # 顺序查找插入位置
            for j in range(i - 1, -1, -1):
                if a[j] > a[i]:
                    a[j + 1] = a[j]
            a[j + 1] = a[i]
    return a
# 2、折半插入排序
# 算法思想：
# 直接插入在寻找插入位置的时候是按照顺序依次查找的，折半插入则通过使用折半查找的方式来寻找插入位置
def binary_sort(a):
    n = len(a)
    for i in range(1, n):
        # 如果当前元素比有序的子序列的最后一个元素小，则进行插入
        if a[i] < a[i - 1]:
            # 折半查找插入位置
            low, high = 0, i - 1
            while low <= high:
                mid = (low + high) / 2
                if a[mid] > a[i]:
                    high = mid - 1
            for j in range(i - 1, high, -1):
                a[j + 1] = a[j]
            a[high + 1] = a[i]
    return a
# 3、希尔排序
# 算法思想：
# 将待排序的序列分成若干个待排序的序列，对每个子序列分别进行直接插入排序
# 当每个子序列中的元素基本有序时，再对全体序列进行一次直接插入排序
def shell_sort(a):
    n = len(a)
    d = n / 2
    if d >= 1:
        for i in range(d, n):
            if a[i] < a[i - d]:
                for j in range(i - d, -1, -1):
                    if a[j] > a[i]:
                        a[j + d] = a[j]
                a[j + d] = a[i]
            d = d / 2
    return a
# 4、冒泡排序
# 算法思想：
# 从前往后两两比较相邻元素的值，若为逆序，则交换它们，直到序列比较完
def bubble_sort(a):
    n = len(a)
    for i in range(n - 1):
        flag = False
        for j in range(i, n - 1):
            if a[j + 1] > a[j]:
                temp = a[j + 1]
                a[j + 1] = a[j]
                a[j] = temp
                flag = True
            # 如果flag为False，说明本次遍历没有发生交换，序列已经有序
            if not flag:
                return a
    return a
# 5、快速排序
# 算法思想：
# 基于分治法，使用一个元素作为基准，将待排序序列分成两部分，使得左边的序列都小于这个基准元素，右边的序列都大于这个基准元素
def partition(a, low, high):
    pivot = a[low]
    while low < high:
        while low < high and a[high] >= pivot:
            high = high - 1
        a[low] = a[high]
        while low < high and a[low] <= pivot:
            low = low + 1
        a[high] = a[low]
    a[low] = pivot
    return low
def quick_sort(a, low, high):
    if low < high:
        pos = partition(a, low, high)
        quick_sort(a, low, pos - 1)
        quick_sort(a, pos + 1, high)
    return a
# 6、选择排序
# 算法思想：
# 每次（第i次）排序过程选择一个最小的元素，放在第i个位置
def select_sort(a):
    n = len(a)
    for i in range(n - 1):
        min = i
        for j in range(i, n):
            if a[j] < a[min]:
                min = j
        if min != i:
            temp = a[min]
            a[min] = a[i]
            a[i] = temp
    return a
# 7、堆排序
# 算法思想：
# 根据序列构造大根堆，输出堆顶元素，然后将堆底元素送入堆顶，再调整使其成为一个大根堆，不断重复直到只剩下一个元素
def adjust_down(a, k, n):
    # a[0]暂存
    a[0] = a[k]
    i = 2 * k
    while i <= n:
        if i < n and a[i] < a[i + 1]:
            i = i + 1
        if a[0] >= a[i]:
            break
        else:
            a[k] = a[i]
            k = i
        i = i * 2
    a[k] = a[0]
    return a
def build_max_heap(a, n):
    for i in range(n/2, 0, -1):
        a = adjust_down(a, i)
    return a
def heap_sort(a):
    n = len(a) - 1
    a = build_max_heap(a)
    for i in range(n, 1, -1):
        temp = a[i]
        a[i] = a[1]
        a[1] = temp
        a = adjust_down(a, 1, i - 1)
    return a