版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/vivizhangyan/article/details/81737612
（1）冒泡排序
def bubbleSort(L):
assert(type(L)==type(['']))
length = len(L)
if length==0 or length==1:
return L
for i in xrange(length):
for j in xrange(length-1-i):
if L[j] < L[j+1]:
temp = L[j]
L[j] = L[j+1]
L[j+1] = temp
return L
pass选择排序
def selectSort(L):
assert(type(L)==type(['']))
length = len(L)
if length==0 or length==1:
return L
def _max(s):
largest = s
for i in xrange(s,length):
if L[i] > L[largest]:
largest = i
return largest
for i in xrange(length):
largest = _max(i)
if i!=largest:
temp = L[largest]
L[largest] = L[i]
L[i] = temp
return L
pass插入排序
def insertSort(L):
assert(type(L)==type(['']))
length = len(L)
if length==0 or length==1:
return L
for i in xrange(1,length):
value = L[i]
j = i-1
while j>=0 and L[j]<value:
L[j+1] = L[j]
j-=1
L[j+1] = value
return L归并排序
def mergeSort(L,start,end):
assert(type(L)==type(['']))
length = len(L)
if length==0 or length==1:
return L
def merge(L,s,m,e):
left = L[s:m+1]
right = L[m+1:e+1]
while s<e:
while(len(left)>0 and len(right)>0):
if left[0]>right[0]:
L[s] = left.pop(0)
else:
L[s] = right.pop(0)
s+=1
while(len(left)>0):
L[s] = left.pop(0)
s+=1
while(len(right)>0):
L[s] = right.pop(0)
s+=1
pass
if start<end:
mid = int((start+end)/2)
mergeSort(L,start,mid)
mergeSort(L,mid+1,end)
merge(L,start,mid,end)快速排序
（1）如果不考虑空间的申请，也就是不在元素组就行排序的话，这个算法写起来就是基本的递归调用，在python中尤为突出，如下：
def quickSortPython(l):
assert(type(l)==type(['']))
length = len(l)
if length==0 or length==1:
return l
if len(l)<=1:
return l
left = [i for i in l[1:] if i>l[0]]
right = [i for i in l[1:] if i<=l[0]]
return quickSortPython(left) +[l[0],]+ quickSortPython(right)（2） python的这种列表推导的写法，简化了代码书写，却牺牲了资源——这也就是快速排序难的部分，需要在原数组进行排序，也就是不使用额外的空间。
解决这个问题的关键，是在进行“分”的时候，不只从数组的一边进行比较，而是从数组的两边同时进行比较，然后相互补位。代码如下：
def quickSort(l,s,e):
assert(type(l)==type(['']))
length = len(l)
if length==0 or length==1:
return l
def partition(l,start,end):
pivot = l[start]
while start<end-1:
while end>start and l[end]<pivot:
end-=1
l[start] = l[end]
while end>start and l[start]>pivot:
start+=1
l[end] = l[start]
l[start] = pivot
return start
pass
#random pivot
def random_partition(l,start,end):
i = random.randint(start,end)
temp = l[i]
l[i] = l[start]
l[start] = temp
return partition(l,start,end)
if s<e:
m = partition (l,s,e)
quickSort(l,s,m-1)
quickSort(l,m+1,e)
return l
pass堆排序
def heapSort(L):
assert(type(L)==type(['']))
length = len(L)
if length==0 or length==1:
return L
def sift_down(L,start,end):
root = start
while True:
child = 2*root + 1
if child > end:break
if child+1 <= end and L[child] > L[child+1]:
child += 1
if L[root] > L[child]:
L[root],L[child] = L[child],L[root]
root = child
else:
break
for start in range((len(L)-2)/2,-1,-1):
sift_down(L,start,len(L)-1)
for end in range(len(L)-1,0,-1):
L[0],L[end] = L[end],L[0]
sift_down(L,0,end-1)
return L二叉树排序
def binaryTreeSort(l):
assert(type(l)==type(['']))
length = len(l)
if length==0 or length==1:
return l
class Node:
def __init__(self,value=None,left=None,right=None):
self.__value = value
self.__left = left
self.__right = right
@property
def value(self):
return self.__value
@property
def left(self):
return self.__left
@property
def right(self):
return self.__right
class BinaryTree:
def __init__(self,root=None):
self.__root = root
self.__ret=[]
@property
def result(self):
return self.__ret
def add(self,parent,node):
if parent.value>node.value:
if not parent.left:
parent.left = node
else:
self.add(parent.left,node)
pass
else:
if not parent.right:
parent.right = node
else:
self.add(parent.right,node)
def Add(self,node):
if not self.__root:
self.__root = node
else:
self.add(self.__root, node)
def show(self,node):
if not node:
return
if node.right:
self.show(node.right)
self.__ret.append(node.value)
if node.left:
self.show(node.left)
def Show(self):
self.show(self.__root)
b = BinaryTree()
for i in l:
b.Add(Node(i))
b.Show()
return b.result桶排序
def countSort(l):
assert(type(l)==type(['']))
length = len(l)
if length==0 or length==1:
return l
m = max(l)
ret = []
storage = [0]*(m+1)
def count(x):
storage[x]+=1
def pop(x):
tem = storage[x]
while tem>0:
ret.append(x)
tem-=1
map(lambda x:count(x),l)
map(lambda x:pop(x),xrange(m,0,-1))
return ret