一、冒泡排序。
核心思想:通过双层循环遍历,每次比较两个数,如果他们顺序错误(大于或者小于),那么就把他们位置交换。
冒泡排序算法利用了双层循环,时间复杂度为O(n^2)
稳定性为:稳定
1 li=[10,2,3,5,110,55,99,88,66]
2 def bubble_sort(li):
3 count=len(li)
4 for i in range(0,count):
5 for j in range(i+1,count):
6 if li[i]>li[j]:
7 li[i],li[j]=li[j],li[i]
8 return li
9 print(bubble_sort(li))
二、插入排序。
核心思想:它把一个无序数列看成两个数列,假如第一个元素构成了第一个数列,那么余下的元素构成了第二个数列,很显然,第一个数列是有序的(因为只有一个元素嘛,肯定有序哦),那么我们把第二个数列的第一个元素拿出来插入到第一个数列,使它依然构成一个有序数列,直到第二个数列中的所有元素全部插入到第一个数列,这时候就排好序了。
插入排序的复杂度是O(n^2)
1 def insert_sort(l):
2 for i in range(1,len(l)): #无序的
3 num=l[i]
4 j=i-1
5 while j>=0 and l[j]>num: #有序的
6
7 l[j+1]=l[j]
8 j-=1
9
10 l[j+1]=num
11 return l
12 l=[1,2,4,22,5,3,66,9]
13 insert_sort(l)
14 print(l)
15
三、选择排序
每次从列表中找最小的数放前,之后从剩余列表中再找最小的数,直到把所有的数找完为止。
详解:1、把第一个数作为基准数(base)
2、把剩余的数作为一个列表和基准数进行比较,小于基准数,和base交换位置,直到把剩余所有数遍历完,找到最小的数放到i的位置。
3、然后重复步骤2
时间复杂度:n^2
1 def select_sort(l):
2 min_num=0
3 for i in range(len(l)-1):
4 min_num=i
5 for j in range(i+1,len(l)):
6 if l[min_num]>l[j]:
7 min_num=j
8 l[min_num],l[i]=l[i],l[min_num]
9 return l
10 l=[1,4,2,3,9,5,7,6,8,10]
11 print(select_sort(l))
四、快速排序
快速排序基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
[2,4,6,1,3,9,7,8]
详解:1、把第一个数2作为基准数,从右到左找比基准数小的数,找到之后和low数换位置,然后从做到找比基准数大的数,找到后和high数换位置(基准数固定,这个数字一定),当low 和 high相等的时候,就分成两组,基准数左边的数列全都小于基准数右边的数列。
2、然后把左边的数列和右边的数列分开,继续重复步骤一,找最左边的为基准数,直到所有数都排完为止。
快排复杂度:最坏的:0(n^2)
平均复杂度 :0(nlog2n)
1 def quick_sort(array,start,last):
2 while start > last:
3 return array
4 low=start
5 high=last
6 base_num=array[low]
7 while low < high:
8 while low < high and array[high] > base_num:
9 high-=1
10 array[high]=array[low]
11 while low < high and array[low] < base_num:
12 low+=1
13 array[low]=array[high]
14 array[low]=base_num
15 quick_sort(array,start,low)
16 quick_sort(array,low+1,last)
17 return array
18 l=[1,4,6,2,9,7,3,0]
19 v=quick_sort(l,0,7)
20 print(v)
21
五、堆排序
核心思想:堆是一种数据结构,可以看作一棵树完全二叉树,这棵二叉树满足,任何一个非叶子的值都大于左右孩子节点的值。将一个无序序列调整为一个堆,就可以找出这个序列的最大值(或最小值),然后将找出的这个值交换序列最后一个值,这样有序序列元素就增加一个,无序序列就减少一个,对新的无序序列重复这样的操作,就实现了排序。
复杂度:o(nlgn)
1 def adjust_heap(array,i,size):
2 lchild=2*i+1
3 rchild=2*i+2
4 maxa=i
5 if i < size//2:
6 if lchild < size and array[lchild] > array[maxa]:
7 maxa=lchild
8 if rchild < size and array[rchild] > array[maxa]:
9 maxa=rchild
10 if maxa != i:
11 array[maxa],array[i]=array[i],array[maxa]
12 adjust_heap(array,maxa,size)
13
14 def build_heap(array,size):
15 for i in range(0,size//2)[::-1]:
16 adjust_heap(array,i,size)
17
18 def heap_sort(array):
19 size=len(array)
20 build_heap(array,size)
21 for i in range(0,size)[::-1]:
22 array[0],array[i]=array[i],array[0]
23 adjust_heap(array,0,i)
24 return array
25 array=[4,2,5,7,1,8]
26 print(heap_sort(array))
六、二分查找(针对有序序列)
思想:折半思想,取这列数的中间值,如果要查找的这个数大于中间数,可以从中间数到最后作为一个数列去查找,再取此时数列的中间数,重复这样的操作,直到找到或者取完没找到为止;小于中间数,则把开头到中间数之前作为一个数列,然后折半。--采用递归
时间复杂度:o(log2n)
1 # _*_ encoding:utf-8 _*_
2 L=[2,5,8,11,33,66,77,88]
3 num=6
4 def binary_search(L,num):
5 if len(L)>1:
6 mid=len(L)//2
7 if L[mid]==num:
8 print('找到结果')
9 if L[mid]>num:
10 return binary_search(L[:mid],num)
11 else:
12 return binary_search(L[mid:],num)
13
14 else:
15 if L[0]==num:
16 print('找到数字了')
17 else:
18 print('此结果不在列表中')
19
20
21 binary_search(L,num)