1.冒泡排序(从大到小):交换发生在内部循环
稳定的排序
冒泡排序的平均时间复杂度是O(n2),最好的时间复杂度是O(n),最坏的时间复杂度是O(n2),空间复杂度为O(1)
冒泡排序的优化在于didswap变量 ,通过这个变量的设置,实现冒泡排序的最好时间复杂度是O(n)
#!usr/bin/python
arr=[1,2,3,4,5,6,7,8,67,5,64,43,546,56,76,34,657,34,45,56,23]
def BubbleSort(list):
for i in range(len(list)-1):
didswap = False
for j in range(len(list)-1-i):
if list[j]<list[j+1]:
list[j],list[j+1]=list[j+1],list[j]
didswap =True
if didswap == False:
return list
return list
print (BubbleSort(arr))
2.选择排序(从大到小):交换发生在外部循环
不稳定的排序
平均算法复杂度O(n2),最好算法复杂度O(n2),最坏的算法复杂度为O(n2),空间复杂度O(1)
#!usr/bin/python
def SelectSort(lists):
for i in range(len(lists)-1):
max=i
for j in range(i+1,len(lists)):
if lists[j]>lists[max]:
max=j
lists[max],lists[i]=lists[i],lists[max]
return lists
lists=[2,3,4,65,7,6,5,5,6,7,8,6,4]
print SelectSort(lists)
3.插入排序(从大到小排序):
稳定的排序
平均复杂度O(n2),最好的时间复杂度O(n),最坏的算法复杂度O(n2),空间复杂度是O(1)
#!usr/bin/python def InsertSort(lists): for i in range(1,len(lists)): key=lists[i] j=i-1 while j>=0 and lists[j]<key: lists[j+1]=lists[j] j=j-1 lists[j+1]=key return lists
arr=[2,3,4,5,6,8,7,5,6,7,6,4,5,6,7,8,7,5] print InsertSort(arr)
4.归并排序(从大到小):归并排序的思想就是分而治之
归并排序是稳定
平均O(nlgn) 最好的时间复杂度是O(nlgn),最坏的时间复杂度是O(nlgn),空间复杂度是O(n)
#!usr/bin/python def Merge(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)<2: return lists div = len(lists)/2 left=MergeSort(lists[0:div]) right=MergeSort(lists[div:]) return Merge(left,right) lists = [2,3,4,5,6,7,6,5,34,23,4,56,6,3,4,6] print MergeSort(lists)
5.快速排序:(递归调用)
平均时间复杂度O(nlgn),平均时间复杂度O(nlgn),最坏的时间复杂度O(n2)
空间复杂度O(lgn)-Olg(n)
def QuickSort(myList,start,end):
#判断low是否小于high,如果为false,直接返回
if start < end:
i,j = start,end
#设置基准数
base = myList[i]
while i < j:
#如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现
while (i < j) and (myList[j] >= base):
j = j - 1
#如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等
myList[i] = myList[j]
#同样的方式比较前半区
while (i < j) and (myList[i] <= base):
i = i + 1
myList[j] = myList[i]
#做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base
myList[i] = base
#递归前后半区
QuickSort(myList, start, i - 1)
QuickSort(myList, j + 1, end)
return myList
lists = [49,38,65,97,76,13,27,49]
print(QuickSort(lists,0,len(lists)-1))
print (lists)
7.堆排序(从大到小):第一步最小堆化;第二步建立最小堆;第三步堆排序
#!user/bin/python def AjustHeap(lists,i,size): min=i left=2*i+1 right=2*i+2 if i < size/2: if right < size and lists[min] > lists[right]: min=right if left < size and lists[min]>lists[left]: min=left if min!=i: lists[i],lists[min]=lists[min],lists[i] AjustHeap(lists,min,size) def BuildHeap(lists,size): for i in range(0,(size/2))[::-1]: AjustHeap(lists,i,size) def HeapSort(lists): size=len(lists) BuildHeap(lists,size) for i in range(0,size)[::-1]: lists[i],lists[0]=lists[0],lists[i] AjustHeap(lists,0,i) return lists arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76] print HeapSort(arr)
6.希尔排序(从大到小):(插入排序的一种)
#!user/bin/python
def ShellSort(lists):
step=len(lists)/2
while (step>=1):#step终止循环为1
for i in range(step,len(lists)):#没一次step对应很多个新列表
while(i>=step and lists[i] > lists[i-step]):#每个列表进行排序
lists[i],lists[i-step]=lists[i-step],lists[i]
i=i-step
step=step/2
return lists
arr=[12,23,4,3,5,6,7,8,76,43,5,6,7,34,3,76]
print ShellSort(arr)
8.计数排序: