首页 > Java开发 > 直接插入排序 希尔排序 冒泡排序 快速排序 直接选择排序 堆排序 归并排序 基数排序的算法分析和具体实现

直接插入排序 希尔排序 冒泡排序 快速排序 直接选择排序 堆排序 归并排序 基数排序的算法分析和具体实现

排序分为内部排序和外部排序 
内部排序是把待排数据元素全部调入内存中进行的排序。 
外部排序是因数量太大,把数据元素分批导入内存,排好序后再分批导出到磁盘和磁带外存介质上的排序方法。 

比较排序算法优劣的标准: 
(1)时间复杂度:它主要是分析记录关键字的比较次数和记录的移动次数 
(2)空间复杂度 :算法中使用的内存辅助空间的多少 
(3)稳定性:若两个记录A和B的关键字值相等,但排序后A、B的先后次序保持不变,则称这种排序算法是稳定的 

内部排序: 
1)插入排序(直接插入排序、希尔排序) 
2)交换排序(冒泡排序、快速排序) 
3)选择排序(直接选择排序、堆排序) 
4)归并排序 
5)分配排序(基数排序) 


插入排序的基本思想是: 
每步将一个待排序的数据元素,按其关键码大小,插入到前面已经排好序的一组数据元素的适当位置上,直到数据元素全部插入为止。 

常用的插入排序 
(1)直接插入排序 
(2)希尔排序 

1.直接插入排序 

其基本思想是:顺序地把待排序的数据元素按其关键字值的大小插入到已排序数据元素子集合的适当位置。 

算法分析: 
(1)时间效率: 因为在最坏情况下,所有元素的比较次数总和为(0+1+…+n-1)→O(n2)。其他情况下也要考虑移动元素的次数。 故时间复杂度为O(n2) 
(2)空间效率:仅占用1个缓冲单元——O(1) 
(3)算法的稳定性:稳定 

 

2.希尔(shell)排序(又称缩小增量排序) 
(1)基本思想:把整个待排序的数据元素分成若干个小组,对同一小组内的数据元素用直接插入法排序;小组的个数逐次缩小,当完成了所有数据元素都在一个组内的排序后排序过程结束。            
(2)技巧:小组的构成不是简单地“逐段分割”,而是将相隔某个增量dk的记录组成一个小组,让增量dk逐趟缩短(例如依次取5,3,1),直到dk=1为止。 
(3)优点:让关键字值小的元素能很快前移,且序列若基本有序时,再用直接插入排序处理,时间效率会高很多。 

 


选择排序 
基本思想是:每次从待排序的数据元素集合中选取关键字最小(或最大)的数据元素放到数据元素集合的最前(或最后),数据元素集合不断缩小,当数据元素集合为空时选择排序结束。 
常用的选择排序算法: 
(1)直接选择排序 
(2)堆排序 

1.直接选择排序 
基本思想是:从待排序的数据元素集合中选取关键字最小的数据元素并将它与原始数据元素集合中的第一个数据元素交换位置;然后从不包括第一个位置上数据元素的集合中选取关键字最小的数据元素并将它与原始数据元素集合中的第二个数据元素交换位置;如此重复,直到数据元素集合中只剩一个数据元素为止。 

优点:实现简单 
缺点:每趟只能确定一个元素,表长为n时需要n-1趟 

算法分析 
时间效率: O(n2)——虽移动次数较少,但比较次数仍多。 
空间效率:O(1)——没有附加单元(仅用到1个temp) 
算法的稳定性:不稳定 

 

2.堆排序 
基本思想:把待排序的数据元素集合构成一个完全二叉树结构,则每次选择出一个最大(或最小)的数据元素只需比较完全二叉树的高度次,即log2n次,则排序算法的时间复杂度就是O(nlog2n)。 

堆的定义 
堆分为最大堆和最小堆两种。定义如下: 
设数组a中存放了n个数据元素,数组下标从0开始,如果当数组下标2i+1<n时有:a[i].key≥a[2i+1].key(a[i].key≤a[2i+1].key);如果当数组下标2i+2<n时有:a[i].key≥a[2i+2].key (a[i].key≤a[2i+2].key),则这样的数据结构称为最大堆(最小堆)。 

 

性质: 
(1)最大堆的根结点是堆中值最大的数据元素,最小堆的根结点是堆中值最小的数据元素,我们称堆的根结点元素为堆顶元素。 
(2)对于最大堆,从根结点到每个叶结点的路径上,数据元素组成的序列都是递减有序的;对于最小堆,从根结点到每个叶结点的路径上,数据元素组成的序列都是递增有序的。 

堆排序的基本思想是: 
  循环执行如下过程直到数组为空: 
(1)把堆顶a[0]元素(为最大元素)和当前最大堆的最后一个元素交换; 
(2)最大堆元素个数减1; 
(3)由于第(1)步后根结点不再满足最大堆的定义,所以调整根结点使之满足最大堆的定义 

 

算法分析: 
时间效率:O(nlog2n)。因为整个排序过程中需要调用n-1次堆顶点的调整,而每次堆排序算法本身耗时为log2n; 
空间效率:O(1)。仅在第二个for循环中交换记录时用到一个临时变量temp。 
稳定性: 不稳定。 
优点:对小文件效果不明显,但对大文件有效。 



交换排序 
基本思想是:利用交换数据元素的位置进行排序的方法。 
交换排序的主要算法有: 
1)冒泡排序 
2)快速排序 

1.冒泡排序 
基本思想:每趟不断将数据元素两两比较,并按“前小后大”(或“前大后小”)规则交换。 
优点:每趟结束时,不仅能挤出一个最大值到最后面位置,还能同时部分理顺其他元素;一旦下趟没有交换发生,还可以提前结束排序。 

 

算法分析: 
 

2 .快速排序 
基本思想:从待排序列中任取一个元素 (例如取第一个) 作为中心,所有比它小的元素一律前放,所有比它大的元素一律后放,形成左右两个子表;然后再对各子表重新选择中心元素并依此规则调整,直到每个子表的元素只剩一个。此时便为有序序列了。 
优点:因为每趟可以确定不止一个元素的位置,而且呈指数增加,所以特别快。 

 

 

算法分析: 
时间效率:O(nlog2n) —因为每趟确定的元素呈指数增加 
空间效率:O(log2n)—因为递归要用堆栈 
稳 定 性: 不 稳 定 —因为有跳跃式交换。 


归并排序 
归并排序主要是二路归并排序,基本思想是:可以把一个长度为n 的无序序列看成是 n 个长度为 1 的有序子序列 ,首先做两两归并,得到 n / 2 个长度为 2 的有序子序列 ;再做两两归并,…,如此重复,直到最后得到一个长度为 n 的有序序列。 

 


基数排序 
其基本思想是: 
设待排序的数据元素关键字是m位d进制整数(不足m位的关键字在高位补0),设置d个桶,令其编号分别为0,1,2,…,d-1。首先按关键字最低位的数值依次把各数据元素放到相应的桶中,然后按照桶号从小到大和进入桶中数据元素的先后次序收集分配在各桶中的数据元素,这样就形成了数据元素集合的一个新的排列,我们称这样的一次排序过程为一次基数排序;再对一次基数排序得到的数据元素序列按关键字次低位的数值依次把各数据元素放到相应的桶中,然后按照桶号从小到大和进入桶中数据元素的先后次序收集分配在各桶中的数据元素;这样的过程重复进行,当完成了第m次基数排序后,就得到了排好序的数据元素序列。 

 

基数排序算法进出桶中的数据元素序列满足先进先出的原则,桶实际就是队列。实现基数排序算法时,有基于顺序队列和基于链式队列两种不同的实现方法。 
在基于链式队列的基数排序算法中,可以把d个队列设计成一个队列数组(设队列数组名为tub),队列数组的每个元素中包括两个域: front域和rear域。front域用于指示队头,rear域用于指示队尾。当第i(i=0,1,2,…,d-1)个队列中有数据元素要放入时,就在队列数组的相应元素tub[i]中的队尾位置插入一个结点。基于链式队列基数排序算法的存储结构示意图如下图所示。 

 

基数排序算法分析 
特点:不用比较和移动,改用分配和收集,时间效率高! 
时间复杂度为:O (mn)。 
空间复杂度:O(n). 
稳定性:稳定。(一直前后有序)。 

总结: 
 

java中具体代码实现 

冒泡排序 简单选择排序 直接插入排序 希尔排序 

Java代码
  1. import java.util.Random;  
  2.   
  3. public class Demo {  
  4. public static void main(String[] args) {  
  5.       
  6.     int [] src=createArray(5);  
  7.     System.out.println("********冒泡排序前数组原始数据:");  
  8.     printArray(src);  
  9.     System.out.println("********冒泡排序后:");  
  10.     printArray(maopao(src));  
  11.       
  12.     src=createArray(5);  
  13.     System.out.println("********简单选择排序前数组原始数据:");  
  14.     printArray(src);  
  15.     System.out.println("********简单选择排序后:");  
  16.     printArray(xuanze(src));  
  17.       
  18.     src=createArray(5);  
  19.     System.out.println("********直接插入排序前数组原始数据:");  
  20.     printArray(src);  
  21.     System.out.println("********直接插入排序后:");  
  22.     printArray(charu(src));  
  23.   
  24.       
  25.     src=createArray(5);  
  26.     System.out.println("********希尔排序前数组原始数据:");  
  27.     printArray(src);  
  28.     System.out.println("********希尔排序后:");  
  29.     printArray(shell(src));  
  30. }  
  31. //生成一个乱序的 指定长度的原始数组  
  32. public static int[] createArray(int size){  
  33.     //初始化数组  
  34.     int [] x=new int[size];  
  35.     for(int i=0;i<x.length;i++){  
  36.         //创建一个随机对象  
  37.         Random r=new Random();  
  38.         x[i]=r.nextInt(100);  
  39.     }  
  40.       
  41.     return x;  
  42. }  
  43. //打印出数组中的元素  
  44. public static void printArray(int [] x){  
  45.     //如果要打印的数组为null,则不打印  
  46.     if(x==null){  
  47.         return ;  
  48.     }  
  49.     for(int i=0;i<x.length;i++){  
  50.         System.out.println(x[i]);  
  51.     }  
  52. }  
  53. //冒泡排序  
  54. public static int[] maopao(int [] x){  
  55.     for(int i=0;i<x.length;i++){  
  56.         for(int j=i+1;j<x.length;j++){  
  57.             if(x[i]>x[j]){  
  58.                 int temp=x[j];  
  59.                 x[j]=x[i];  
  60.                 x[i]=temp;  
  61.             }  
  62.         }  
  63.     }  
  64.      return x;  
  65. }  
  66. //简单选择排序  
  67. public static int[] xuanze(int [] x){  
  68.     for(int i=0;i<x.length;i++){  
  69.         int lowerindex=i;  
  70.         //找出最小的一个索引  
  71.         for(int j=i+1;j<x.length;j++){  
  72.             if(x[j]<x[lowerindex]){  
  73.                 lowerindex=j;  
  74.             }  
  75.         }  
  76.         //交换  
  77.      int temp=x[i];  
  78.      x[i]=x[lowerindex];  
  79.      x[lowerindex]=temp;   
  80.     }  
  81.     return x;  
  82. }  
  83. //直接插入排序  
  84. public static int[] charu(int [] x){  
  85.     for(int i=1;i<x.length;i++){  
  86.         for(int j=i;j>0;j--){  
  87.             if(x[j]<x[j-1]){  
  88.                 int temp=x[j];  
  89.                  x[j]=x[j-1];  
  90.                 x[j-1]=temp;  
  91.             }  
  92.         }  
  93.     }  
  94.     return x;  
  95. }  
  96. //希尔排序  
  97. public static int[] shell(int [] x){  
  98.     //分组  
  99.     for(int increment=x.length/2;increment>0;increment/=2){  
  100.         //每个组内排序  
  101.         for(int i=increment;i<x.length;i++){  
  102.             int temp=x[i];  
  103.             int j=0;  
  104.             for(j=i;j>=increment;j-=increment){  
  105.                 if(temp<x[j-increment]){  
  106.                     x[j]=x[j-increment];  
  107.                  }else {  
  108.                      break;  
  109.                  }  
  110.             }  
  111.             x[j]=temp;    
  112.         }  
  113.     }  
  114.     return x;  
  115. }  
  116.   
  117.   
  118. }  



快速排序 

Java代码
  1. import java.util.Random;  
  2.   
  3. public class kaisu {  
  4. public static void main(String[] args) {  
  5.     int [] src=createArray(5);  
  6.     System.out.println("********快速排序前数组原始数据:");  
  7.     printArray(src);  
  8.     System.out.println("********快速排序后:");  
  9.     printArray(kuaisu(src));  
  10. }  
  11.   
  12. public static int[] createArray(int size){  
  13.     //初始化数组  
  14.     int [] x=new int[size];  
  15.     for(int i=0;i<x.length;i++){  
  16.         //创建一个随机对象  
  17.         Random r=new Random();  
  18.         x[i]=r.nextInt(100);  
  19.     }  
  20.       
  21.     return x;  
  22. }  
  23. public static void printArray(int [] x){  
  24.     //如果要打印的数组为null,则不打印  
  25.     if(x==null){  
  26.         return ;  
  27.     }  
  28.     for(int i=0;i<x.length;i++){  
  29.         System.out.println(x[i]);  
  30.     }  
  31. }  
  32. public static int[] kuaisu(int [] x){  
  33.         quick(x);  
  34.      return x;  
  35. }  
  36. public static void quick(int [] x){  
  37.     if(x.length>0){  
  38.         quicksort(x,0,x.length-1);  
  39.     }  
  40. }  
  41. public static void quicksort(int [] x,int low,int high){  
  42.     //如果不加这个判断递归会无法退出导致堆栈溢出异常  
  43.     if(low<high){  
  44.         int middle=getmiddle(x,low,high);  
  45.         quicksort(x,0,middle-1);  
  46.         quicksort(x,middle+1,high);  
  47.           
  48.     }  
  49. }  
  50. public static int getmiddle(int [] x,int low,int high){  
  51.     int temp=x[low];//基准元素  
  52.     while(low<high){  
  53.         //找到比基准元素小的元素位置  
  54.         while(low<high&&x[high]>=temp){  
  55.             high--;  
  56.         }  
  57.         x[low]=x[high];  
  58.         while(low<high&&x[low]<=temp){  
  59.             low++;  
  60.         }  
  61.         x[high]=x[low];   
  62.     }  
  63.     x[low]=temp;  
  64.     return low;  
  65. }  
  66. }  



堆排序 

Java代码
  1. import java.util.Random;  
  2.   
  3. public class Heap {  
  4.     public static void main(String[] args) {  
  5.         int [] src=createArray(5);  
  6.         System.out.println("********堆排序前数组原始数据:");  
  7.         printArray(src);  
  8.         System.out.println("********堆排序后:");  
  9.         printArray(heap(src));  
  10.     }  
  11.   
  12.     public static int[] createArray(int size){  
  13.         //初始化数组  
  14.         int [] x=new int[size];  
  15.         for(int i=0;i<x.length;i++){  
  16.             //创建一个随机对象  
  17.             Random r=new Random();  
  18.             x[i]=r.nextInt(100);  
  19.         }  
  20.           
  21.         return x;  
  22.     }  
  23.     public static void printArray(int [] x){  
  24.         //如果要打印的数组为null,则不打印  
  25.         if(x==null){  
  26.             return ;  
  27.         }  
  28.         for(int i=0;i<x.length;i++){  
  29.             System.out.println(x[i]);  
  30.         }  
  31.     }  
  32.     public static int[] heap(int [] x){  
  33.          //循环建堆   
  34.          for(int i=0;i<x.length;i++){  
  35.             //建堆   
  36.              buildMaxHeap(x,x.length-1-i);  
  37.             //交换堆顶和最后一个元素    
  38.             swap(x,0,x.length-1-i);            
  39.          }  
  40.          return x;  
  41.     }  
  42.     //对x数组从0到lastIndex建大顶堆  
  43. public static void buildMaxHeap(int [] x,int lastindex){  
  44.     //从lastIndex处节点(最后一个节点)的父节点开始   
  45.     for(int i=(lastindex-1)/2;i>=0;i--){  
  46.         //k保存正在判断的节点  
  47.         int k=i;  
  48.       //如果当前k节点的子节点存在  
  49.     while(k*2+1<=lastindex){  
  50.          //k节点的左子节点的索引   
  51.         int biggerindex=2*k+1;  
  52.         //如果biggerIndex小于lastIndex  
  53.         //即biggerIndex+1代表的k节点的右子节点存在  
  54.         if(biggerindex<lastindex){  
  55.              //若果右子节点的值较大   
  56.             if(x[biggerindex]<x[biggerindex+1]){  
  57.                 //biggerIndex总是记录较大子节点的索引    
  58.                 biggerindex++;  
  59.             }  
  60.         }  
  61.          //如果k节点的值小于其较大的子节点的值   
  62.         if(x[k]<x[biggerindex]){  
  63.          //交换他们       
  64.         swap(x,k,biggerindex);  
  65.          //将biggerIndex赋予k,开始while循环的下一次循环,重新保证k节点的值大于其左右子节点的值    
  66.         k=biggerindex;  
  67.         }else {  
  68.             break;  
  69.         }  
  70.     }  
  71.   }  
  72. }  
  73. //交换  
  74. public static void swap(int[] x,int i,int j){  
  75.         int temp=x[i];  
  76.         x[i]=x[j];  
  77.         x[j]=temp;  
  78.     }  
  79. }  



归并排序 

Java代码
  1. import java.util.Random;  
  2.   
  3. public class Merge {  
  4.     public static void main(String[] args) {  
  5.         int [] src=createArray(8);  
  6.         System.out.println("********归并排序前数组原始数据:");  
  7.         printArray(src);  
  8.         System.out.println("********归并排序后:");  
  9.         int [] tem=sort(src);  
  10.         printArray(tem);  
  11.     }  
  12.   
  13.     public static int[] createArray(int size){  
  14.         //初始化数组  
  15.         int [] x=new int[size];  
  16.         for(int i=0;i<x.length;i++){  
  17.             //创建一个随机对象  
  18.             Random r=new Random();  
  19.             x[i]=r.nextInt(100);  
  20.         }  
  21.           
  22.         return x;  
  23.     }  
  24.     public static void printArray(int [] x){  
  25.         //如果要打印的数组为null,则不打印  
  26.         if(x==null){  
  27.             return ;  
  28.         }  
  29.         for(int i=0;i<x.length;i++){  
  30.             System.out.println(x[i]);  
  31.         }  
  32.     }  
  33.     public static int[] sort(int [] x){  
  34.        mergesort(x,0,x.length-1);  
  35.    return  x;  
  36. }  
  37.     public static void  mergesort(int[] x,int left,int right){  
  38.     if(left<right){  
  39.         int middle=(left+right)/2;  
  40.          //对左边进行递归  
  41.         mergesort(x,left,middle);  
  42.          //对右边进行递归  
  43.         mergesort(x,middle+1,right);  
  44.         //合并  
  45.         merge(x,left,middle,right);  
  46.     }  
  47.     }  
  48.     public static void merge(int[] x,int left,int middle,int right){  
  49.         int [] temArr=new int[x.length];  
  50.         int mid=middle+1;//右边的起始位置  
  51.         int tmp=left;  
  52.         int third=left;  
  53.         while(left<=middle&&mid<=right){  
  54.               //从两个数组中选取较小的数放入中间数组  
  55.             if(x[left]<=x[mid]){  
  56.                 temArr[third++]=x[left++];  
  57.             }else {  
  58.                 temArr[third++]=x[mid++];  
  59.             }  
  60.         }  
  61.         //将剩余的部分放入中间数组  
  62.         while(left<=middle){  
  63.             temArr[third++]=x[left++];  
  64.         }  
  65.         while(mid<=right){  
  66.             temArr[third++]=x[mid++];  
  67.         }  
  68.          //将中间数组复制回原数组  
  69.         while(tmp<=right){  
  70.             x[tmp]=temArr[tmp++];  
  71.         }                 
  72.     }  
  73. }  

本文固定链接: http://www.devba.com/index.php/archives/6438.html | 开发吧

报歉!评论已关闭.