python 排序算法实现（选择、插入、冒泡、快排、归并）

左手的ㄟ右手 2024-04-17 18:40 80阅读 0赞

### \[Python笔记\]部分经典排序的实现 ###

*  0、部分排序算法相关术语
 *  1、选择排序 Selection sort
 *  2、插入排序 Insertion sort
 *  3、冒泡排序 Bubble sort
 *  4、快速排序 Quick sort
 *  5、归并排序 Merge sort

# 0、部分排序算法相关术语 #

（1）稳定or不稳定  
若在待排序的记录中，存在两个或两个以上的关键码值相等的记录，经排序后这些记录的相对次序仍然保持不变，则称相应的排序方法是稳定的方法，否则是不稳定的方法。  
（2）根据排序过程中涉及的存储器不同，可以将排序方法分为两大类：  
一类是内部排序，指的是待排序的几率存放在计算机随机存储器中进行的排序过程；另一类的外部排序，指的是排序中要对外存储器进行访问的排序过程。  
内部排序是排序的基础，在内部排序中，根据排序过程中所依据的原则可以将它们分为5类：插入排序、交换排序、选择排序、归并排序和基数排序；根据排序过程的时间复杂度来分，可以分为三类：简单排序、先进排序、基数排序。  
评价排序算法优劣的标准主要是两条：一是算法的运算量，这主要是通过记录的比较次数和移动次数来反应；另一个是执行算法所需要的附加存储单元的的多少。  
（3）时间复杂度  
时间复杂度是一个函数，定性地描述了算法的运行时间，常用大O符号表示，考察输入值渐进于无穷大时的情况。

# 1、选择排序 Selection sort #

（1）选择排序是不稳定的排序方法。时间复杂度O(n2）。  
（2）原理：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。  
（3）python实现：

import numpy as np
    def SelectionSort(lists):
    	for i in range(len(lists)):
    		swap = i + np.argmin(lists[i:])
    		lists[i],lists[swap]=lists[swap],lists[i]
    	return lists
    testarr=array([2,1,4,5,3,6,8])
    print('After sort:',SelectionSort(testarr))

这里我们用一下numpy.argmin直接找一下最小值，这比再做一个内循环来得方便，也比较切合选择排序的思想，但选择排序的时间复杂度还是大了点，不太适用于大数组。

# 2、插入排序 Insertion sort #

（1）时间复杂度为O(n^2)  
（2）思路（2步）:  
a.将元素分为两部分：除了最后一个元素 以及 最后一个元素  
b.让最后一个元素插入已经排好序的第一部分中  
即：每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，找出插入位置，将该元素插入到有序数列的合适位置中。  
（3）步骤：  
a.认为第一个元素就是一个已经排好序的序列了  
b.这之后每一个元素都与排好序序列从后向前每一个元素比较，若已排好序序列的元素较小（降序）或较大（升序）的时候就向后移（实为与当前元素换位）。  
（4）python实现：

def InsertionSort(lists):
    	for i in range(1,len(lists)):
    		for j in range(i,0,-1):
    			if lists[j] < lists[j-1]:
    				lists[j],lists[j-1] = list[j-1],list[j]
    	return lists
    testarr=array([2,1,4,5,3,6,8])
    print('After sort:',InsertionSort(testarr))

# 3、冒泡排序 Bubble sort #

（1）时间复杂度O(n2)，稳定  
（2）思路（3步）：  
a.比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
b.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。  
c.针对所有的元素重复以上的步骤，除了最后一个,直到没有任何一对数字需要比较。  
（3）python实现：

def BubbleSort(lists):
    	for i in range(len(lists)-1):
    		for j in range(len(lists)-i-1):
    			if lists[j] > lists[j+1]:
    				lists[j],lists[j+1] = lists[j+1],lists[j]
    	return lists
    testarr=array([2,1,4,5,3,6,8])
    print('After sort:',BubbleSort(testarr))

# 4、快速排序 Quick sort #

（1）是对冒泡排序的一种改进，不稳定  
（2）原理：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。  
注意：第一遍快速排序不会直接得到最终结果，只会把比k大和比k小的数分到k的两边。为了得到最后结果，需要再次对下标2两边的数组分别执行此步骤，然后再分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。  
（3）步骤：  
a.先选择key值，可以是首元素、尾元素或者是中间元素，在python里可以考虑新建左右列表用来存放分开的值，这样还避免了从尾到首的又一次循环。  
b.接下来再将已经分开的部分继续排序并分为两份，直至得出结果。  
(4)python实现：

def QuickSort(lists):
    	if len(lists) >= 2:
    		key = lists[0]
    		left,right = [],[]
    		lists.remove(key)
    		for i in lists:
    			if i >= key:
    				right.append(i)
    			else:
    				left.append(i)
    		return QuickSort(left) + [key] + QuickSort(right)
    	else:
    		return lists
    testarr=array([2,1,4,5,3,6,8])
    print('After sort:',QuickSort(testarr))

# 5、归并排序 Merge sort #

（1）时间复杂度：O(n log n)  
（2）思路（3步）：  
a.若数列仅含1个元素，done  
b.将元素分为两部分：（1到n/2向上取整）以及（n/2+1到n）  
递归地 对 这两部分分别排序  
c.排好序的两个表归并：两个list从末尾开始各取1比大小，小的放入最终list  
（3）步骤：  
申请合并空间—>指针分别对准各子序列首元素—>指针对应数对比，小的放进合并空间并移动该子序列指针—>直至一侧指针超出子序列元素，剩余数也放入合并空间内—>完成排序。  
（4）python实现：

def MergeSort(lists):
    	if len(lists) <= 1:
    		return lists
    	num = int(len(lists)/2)
    	left=MergeSort(lists[:num])
    	right=MergeSort(lists[num:])
    	return Merge(left,right)
    def Merge(left,right):
    	r,l = 0,0
    	result=[]
    	while l<len(left) and r<len(right):
    		if left[l] < right[r]:
    			result.append(left[l])
    			l += 1
    		else:
    			result.append(right[r])
    			r += 1
    	result += list(left[l:])
    	result += list(right[r:])
    	return result
    testarr=array([2,1,4,5,3,6,8])
    print('After sort:',MergeSort(testarr))