快速排序，归并排序，堆排序python实现

http://blog.csdn.net/u011608357/article/details/37724329

快速排序的时间复杂度最好情况下为O(n*logn),最坏情况下为O(n^2),平均情况下为O(n*logn),是不稳定的排序

归并排序的时间复杂度最好情况下为O(n*logn),最坏情况下为O(n*logn),平均情况下为O(n*logn),是稳定的排序

堆排序的时间复杂度最好情况下为O(n*logn),最坏情况下为O(n*logn),平均情况下为O(n*logn),是不稳定的排序

1.快速排序

快速排序的介绍以及C语言实现在这里：快速排序C语言实现

本文介绍的是快速排序python实现：

[python] view plain copy

1. def recurse(lista,left,right):  
2.     if left<right:  
3.         i=left;  
4.         j=right;  
5.         tmp=lista[left];  
6.         while(i<j):  
7.             while(i<j and lista[j]>=tmp):  
8.                 j=j-1;  
9.             if i<j:  
10.                 lista[i]=lista[j];  
11.                 i=i+1;  
12.             while (i<j and lista[i]<tmp):  
13.                 i=i+1;  
14.             if i<j:  
15.                 lista[j]=lista[i];  
16.                 j=j-1;  
17.         lista[i]=tmp;  
18.         recurse(lista,left,i-1);  #分治  
19.         recurse(lista,i+1,right);  
20.     return lista;  
21. def quicksort(lista):  
22.     leng=len(lista);  
23.     recurse(lista,0,leng-1);  
24.   
25. lista=[1,4,23,45,97,22,10,4];   #快速排序测试代码  
26. quicksort(lista);  
27. print lista;  

2.归并排序

归并排序及C语言实现在这里：归并排序C语言实现

本文介绍的是归并排序python实现：

[python] view plain copy

1. def merge(lista,left,mid,right):   # 合并有序数组  
2.     i=left;  
3.     j=mid+1;  
4.     tmp=[];  
5.     while(i<=mid and j<=right):  
6.         if lista[i]<= lista[j]:  
7.             tmp.append(lista[i]);  
8.             i=i+1;  
9.         else:  
10.             tmp.append(lista[j]);  
11.             j=j+1;  
12.     while(i<=mid):  
13.         tmp.append(lista[i]);  
14.         i=i+1;  
15.     while(j<=right):  
16.         tmp.append(lista[j]);  
17.         j=j+1;  
18.     i=0;   
19.     while(i<right-left+1):  
20.         lista[left+i]=tmp[i];  
21.         i=i+1;  
22. def mergerecurse(lista,left,right):  
23.     if left<right:  
24.         mid=int((right+left)/2);  
25.         mergerecurse(lista,left,mid);  
26.         mergerecurse(lista,mid+1,right);  
27.         merge(lista,left,mid,right);  
28.     return lista;  
29. def mergesort(lista):                                
30.     leng=len(lista);  
31.     mergerecurse(lista,0,leng-1);  
32.   
33. lista=[1,4,23,45,97,22,10,4];       #测试代码  
34. mergesort(lista);  
35. print lista;  
36.       

3.堆排序

堆排序及C语言实现在这里：堆排序C语言实现

本文介绍的是堆排序python实现：

python中提供了堆这种数据结构，可以直接使用heap中的heappush方法来建立堆，使用heappop来弹出堆中的最小元素。

[python] view plain copy

1. from heapq import *;  
2. def heapsort(lista):  
3.     h=[];  
4.     for i in range(0,len(lista)):  
5.         heappush(h,lista[i]);  
6.     for i in range(0,len(h)):  
7.         lista[i]=heappop(h);  

也可以自行实现heap数据结构：

[python] view plain copy

1. def heapadjust(lista,s,end):  
2.     i=2*s+1;  
3.     tmp=lista[s];  
4.     while(i<=end):  
5.         if i+1<=end and lista[i+1]>lista[i]:  
6.             i=i+1;  
7.         if lista[i]<=tmp:  
8.             break;  
9.         lista[s]=lista[i];  
10.         s=i;  
11.         i=s*2+1;  
12.     lista[s]=tmp;  
13. def heapsort2(lista):  
14.     n=len(lista);  
15.     for i in range((n-1)/2,-1,-1):  
16.         heapadjust(lista,i,n-1);  
17.     for i in range(n-1,-1,-1):  
18.         lista[i],lista[0]=lista[0],lista[i];  
19.         heapadjust(lista,0,i-1);  
20. lista=[5,4,2,5,1,7];        # 堆排序测试代码  
21. heapsort(lista);  
22. print lista;