冒泡排序
- 比较相邻的元素。如果第一个比第二个大,就交换它们两个;
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
- 针对所有的元素重复以上的步骤,除了最后一个;
- 重复步骤1~3,直到排序完成。
def bubble_sort(list1):
for i in range(len(list1)):
for j in range(len(list1)-1-i):
if list1[j]>list1[j+1]:
list1[j],list1[j+1]=list1[j+1],list1[j]
print(list1)
#从后往前排 ,先排最大的,时间复杂度:O(n²)
选择排序
选择排序就是要首先选定一个元素认为为最小的,之后比较其他,如果小于之前的,换更换列表所在位置。时间复杂度:O(n²)
def selection_sort(list1):
for i in range(len(list1)):
x=i #首先假定list[i]为最小,与之后的比较
for j in range(i,len(list1)):
if list1[j]<list1[x]:
x=j #小于之前list[i]就交换位置
list1[i],list1[x]=list1[x],list1[i]
print(list1)
插入排序
插入排序:选定元素,分别与列表中的元素比较,小的在左边,大的在右边
- 从第一个元素开始,该元素可以认为已经被排序;
- 取出下一个元素,在已经排序的元素序列中从后向前扫描;
- 如果该元素(已排序)大于新元素,将该元素移到下一位置;
- 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
- 将新元素插入到该位置后;
- 重复步骤2~5。
def insertion_sort(list1):
for i in range(len(list1)):
for j in range(i):
if list1[j]>list1[i]:
list1[i],list1[j]=list1[j],list1[i]
print(list1)
希尔排序
希尔排序将元素先平分,gap=len(list1)//2,按照gap去比较,一次//2,直到gap为1,
例如:gap=4,0-4,1-5,2-6,3-7,4-8,5-9去比较大小,若小于前面的,则交换位置。 时间复杂度:O(n)
def Shell_sort(list1):
gap=len(list1)
while gap>1:
gap=gap//2 #若len(list1)=9,gap=4,3,2,1
for i in range(gap,len(list1)):
for j in range(i%gap,i,gap):
if list1[i]<list1[j]:
list1[j],list1[i]=list1[i],list1[j]
print(list1)
快速排序
快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists),从数列中挑出一个元素,称为 “基准”(pivot);
重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置
时间复杂度O(nlog₂n)
ef quick_sort(list1):
left=[]
right=[]
same=[]
if len(list1)<=1:
return list1
else:
base=list1[0]
for i in list1:
if i<base:
left.append(i)
elif i>base:
right.append(i)
else:
same.append(i)
left=quick_sort(left)
right=quick_sort(right)#对right数列和left数列继续进行排序
return left+same+right#函数里面调用直到满足return条件停止调用,类似于函数循环
归并排序
归并排序:采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并
时间复杂度:O(nlog₂n)
归并排序也就是将列表中的元素分成两个长度为n/2的子序列,进行比较,之后合在一起
def merge_sort(list1):#merge_sort是按照len(list1)//2分开,知道分成两两比较大小
if len(list1)<=1:
return list1
mid=len(list1)//2
left=merge_sort(list1[:mid])
right=merge_sort(list1[mid:])
return merge(left,right)
def merge(left,right):#mere函数主要是左右两边每次取一个数进行比较,小的加入到result中
result=[]
while len(left)and len(right):
if left[0]<right[0]:
result.append(left.pop(0))
else:
result.append(right.pop(0))
if len(left)!=0:
result+=left
elif len(right)!=0:
result+=right
return result
堆排序
堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值,称为大顶堆;或者每个结点的值都小于或等于其左右孩子结点的值,称为小顶堆。
二叉树相关知识
大顶堆:arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] 父节点i的左子节点在位置(2*i+1); 父节点i的右子节点在位置(2*i+2)
小顶堆:arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
堆排序:
- 将无序列表构建最大堆,根节点为最大元素
- 将堆顶元素与末尾元素进行交换,使末尾元素最大。然后继续调整堆,再将堆顶元素与末尾元素交换,得到第二大元素。如此反复进行交换、重建、交换。
def heap_sort(hlist):
def heap_adjust(parent):
child = 2 * parent + 1 # left child
while child < len(heap):
if child + 1 < len(heap):
if heap[child + 1] > heap[child]:
child += 1 # right child,比较左右结点的大小,选出最大的元素
if heap[parent] >= heap[child]:
break
heap[parent], heap[child] = heap[child], heap[parent]#把最大的结点与父节点交换
parent, child = child, 2 * child + 1#往二叉树下面走,继续去比较,选出最大放到根节点,知道所有元素比较完退出
heap, hlist = copy.copy(hlist), []
for i in range((len(heap)-2)// 2, -1, -1):#(len(heap)-2)// 2为二叉树层数,k=3,i=3,2,1,0
heap_adjust(i)
while len(heap) != 0:
heap[0], heap[-1] = heap[-1], heap[0]
hlist.insert(0, heap.pop())#第一个替换成heap最后一个
heap_adjust(0)
return hlist
时间复杂度O(nlog₂n),不稳定