关闭

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

152人阅读 评论(0) 收藏 举报

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实现:

  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实现:

  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来弹出堆中的最小元素。

  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数据结构:

  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;  


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:67161次
    • 积分:1220
    • 等级:
    • 排名:千里之外
    • 原创:46篇
    • 转载:68篇
    • 译文:0篇
    • 评论:3条
    最新评论