python实现各种排序

python实现各种排序算法

 

冒泡排序

"""
分析
1. 算法是一种与语言无关的东西，更确切地说就算解决问题的思路，就是一个通用的思想的问题
2. 冒泡算法作为最简单的一种排序算法，我们的关注点不应该是代码本身，而应该是思想
3. 冒泡排序思想的侧重点有两点：走一趟干到底选出最大的放到右边；走几趟能够把整个序列都排序完毕
4. 当走一趟干到底的时候考虑的是j的取值, 而不是j+1, 这样能清晰地知道range的范围应该是什么
5. is_ordered 标志位：如果有序列表就不再排序，直接退出
6. 两个for循环的考虑顺序：先考虑内层循环的意义，再考虑外层循环的意义
"""

def bubble_sort(alist):
    n = len(alist)
    # i 代表的是第几趟，从1开始，表示第一趟
    for i in range(1, n):
        is_ordered = True
        # j 表示走一趟
        for j in range(n-i):
            if alist[j] > alist[j+1]:
                alist[j], alist[j+1] = alist[j+1], alist[j]
                is_ordered = False
        if is_ordered:
            return

if __name__ == '__main__':
    lis = [9, 11, 2, 2, 1, 20, 13]
    bubble_sort(lis)
    print(lis)

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

冒泡排序算法的运作如下：

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

选择排序

"""
分析：
1. 代码本身不重要，算法思想才是重中之重
2. 选择排序从概念上把列表分为前后两部分，前一部分假设是有序的(借助一些操作它就是有序的，这也是一种思想)，后一部分是乱序的
3. 每次从乱序的当中选择出一个最小值放到前面一部分的最后一个位置，这里体现了选择的概念
4. 稳定性：考虑这样一种情况，把列表分为前后两部分，后一部分是有序的，每次从前面一部分选出一个最大值放到后面一部分的第一个位置，
   假设第一个元素是99，是最大的，中间还有一个元素99，因为后面的99不比前面的大，所以前面的99放到最后，这样就不稳定了
5. 最优时间复杂度：即使已经是有序，还是得拿着前面的元素和后面的一个一个地进行比较，所以复杂度是O(n2)
6. 最坏时间复杂度: 内层循环是和n有关的，复杂度是O(n2)
"""
def select_sort(alist):
    """
    选择排序
    :param alist:
    :return:
    """
    n = len(alist)
    for j in range(n-1):
        min_index = j
        for i in range(j + 1, n):
            if alist[min_index] > alist[i]:
                min_index = i
        if min_index != j:
            alist[j], alist[min_index] = alist[min_index], alist[j]

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

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

插入排序

"""
1. 插入排序：同样是把列表分为两部分，前面一部分有序，后面一部分无序，每次从后面选择第一个元素插入到前面有序序列中
2. 对一个变量进行加减操作的判断一般使用while循环
3. 优化：因为前一部分已经是从小到大排列的了, 所以如果从后面选出的最小元素大于前面的元素，那么就一定比前面的前面还要大，这时候就不需要进行比较了
4. 最优算法复杂度：假设列表已经是从小到大排序好, 那么while循环进入一次就退出，总共进入n-1次，所以算法复杂度是O(n)
5. 最坏算法复杂度：假设列表是完全无序，或者说是从大到小排列的，那么内层循环是n-1 n-2 n-3 ...,和n是有关的，所以复杂度是O(n2)
6. 稳定性：因为比较是这样进行的：拿无序的第一个元素和前面的比较，比如说前面最大66，后面有一个66，因为后面的66不比前面的66大，所以位置不改变，
    所以插入排序是稳定的
"""

def insert_sort(alist):
    """
    选择排序
    :param alist:
    :return:
    """
    n = len(alist)
    for j in range(1, n):
        i = j
        while i > 0:
            if alist[i] < alist[i-1]:
                alist[i], alist[i-1] = alist[i-1], alist[i]
                i -= 1
            else:
                break

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

希尔排序

"""
希尔排序是通过步长把原来的序列分为好几部分，每一个部分采用插入排序，然后调整步长，重复这个过程
最坏时间复杂度考虑gap取1，这就是完全的插入排除
"""
def shell_sort(alist):
    n = len(alist)
    gap = n // 2
    # gap 必须能取到1
    while gap > 0:
        # 插入算法，与普通的插入算法的区别就是gap步长
        for j in range(gap, n):
            i = j
            while i > 0:
                if alist[i] < alist[i-gap]:
                    alist[i], alist[i-gap] = alist[i-gap], alist[i]
                    i -= gap
                else:
                    break
        gap //= 2

快速排序

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

步骤为：

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

"""
1. 快速排序是一种常用的排序算法，本质是找到每一个元素在原列表的真实位置
2. 因为需要排序的是原列表，如果quick_sort(alist[0:low]) 这种方式排序的是新列表，和原列表脱离了关系，所以采用多传参数的方式，传的参数是列表位置
3. 最坏时间复杂度：考虑最坏的情况，每次找到的元素位置就是在最左边，那时间复杂度是O(n2)
4. 最优时间复杂度：考虑最好的情况，每次找到的元素在最中间，每次low和high移动之和是n,总共移动多少次？
   每次都是对半分割  2*2*.. = N 个数字，次数是logn,所以O(nlogn)
"""

def quick_sort(alist, start, end):
    """
    快速排序
    :param alist:
    :return:
    """
    # n = len(alist)
    if start >= end:
        return
    mid = alist[start]
    low = start
    high = end

    while low < high:
        # 这里用alist[high] >= mid 而不是alist[high]>mid是为了把所有和中间值相等的都移动到一遍，而不是移来移去
        while low < high and alist[high] >= mid:
            high -= 1
        alist[low] = alist[high]
        while low < high and alist[low] < mid:
            low += 1
        alist[high] = alist[low]
    # while low < high:
    #     while low < high:
    #         if alist[high] < mid:
    #             alist[low] = alist[high]
    #             # 这时候应该移动low了
    #             break
    #         # 这个else就是循环移动
    #         else:
    #             high -= 1
    #     while low < high:
    #         if alist[low] > mid:
    #             alist[high] = alist[low]
    #             # 这时候应该移动high了
    #             break
    #         else:
    #             low += 1
    alist[low] = mid
    quick_sort(alist, start, low)
    quick_sort(alist, low+1, end)

归并排序

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

"""
1. 归并排序采用递归，可以用这个排序算法好好体会一下递归的流程思想.其中递归编程思想和执行思想是有区别的，编程思想是不考虑底下的层，只着眼于
   当前层，最后考虑细枝末节。执行思想是嵌套
2. 最优时间复杂度和最坏时间复杂度是一样的：每一层的归并用来两个指针，相加的和是 n ,每次对半分，总共分了logn次(和快速排序一样)，时间复杂度是O(nlogn)
"""

def merge_sort(alist):
    n = len(alist)
    if n <= 1:
        return alist
    # 分为两部分,对每部分进行排序
    mid = n // 2

    # 假设这已经是排序好的了
    left = merge_sort(alist[0:mid])
    right = merge_sort(alist[mid:])

    # 对排序好的进行合并
    left_index = 0
    right_index = 0
    result = []
    while left_index < len(left) and right_index < len(right):
        if left[left_index] < right[right_index]:
            result.append(left[left_index])
            left_index += 1
        else:
            result.append(right[right_index])
            right_index += 1
    # 如果左边先走到尽头，则把右边剩余所有加进来；如果右边先走到尽头，则把左边剩余所有加进来
    # 最终第一层的result把left 和 right 的result 都包含进来了
    result += left[left_index:]
    result += right[right_index:]
    return result