主要的排序算法-python实现

主要的排序算法（python 实现）

时间复杂度分析

排序方法	时间复杂度（平均）	空间复杂度	稳定性
直接插入排序	$$O(n^2)$$	$$O(1)$$	稳定
冒泡排序	$$O(n^2)$$	$$O(1)$$	稳定
简单选择排序	$$O(n^2)$$	$$O(1)$$	不稳定
快速排序	$$O(nlo{g}_{2}n)$$	$$O(nlo{g}_{2}n)$$	不稳定
希尔排序	$$O(n^{1.3})$$	$$O(1)$$	不稳定
堆排序	$$O(nlo{g}_{2}n)$$	$$O(1)$$	不稳定
归并排序	$$O(nlo{g}_{2}n)$$	$$O(n)$$	稳定

将排序算法分类

• 插入排序
  • 直接插入排序（开始时默认第一个数是有序的，将剩余的n-1个数逐个插入；包含的主要操作：比较确定插入位置，移动数据腾出空位）
  • 希尔排序（在直接插入排序的基础上做了优化，减少了一些没有必要的数据移动；希尔排序将数列按固定间隔分为多个子序列，再在子序列上做直接插入排序的操作，先做远距离移动使数列基本有序，再逐渐缩小间隔，直到间隔为1时做直接插入排序）
• 交换排序
  • 冒泡排序（比较前后两个元素，如果前一个数比后一个数大则交换，每一轮会将一个最值交换到队尾，类似冒泡）
  • 快速排序（从数列中挑选一个元素–一般为第一个数，将数组中其余的数按照小值在左，大值在右的方式重新排列，将基准值位于中间，递归的对左右分区做相同的操作）
• 选择排序
  • 简单选择排序（将数组分为有序区和无序区，并在无序区中选择最值和无序区的第一个值进行交换）
  • 堆排序（将待排序的关键字数组建成大顶堆，并将堆顶元素$$R(1)$$和最后一个元素$$R(N)$$进行交换，对无序区$$R(1),R(2),...,R(N-1)$$进行大顶堆排序）
• 归并排序

• 归并排序（将待排序列分成N/2的两个子序列，对这两个子序列分别进行归并排序，将两个排序好的子序列合并成一个序列）

代码解析

【直接插入排序】

def InsertSort(lst):
    l = len(lst)
    if n <= 1:
    	return lst
    for i in range(1, l):
        j = i 
        tagret = lst[i]     # 每次循环时待插入的一个数
        while j > 0 and target < lst[j-1]:     # 比较待插入的数和当前数，小于当前数则后移
            lst[j] = lst[j-1]
            j -= 1
        lst[j] = target     # j为待插入数的位置
    return lst

x = input("请输入待排序的序列：\n")
y = x.split()
arr = []
for i in y:
	arr.append(int(i))
arr = InsertSort(arr)
print(arr)
	

【希尔排序】

def ShellSort(lst):
	def ShellInsert(arr, d):		# 每个子序列的直接插入排序
		l = len(arr)
		for i in range(d, l):
			j = i - d		# 从后往前开始比较的下标
			target = arr[i]
			while j >= 0 and arr[j]>target:
				arr[j+d] = arr[j]
				j -= d
			if j != i-d:
				arr[j+d] = target
	n = len(lst)
	if n <= 1:
		return lst
	d = n // 2
	while d >=1 :
		ShellInsert(lst, d)
	   d = d // 2
	return lst
	
x = input("请输入待排序的序列：\n")
y = x.split()
arr = []
for i in y:
	arr.append(int(i))
arr = ShellSort(arr)
print(arr)

【冒泡排序】

def BubbleSort(lst):
	n = len(lst)
	if n <= 1:
		return lst
	for i in range(n):
		for j in range(n-i-1):
			if lst[j] > lst[j+1]:
				lst[j], lst[j+1] = lst[j+1], lst[j]
	return lst
	
# 优化冒泡排序：
def BubbleSort(lst):
	n = len(lst)
	if n <= 1:
		return lst
	for i in range(n):
		ex_flag = False    # 标志位，如果在一次冒泡中没有交换元素，那么直接退出循环
		for j in range(n-i-1):
			if lst[j] > lst[j+1]:
				lst[j], lst[j+1] = lst[j+1], lst[j]
				ex_flag = True
			if not ex_flag:
				return lst
	return lst

x = input("请输入待排序的序列：\n")
y = x.split()
arr = []
for i in y:
	arr.append(int(i))
arr = BubbleSort(arr)
print(arr)

【快速排序】

def QuickSort(lst):
	def quicksort(arr, left, right):     # 主函数
		if left >= right:      # 递归出口
			return 
		mid = partition(arr, left, right)         # 分区的中间基准值的下标
		quicksort(arr, left, mid-1)
		quicksort(arr, mid+1, right)
	
	def partition(arr, left, right):
		index = left       # 基准值的下标
		while left < right:
			# 从右往左找到比基准值小的值
			while left < right and arr[right] >= arr[index]:
				right -= 1
		   # 从左往右找到比基准值大的值
		    while left < right and arr[left] <= arr[index]:
		    	left += 1
		   # 交换
		   arr[left], arr[right] = arr[right], arr[left]
		   
		# 前后位置相等时，将标准值和左边的小值交换
		arr[index], arr[left] = arr[left], arr[index]
	return left

	n = len(lst)
	if n <= 1:
		return lst
	quicksort(lst, 0, n-1)
	return lst

x = input("请输入待排序的序列：\n")
y = x.split()
arr = []
for i in y:
	arr.append(int(y))
arr = QuickSort(arr)
pritn(arr)

【简单选择排序】

def SelectSort(lst):
	n = len(lst)
	if n <=1:
		return lst
	for i in range(n-1):
		minIndex = i       # 待比较值的索引
		for j in range(i+1, n):
			if lst[j] < lst[minIndex]:
				minIndex = j			# 交换小值索引
			if minIndex != i:
				lst[i], lst[minIndex] = lst[minIndex], lst[i]       # 交换值
	return lst

x = input("请输入待排序的序列：\n")
y = x.split()
arr = []
for i in y:
	arr.append(int(y))
arr = SelectSort(arr)
pritn(arr)

【堆排序】

def HeapSorted(lst):
	def created_head(arr):      # 建大顶堆
		n = len(arr)
		max_child_index = (n-2) // 2             # 下标值最大的根结点
		for i in range(max_child_index, -1, -1):
			max_head(arr, n, i)				# 调整堆
	
	def max_head(array, length, root_index):          # 以root_index为根，调整堆
		left = root_index * 2 + 1        # 左孩子结点
		right = root_index * 2 +2			# 右孩子结点
		large_index = root_index
		if left < length and array[left] > array[large_index]:
			large_index = left
		if right < length and array[right] > array[large_index]:
			large_index = right
		if large_index != root_index:
			# 在左右孩子结点中找最大值和根结点交换
			array[large_index], array[root_index] = array[root_index], array[large_index]
		max_head(array, length, large_index)
	
	created_head(lst)
	for i in range(len(lst), -1, -1):
		lst[i], lst[0] = lst[0], lst[i]		# 将大顶堆的堆顶放在最后
		max_head(lst, i, 0)
	return lst

【归并排序】

def MergeSort(lst):
	#合并左右子序列函数
    def merge(arr,left,mid,right):
        temp=[]     #中间数组
        i=left          #左段子序列起始
        j=mid+1   #右段子序列起始
        while i<=mid and j<=right:
            if arr[i]<=arr[j]:
                temp.append(arr[i])
                i+=1
            else:
                temp.append(arr[j])
                j+=1
        while i<=mid:
            temp.append(arr[i])
            i+=1
        while j<=right:
            temp.append(arr[j])
            j+=1
        for i in range(left,right+1):    #  !注意这里，不能直接arr=temp,他俩大小都不一定一样
            arr[i]=temp[i-left]
    #递归调用归并排序
    def mSort(arr,left,right):
        if left>=right:
            return
        mid=(left+right)//2
        mSort(arr,left,mid)
        mSort(arr,mid+1,right)
        merge(arr,left,mid,right)
 
    n=len(lst)
    if n<=1:
        return lst
    mSort(lst,0,n-1)