python实现各个排序算法【转】

交换排序
#coding:gbk

#交换排序
import copy

#交换排序经典---冒泡排序
def BubbleSort(a):
for i in xrange(len(a)-1,0,-1):
flag = True #标志一趟排序没有进行交换
for j in xrange(i):
if(a[j]>a[j+1]):
flag = False #交换的标志
temp = a[j]
a[j] = a[j+1]
a[j+1] = temp
#print "--------------",i
#print a
if(flag):
break
return a

#快速排序
#一次划分
def partition(a,i,j): #i:起始点。j:终止点
temp = a[i]
while(i<j):
#从上向下找比temp小的
while(i<j and a[j]>=temp):
j-=1
a[i] = a[j]
#从下向上找比temp小的
while(i<j and a[i]<=temp):
i+=1
a[j] = a[i]
a[i] = temp
return i

def quickSort(a,i,j):
if(i<j):
m = partition(a,i,j) #划分
quickSort(a,i,m-1) #快速排序左半部分
quickSort(a,m+1,j) #快速排序右半部分

if __name__ == "__main__":
a=[49,38,65,97,76,13,27,49]
print "冒泡排序前"
print a
print "冒泡排序后"
print BubbleSort(copy.deepcopy(a))

print "快速排序前"
print a
print "快速排序后"
aa = copy.deepcopy(a)
quickSort(aa,0,len(a)-1)
print aa

插入排序

#coding:gbk
#插入排序
import copy

#直接插入排序
def insert_sort(a):
for i in xrange(1,len(a)):
temp = a[i] #保存当前值
#寻找要插入的位置(就在这个位置插入)
jj = 0
for j in xrange(i-1,-1,-1):
if(temp>=a[j]):
jj=j+1
break
#将该位置后的元素后移
for m in xrange(i,jj,-1):
a[m] = a[m-1]
#插入当前值
a[jj] = temp
return a

#二分插入排序
def binary_sort(a):
for i in xrange(1,len(a)):
temp = a[i] #保存当前值
#寻找要插入的位置(就在这个位置插入)
jj = 0
low = 0
high = i-1
while(low<=high):
m = int((low+high)/2)
if(a[m]<temp):
low = m+1
else:
high = m-1
jj= low
#将该位置后的元素后移
for m in xrange(i,jj,-1):
a[m] = a[m-1]
#插入当前值
a[jj] = temp
return a

#希尔排序(缩小增量排序)
def once_shell(a,dk):
for i in xrange(dk,len(a)):
temp = a[i] #保存当前值
#寻找要插入的位置(就在这个位置插入)
for j in xrange(i-dk,-1,-dk):
if(temp>=a[j]):
j+=dk
break
else:
a[j+dk] = a[j] #将该位置后的元素后移
#插入当前值
a[j] = temp

def shell_sort(a):
dd=[5,3,1]
for i in dd:
once_shell(a,i)
return a

if __name__ == "__main__":
a=[49,38,65,97,76,13,27,49,55,4]
print "直接插入排序前："
print a
print "直接插入排序后："
print insert_sort(copy.deepcopy(a))

print "二分插入排序前："
print a
print "二分插入排序后："
print binary_sort(copy.deepcopy(a))

print "希尔插入排序前："
print a
print "希尔插入排序后："
print shell_sort(copy.deepcopy(a))

归并排序

#coding:gbk

#归并排序--递归实现
import copy
global aa

def merge(a,s,m,e): #s,m,e:起始，中间，结束
i = s
j = m+1
f = e
qi = s
print s,m,e
while(i<=m and j<=e):
if(a[i]<=a[j]):
aa[s] = a[i]
s+=1
i+=1
else:
aa[s] = a[j]
s+=1
j+=1
if(i<=m):
while(i<=m):
aa[s] = a[i]
s+=1
i+=1
if(j<=e):
while(j<=e):
aa[s] = a[j]
s+=1
j+=1
for ii in xrange(qi,e+1):
a[ii] = aa[ii]
print a

def merge_sort(a,s,e):
if(s<e):
m = (s+e)/2
merge_sort(a,s,m)
merge_sort(a,m+1,e)
merge(a,s,m,e)

if __name__ == "__main__":
a=[49,38,65,97,76,13,27,49]
s=[49,38,97,65]
print "归并排序前"
print a
print "归并排序后"
ba = copy.deepcopy(a)
aa = [0]*len(a) #归并排序需要的辅助空间
merge_sort(ba,0,len(ba)-1)
print ba

选择排序

#coding:gbk

#选择排序

import copy

#经典选择排序---简单选择排序

def select_sort(a):
for i in xrange(len(a)-1):
m=i #保存要交换的位置
t=a[i] #记录当前最小值
for j in xrange(i+1,len(a)):
if(t>a[j]):
m = j
t = a[j]
#交换
temp = a[m]
a[m] = a[i]
a[i] = temp
return a

#堆排序----大根堆实现从小到大的排序
def heap_adjust(a,i,ml): #i是当前要调整的节点；ml是当前序列长度+1
p = i #父节点
while(p<ml):
left = 2*p+1 #左孩子
right = 2*p+2 #右孩子
if(left<ml and right<ml): #左右孩子都存在
if(a[left]>=a[right]):
if(a[left]>a[p]):
t = a[left]
a[left] = a[p]
a[p] = t
p = left
else:
break
else:
if(a[right]>a[p]):
t = a[right]
a[right] = a[p]
a[p] = t
p= right
else:
break
elif(left<ml and right>=ml): #只有左孩子，没有右孩子
if(a[left]>a[p]):
t = a[left]
a[left] = a[p]
a[p] = t
p = left
else:
break
elif(left>=ml and right>=ml): #左右孩子都不存在
break

def heap_sort(a):
#首先先建立大根堆
for i in xrange(len(a)/2-1,-1,-1):
heap_adjust(a,i,len(a))
#print a
#排序
for j in xrange(len(a)-1,0,-1):
temp = a[j]
a[j] = a[0]
a[0] = temp
heap_adjust(a,0,j)
#print "----",a
return a

if __name__ == "__main__":
a=[49,38,65,97,76,13,27,49]
aa=[97,38,27,49,76,65,49,13]
print "选择排序前"
print a
print "选择排序后"
print select_sort(copy.deepcopy(a))

print "heap排序前"
print a
print "heap排序后"
print heap_sort(copy.deepcopy(a))