目录
1.冒泡排序
def bubbleSort(nums):
for i in range(0,len(nums)-1):
for j in range(i+1,len(nums)):
if nums[i]>nums[j]:
nums[i],nums[j] = nums[j],nums[i]
return nums
2.选择排序
def selectSort(nums):
for i in range(0,len(nums)-1):
Min = i
for j in range(i+1,len(nums)):#应该从i的后一位开始查找,因为i之前的数已经是排好序的
if nums[Min]>nums[j]:
Min = j
if Min!=i:
nums[i],nums[Min] = nums[Min],nums[i]
return nums
3.直接插入排序
def insertSort(nums):
length = len(nums)
for i in range(1,length):
temp = nums[i] #将当前元素保存起来,以此和前面的元素相比
j = i-1
while j>=0 and temp<nums[j]:
nums[j+1] = nums[j]#将小于temp的元素依次向后移位
j -= 1
nums[j+1] = temp #最后nums[j]要不小于0,要不小于temp,所以在后面插入temp
return nums
4.归并排序
def merge(left, right): # 对left和right数组进行合并
i, j = 0, 0
result = []
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i])
i += 1
else:
result.append(right[j])
j += 1
result += left[i:]
result += right[j:]
return result
def mergeSort(lists):
# 归并排序
if len(lists) <= 1:
return lists
num = len(lists) // 2
left = mergeSort(lists[:num]) # left是数组,存放着数据
right = mergeSort(lists[num:])
return merge(left, right) # 把left数组和right数组合并
5.快速排序
def quicksort(nums,low,high):
if low<high:
index = partition(nums,low,high)
quicksort(nums,low,index-1)#每一趟排序将数组里小于index的数放在左边,大于index的数放在右边,
# 所以要index-1和index+1
quicksort(nums,index+1,high)
return nums
def partition(nums,low,high):
pivot = nums[low]
while low<high:
while (low<high) and pivot<=nums[high]:
high -=1
nums[low] = nums[high]
while low<high and pivot>=nums[low]:
low+=1
nums[high] = nums[low]
nums[low] = pivot
return low
6.堆排序
def heapify(arr,n,i):
large = i #父节点的下标为i
left_child = 2*i+1 #左孩子下标
right_child = 2*i+2
if left_child<n and arr[left_child]>arr[large]:#如果左孩子的值大于父节点的值,将下标互换
large = left_child
if right_child<n and arr[right_child]>arr[large]:
large = right_child
if large != i:#如果下标换了,将最大子节点和父节点的值互换
arr[large],arr[i] = arr[i],arr[large]
heapify(arr,n,large)#将最大值的那个子树继续递归
def build_heap(arr,n):
last_child = n-1
last_parent = (last_child-1)//2 #从最后一个叶子节点的父节点开始以此向上调整
for i in range(last_parent,-1,-1):
heapify(arr,n,i)
def heap_sort(arr,n):
build_heap(arr,n)
for i in range(n-1,-1,-1):
arr[0],arr[i] = arr[i],arr[0] #每次将最大的节点(根节点)与最后一个节点交换,然后去掉最后一个节点,继续调整为最大堆
heapify(arr,i,0)
return arr
arr = [0, 8, 6, 2, 4, 9, 1, 4, 6]
n = len(arr)
res = heap_sort(arr,n)
print(res)
稳定排序的定义:定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变。就是“有序元素自始至终不改变相对位置”
7.几种排序算法比较
时间复杂度(平均情况) | 空间复杂度 | 稳定性 | |
冒泡排序 | 稳定 | ||
选择排序 | 不稳定 | ||
直接插入排序 | 稳定 | ||
归并排序 | 稳定 | ||
快速排序 | 不稳定 | ||
堆排序 | 不稳定 |
8、和初始顺序无关的排序算法:
比较次数与初始元素顺序无关的排序算法(即最好、最坏情况的时间复杂度一样)
选择排序 O (n^2)
堆排序 O (nlogn)
归并排序 O (nlogn)
基数排序 O (tn)