标签：代码 插入 一个个 构建 uil nbsp 利用 clear color
一、选择排序
选择排序是每次从未排序的部分选出一个最小的数字，放在已排序部分的最后，即每次选出最小的、第二小的，以此类推。当然，也可以每次从未排序的地方选出最大的数字，放在已排序部分的最前面，即每次选出最大的、第二大的，以此类推。
时间复杂度O(n^2)。
优点是交换次数最少。
代码：
def select_sort(nums): n = len(nums) for i in range(n): min = i for j in range(i+1,n): if nums[j]<nums[min]: min = j nums[i],nums[min] = nums[min],nums[i] return nums nums = [3,4,8,2,1] print(select_sort(nums))
二、插入排序（熟悉）
插入排序是每次将一个数字（主元）【i序列】插入到一个有序的数组【j序列】里，成为一个长度更长的有序数组，有限次操作后，数组整体有序。
时间复杂度O(n^2)。
优点是在几乎有序的数组和短数组上表现很好，为此，在小区间执行排序任务时可以使用插入排序。
代码：
def insert_sort(nums): n = len(nums) for i in range(1,n): pivot = nums[i] j = i-1 while j>=0 and nums[j] > pivot: nums[j+1] = nums[j] j -= 1 nums[j+1] = pivot return nums nums = [3,4,8,2,1] print(insert_sort(nums))
三、归并排序（重点）
归并排序是借助额外空间，将两个有序数组合并，得到更长的有序数组。额外空间是用来存放合并后数组，然后将该数组再放回大数组里。
以下代码为《算法导论》里的代码，它开辟了两个额外空间存放数组。
def merge(A,l,m,r): n1 = m-l+1 n2 = r-m #创建临时数组 L = [0]*n1 R = [0]*n2 #拷贝到临时数组 for i in range(n1): L[i] = A[l+i] for j in range(n2): R[j] = A[m+1+j] #归并临时数组到A[l,r] i,j,k=0,0,l while i<n1 and j<n2: if L[i]<=R[j]: A[k] = L[i] i += 1 else: A[k] = R[j] j += 1 k += 1 #拷贝L、R剩余元素 while i<n1: A[k]=L[i] i += 1 k += 1 while j<n2: A[k]=R[j] j += 1 k += 1 def mergesort(A,l,r): if r>l: m = l+ (r-l)//2 mergesort(A,l,m) mergesort(A,m+1,r) merge(A,l,m,r) #测试实例 A=[5,2,4,7,1,3,2,6] mergesort(A,0,len(A)-1) print(A)
也可以每次不用开辟新临时数组，而只用一个。每次开辟新临时数组空间复杂度为nlogn。
def merge(A,l,m,r,temp): i,j = l,m+1 while i<=m and j<=r: if A[i]<=A[j]: temp.append(A[i]) i += 1 else: temp.append(A[j]) j+=1 while i<=m: temp.append(A[i]) i += 1 while j<=r: temp.append(A[j]) j += 1 for i in range(len(temp)): A[l+i] = temp[i] temp.clear() def mergesort(A,l,r,temp): if r>l: m = l+(r-l)//2 mergesort(A,l,m,temp) mergesort(A,m+1,r,temp) merge(A,l,m,r,temp) A=[5,2,4,7,1,3,2,6] mergesort(A,0,len(A)-1,[]) print(A)
四、快速排序（重点）
快速排序是每一次都排好一个元素，这个元素就待在了它最终该待的地方，然后递归地处理它左边和右边的部分，直至有序。思想也是分治的思想，但与归并排序不同，采用的是分割的方法，所以没有“合”的过程。
代码为随机化分割：
import random def partition(A,p,r): pivot = A[r] #主元 i = p-1 #初始化起始序号 for j in range(p,r): if A[j] <= pivot: i += 1 A[i],A[j] = A[j],A[i] A[r],A[i+1] = A[i+1],A[r] return i+1 def RandomizePartition(A,p,r): x = random.randint(p,r) A[x],A[r] = A[r],A[x] return partition(A,p,r) def quicksort(A,p,r): if p<r: q = RandomizePartition(A,p,r) quicksort(A,p,q) quicksort(A,q+1,r) return A A = [2,8,7,1,3,5,6,4] quicksort(A,0,len(A)-1) print(A)
每次随机化选择主元，这样可以避免出现有序或逆序的待排序数组时时间复杂度为O(n^2)的情况。
五、堆排序（重要）
堆排序是利用堆这种数据结构而设计的一种排序算法，它的时间复杂度为O(nlogn)。它的主要思想是：将待排序序列构造成一个最大堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样就会得到n个元素的次小值。以此类推，就能得到一个有序序列了。
代码如下：
#维护一个最大堆 def heapify(arr, n, i): largest = i l = 2 * i + 1 # left = 2*i + 1 r = 2 * i + 2 # right = 2*i + 2 if l < n and arr[i] < arr[l]: largest = l if r < n and arr[largest] < arr[r]: largest = r if largest != i: arr[i], arr[largest] = arr[largest], arr[i] # 交换 heapify(arr, n, largest) #堆排序 def heapSort(arr): n = len(arr) # Build a maxheap. for i in range(n, -1, -1): heapify(arr, n, i) # 一个个交换元素 for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] # 交换 heapify(arr, i, 0) arr = [12, 11, 13, 5, 6, 7] heapSort(arr) print(arr)
堆排序是一种选择排序，整体主要由构建初始堆+交换堆顶元素和末尾元素并重建堆两部分组成。其中构建初始堆经推导复杂度为O(n)，在交换并重建堆的过程中，需交换n-1次，而重建堆的过程中，根据完全二叉树的性质，[log2(n-1),log2(n-2)...1]逐步递减，近似为nlogn。所以堆排序时间复杂度一般认为就是O(nlogn)级。
标签：代码 插入 一个个 构建 uil nbsp 利用 clear color
原文地址：https://www.cnblogs.com/amberwang2018/p/12606010.html
