经典排序算法详解-优快云博客

一、排序算法

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。所以说一个好的排序算法是相当重要的。当然一个好的算法并不单单从它的时间效率看，算法的稳定性也相当重要。
如何评价一个算法的稳定性。

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；

排序算法的性能三大影响因素

时间性能(时间复杂度): 一个算法执行所耗费的时间。
辅助空间 (空间复杂度)：运行完一个程序所需内存的大小。
算法的复杂性 : 算法本身的复杂度，而不是指算法的时间复杂度。

算法对我们来说是非常重要的。当然算法分为好多种。

内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
下面我们就实现几种常用的算法。

冒泡排序

冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。
冒泡排序算法的运作如下:
1. 比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。
这步做完后,最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤,除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
具体实现和结果如下：

def BubbleSort(nums):
    """
    冒泡排序
    需要排n趟， i趟需要比较(n-i-1)
    :param nums: 需要排序的数值
    :return:
    """
    nums_len = len(nums)
    for count in range(nums_len):
        for index in range(nums_len-count-1):
            if nums[index]  < nums[index+1]:
                nums[index], nums[index+1] = nums[index+1], nums[index]

    return  nums
if __name__ == '__main__':
    nums = [12, 34, 23, 45, 66, 1, 2, 0]
    sorted_nums = BubbleSort(nums)
    print(sorted_nums)

在这里插入图片描述

交换排序:快速排序

快速排序（Quick Sort）的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
具体实现和结果如下：

"""
User: yz
Email: 1147570523@qq.com
Desc:
"""
def quicksort(array):
    if len(array)<2:
        return array
    else:
        item=array[0]
        minarr=[i for i in array[1:] if i < item]
        maxarr=[i for i in array[1:] if i>= item]
        return quicksort(minarr)+[item]+quicksort(maxarr)
print("排序后：")
print(quicksort([4,3,2,1,2]))

在这里插入图片描述

插入排序: 直接插入排序

直接插入排序（Straight Insertion Sort）的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增 1 的有序表。

原理：每次将排序中的元素，插入到前面已经排好序的有序序列中去，直到排序完成。
步骤：
第一步，a[0]为有序区，待排序区为a[1…n-1]。令i=1。
第二步，将a[1]与a[0]中元素比较，将小的元素放在第一个位置。
第三步，以此类推，直到待排序中全部元素插入完成为止。

具体实现和结果如下：

def insert_sort(array):
    count = len(array)
    for i in range(1, count):
        key = array[i]
        j = i - 1
        while j >= 0:
            if array[j] > key:
                array[j + 1] = array[j]
                array[j] = key
            j -= 1
    return array
if __name__ == '__main__':
    nums = [5, 4, 6, 3, 2, 1]
    sort_nums = insert_sort(nums)
    print(sort_nums)

在这里插入图片描述

希尔排序

希尔排序是D.L.Shell于 1959 年提出来的一种排序算法，在这之前排序算法的时间复杂度基本都是O(n2)的，希尔排序算法是突破这个时间复杂度的第一批算法之一。
基本思想：
算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的然后
再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行
直接插入排序后，排序完成。
具体实现和结果如下：

def shellSort(arr):
    n = len(arr)
    gap = int(n/2)
    while gap>0:
        for i in range(gap,n):
            temp = arr[i]
            j=i
            while j >=gap and arr[j-gap] >temp:
                arr[j]=arr[j-gap]
                j -= gap
            arr[j]=temp
        gap=int(gap/2)

arr=[12,43,54,2,4]
n = len(arr)
print("排序前：")
for i in range(n):
    print(arr[i],end=' ')
shellSort(arr)
print("\n排序后：")
for i in range(n):
    print(arr[i],end=' ')

在这里插入图片描述

选择排序

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

def findSmallest(arr):
    smallest = arr[0]
    smallest_index =0
    for i in range(1,len(arr)):
        if arr[i]<smallest:
            smallest=arr[i]
            smallest_index =i
    return smallest_index

def selectionSort(arr):
    newArr=[]
    for i in range(len(arr)):
        smallest = findSmallest(arr)
        newArr.append(arr.pop(smallest))
    return newArr

print(selectionSort([5,4,3,2,1]))

在这里插入图片描述