关闭

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

182人阅读 评论(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网站的观点或立场

排序算法的C++实现与性能分析(插入排序、归并排序、快速排序、STOOGE排序、堆排序)

以下是对《算法导论(第二版)》
  • XD_lixin
  • XD_lixin
  • 2014-04-28 21:47
  • 1054

三种排序算法(归并排序、快速排序,堆排序)

归并排序 快速排序 堆排序 java实现
  • stephenxe
  • stephenxe
  • 2016-07-18 18:40
  • 2149

经典排序算法设计与分析(插入排序、冒泡排序、选择排序、shell排序、快速排序、堆排序、分配排序、基数排序、桶排序、归并排序)

经典的内排序算法有: 插入排序、冒泡排序、选择排序、shell排序、快速排序、堆排序、分配排序、基数排序、桶排序 为了分析所有的排序情况,给出一个模板程序用于测试,通过改写mySort函数来实现不同的排序算法。测试环境为vc++6.0。可以通过改变SIZE的大小来减少或增长排序所需的时间。 #in...
  • woshiwanghao_hi
  • woshiwanghao_hi
  • 2013-11-12 23:21
  • 4088

六大经典排序算法 java 选择排序、插入排序、冒泡排序、快速排序、堆排序、归并排序,六大经典排序算法,

1. [文件] ChaRuFa.java ~ 890B     下载(71)      ? 1 2 3 4...
  • Smurfs___zmy
  • Smurfs___zmy
  • 2016-11-04 08:54
  • 452

常见比较排序算法的实现(归并排序、快速排序、堆排序、选择排序、插入排序、希尔排序)

这篇博客主要实现一些常见的排序算法。例如: //冒泡排序 //选择排序 //简单插入排序 //折半插入排序 //希尔排序 //归并排序 //双向的快速排序 //单向的快速排序 //堆排序对于各个算法的实现原理,这里不再多说了,代码中注释较多,结合注释应该都能理解算法的原理,读者也...
  • Chengzi_comm
  • Chengzi_comm
  • 2016-05-16 22:27
  • 6079

排序算法 快速排序 归并排序 堆排序

一:插入排序思想:在对整个数组循环for(i = 0;i < n;i++)的过程中,保证此时走到的i位置的前面已经是一个有序序列,所以对于i位置的处理就是由i位置依次向前,找到第一个不满足大于此时i位置的元素的位置,插入即可。 #include<stdio.h>void Inse...
  • yangbodong22011
  • yangbodong22011
  • 2015-12-14 18:45
  • 847

C++实现快速排序,归并排序,堆排序

回忆几个重要的排序算法,留存: #include <iostream> *归并排序using namespace std; /* 归并排序 @dragonboss */ int buff1[10] = {0}; int buff2[10] = {0}; void Merg...
  • dragonboss2016
  • dragonboss2016
  • 2016-08-16 19:54
  • 219

各种常见的排序,冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序

各种常见的排序 要开始找工作了,把以前学的各种小知识复习一遍,以下是各种常见的排序的简单实现(冒泡排序,选择排序,插入排序,希尔排序,堆排序,快速排序,基数排序,桶排序),至于原理就不写出来了,代码比较简单,看一下就懂,再不行可以随意找本书或百度! #include using names...
  • xwchao2014
  • xwchao2014
  • 2015-08-04 16:41
  • 883

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法, 冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法, 冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。 冒泡法:   这是最原始,也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡:  复杂度为O(n*n)。当数据为...
  • xpp1993
  • xpp1993
  • 2013-04-19 23:36
  • 2879

程序员必知的8大排序(①直接插入排序②希尔排序③简单选择排序④堆排序⑤冒泡排序⑥快速排序⑦归并排序⑧基数排序)

8种排序之间的关系:   1,  直接插入排序    (1)基本思想:在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排 好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数 ...
  • Summer_YuXia
  • Summer_YuXia
  • 2016-11-20 14:42
  • 1108
    个人资料
    • 访问:85939次
    • 积分:1387
    • 等级:
    • 排名:千里之外
    • 原创:46篇
    • 转载:69篇
    • 译文:0篇
    • 评论:3条
    最新评论