Python中八种基本排序方法
Python 基本排序方法
1. 选择排序方法
def select_sort(L):
for i in range(0,len(L)):
minl = L[i]
for j in range(i+1,len(L)):
if L[j] < minl:
temp = L[j]
L[j] = minl
minl = temp
L[i] = minl
选择排序不过多解释,只是通过遍历把每次最小的放到当前的数组头
2. 插入排序方法
def insert_sort(L):
for x in range(1,len(L)):
for i in range(x-1,-1,-1):
if L[i] > L[i+1]:
temp = L[i+1]
L[i+1] = L[i]
L[i] = temp
插入排序也就是让后面的依次插入到自己该去的位置,即可以类比为扑克牌发牌,每次拿一张牌然后放在它该放的位置
3. 冒泡排序方法
def pop_sort(L):
length = len(L)
for i in range(1,length):
for j in range(0,length - i):
if L[j] > L[j+1]:
temp = L[j]
L[j] = L[j+1]
L[j+1] = temp
bubble,冒泡冒泡冒泡泡,原理就是冒泡泡
4. 快速排序方法
def quick_sort(L,start,end):
if start < end:
left = start
right = end
temp = L[start]
while left < right:
while left < right and L[right] >= temp:
right = right - 1
if(left < right):
L[left] = L[right]
left = left + 1
while left < right and L[left] <= temp:
left = left + 1
if(left < right):
L[left] = L[right]
right = right - 1
L[left] = temp
quick_sort(L,start,left-1)
quick_sort(L,left+1,end)
快排,好用,原理移动,但是不稳定,它会把部分排序好的排在后面,会对排序稳定性有很大影响,同时大量的数据可能会超过其所满足的迭代深度,造成无法执行程序的后果
5. 希尔排序方法
def insert_shell(L):
gap = (int)(len(L)/2)
while(gap>=1):
for i in range (gap,len(L)):
for j in range(i-gap,-1,-gap):
if L[j] > L[j+gap]:
temp = L[j+gap]
L[j+gap] = L[j]
L[j] = temp
gap = (int)(gap/2)
希尔排序自己其实也只是一知半解,大概理解为一个分组进行插入,用步长gap将待排序元素分成若干个子序列,然后对各组内进行插入排序,逐渐减小步长,gap=1时,该数组便是有序的
6. 归并排序方法
def mergearray(L,first,mid,last,temp):
i = first
j = mid + 1
k = 0
m = mid
n = last
while (i <= m) and (j <= n):
if L[i] <= L[j]:
temp[k] = L[i]
k = k + 1
i = i + 1
else:
temp[k] = L[j]
k = k + 1
j = j + 1
while i <= m:
temp[k] = L[i]
k = k + 1
i = i + 1
while j <= n:
temp[k] = L[j]
k = k + 1
j = j + 1
for i in range(0,k):
L[first + i] = temp[i]
def mergesort(L,first,last,temp):
if first < last:
mid = (int)((first + last)/2)
mergesort(L,first,mid,temp)
mergesort(L,mid+1,last,temp)
mergearray(a,first,mid,last,temp)
归并不仅好用,稳定还方便理解,简单理解为通过mergesort做到左有序,右有序,然后把左右再整合有序
7. 堆排序方法
def adjust(L,len,i): #调整堆
left = (int)(2*i+1)
right = left + 1
max = i
#找大儿子
if (left < len) and L[left]>L[max]:
max = left
if (right < len) and L[right]>L[max]:
max = right
if max!=i:
temp = L[max]
L[max] = L[i]
L[i] = temp
adjust(L,len,max)
def heapsort(L,size):
for i in range(int(size/2)-1,-1,-1): #对每一个非叶节点进行堆调整,从最后一个非叶节点开始
adjust(L,size,i)
for i in range(size-1,0,-1):
temp = L[0]
L[0]=L[i]
L[i]=temp #将当前最大的放置到数组的末尾
adjust(L,i,0) #将未完成排序的部分继续进行堆排序
如上代码所构建的为大顶堆,即根节点大于叶节点,简单说就是父亲大于儿子,然后通过交换父亲与末尾节点,取出了本次循环的父亲,然后在对剩下的进行调整,形成大顶堆,直到只有一个元素的时候,循环结束,完成排序
8. 基数排序
#寻找最大数字的位数
def max_nums(L):
maxnum = L[0]
for i in L:
if maxnum < i:
maxnum = i
flag = 0 #统计位数
while (maxnum > 0):
maxnum = (int)(maxnum/10)
flag = flag + 1
return flag
#获取num从低位到高位的第pos个位的数据
def get_num(num,pos):
return ((int)(num/(10**(pos-1))))%10
def radix_sort(L):
count = 10*[None] #存放每个桶的数据统计个数
bucket = (len(L))*[None] #暂时存放排序结果
for pos in range(1,max_nums(L)+1): #从个位开始循环
for i in range(0,10):
count[i] = 0
for i in range(0,len(L)): #统计当前位数的元素数目
j = get_num(int(L[i]),pos)
count[j] = count[j]+1
for i in range(1,10):
count[i] = count[i] + count[i-1]
for i in range(len(L)-1,-1,-1):
j = get_num(L[i],pos)
bucket[count[j] - 1] = L[i]
count[j] = count[j] - 1
for i in range(0,len(L)):
L[i] = bucket[i]
基数排序简单理解可以理解成,我首先只看个位,对个位进行排序,然后再看十位,对十位进行排序,以此类推,直到看完最大数的位数即可,下面是一个简单的程序样例类型。
L = [ 52 , 95 , 9 , 101 , 960 ]
我们可以获得L的最高位数为3,然后对个位进行排序得到:
L = [ 960 , 101 , 52 , 95 , 9 ]
然后我们对十位进行排序可以得到:
L = [ 9 , 101 , 52 , 960 , 95 ]
然后我们对百位进行排序可以得到:
L = [ 9 , 52 , 95 , 101 , 960 ]
排序结束
自己第一次写博客,可能排版还有文稿都比较菜,希望大家多多体谅,以后在闲暇时间通过博客记录自己的学习之路
上面的很多代码都是自己在之前的C++模板上稍加修改的,本质还是要学各种排序方法的原理和相关知识