`
1028826685
  • 浏览: 939037 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类

归并排序,基数排序

 
阅读更多

转载:http://blog.csdn.net/pzhtpf/article/details/7560312

 

7、归并排序

 

(1)基本排序:归并(Merge)排序法是将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

(2)实例:

(3)用java实现

[plain] view plain copy
 
  1. import java.util.Arrays;  
  2.   
  3. public class mergingSort {  
  4. int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};  
  5. public  mergingSort(){  
  6.     sort(a,0,a.length-1);  
  7.     for(int i=0;i<a.length;i++)  
  8.         System.out.println(a[i]);  
  9. }  
  10. public void sort(int[] data, int left, int right) {  
  11.     // TODO Auto-generated method stub  
  12.     if(left<right){  
  13.         //找出中间索引  
  14.         int center=(left+right)/2;  
  15.         //对左边数组进行递归  
  16.         sort(data,left,center);  
  17.         //对右边数组进行递归  
  18.         sort(data,center+1,right);  
  19.         //合并  
  20.         merge(data,left,center,right);  
  21.           
  22.     }  
  23. }  
  24. public void merge(int[] data, int left, int center, int right) {  
  25.     // TODO Auto-generated method stub  
  26.     int [] tmpArr=new int[data.length];  
  27.     int mid=center+1;  
  28.     //third记录中间数组的索引  
  29.     int third=left;  
  30.     int tmp=left;  
  31.     while(left<=center&&mid<=right){  
  32.         //从两个数组中取出最小的放入中间数组  
  33.         if(data[left]<=data[mid]){  
  34.             tmpArr[third++]=data[left++];  
  35.         }else{  
  36.             tmpArr[third++]=data[mid++];  
  37.         }  
  38.     }  
  39.     //剩余部分依次放入中间数组  
  40.     while(mid<=right){  
  41.         tmpArr[third++]=data[mid++];  
  42.     }  
  43.     while(left<=center){  
  44.         tmpArr[third++]=data[left++];  
  45.     }  
  46.     //将中间数组中的内容复制回原数组  
  47.     while(tmp<=right){  
  48.         data[tmp]=tmpArr[tmp++];  
  49.     }  
  50.     System.out.println(Arrays.toString(data));  
  51. }  
  52.   
  53. }  
[plain] view plain copy
 
  1.   
[plain] view plain copy
 
  1.   
8、基数排序
 
(1)基本思想:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
(2)实例:

3)用java实现
[plain] view plain copy
 
  1. import java.util.ArrayList;  
  2.   
  3. import java.util.List;  
  4.   
  5.    
  6.   
  7. public class radixSort {  
  8.   
  9.          int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};  
  10.   
  11. public radixSort(){  
  12.   
  13.          sort(a);  
  14.   
  15.          for(int i=0;i<a.length;i++)  
  16.   
  17.                    System.out.println(a[i]);  
  18.   
  19. }  
  20.   
  21. public  void sort(int[] array){     
  22.   
  23.                       
  24.   
  25.                  //首先确定排序的趟数;     
  26.   
  27.         int max=array[0];     
  28.   
  29.         for(int i=1;i<array.length;i++){     
  30.   
  31.                     if(array[i]>max){     
  32.   
  33.                max=array[i];     
  34.   
  35.                     }     
  36.   
  37.                  }     
  38.   
  39.                       
  40.   
  41.         int time=0;     
  42.   
  43.                 //判断位数;     
  44.   
  45.                  while(max>0){     
  46.   
  47.                     max/=10;     
  48.   
  49.                      time++;     
  50.   
  51.                  }     
  52.   
  53.                       
  54.   
  55.         //建立10个队列;     
  56.   
  57.                  List<ArrayList> queue=new ArrayList<ArrayList>();     
  58.   
  59.                  for(int i=0;i<10;i++){     
  60.   
  61.                           ArrayList<Integer> queue1=new ArrayList<Integer>();   
  62.   
  63.                      queue.add(queue1);     
  64.   
  65.         }     
  66.   
  67.                      
  68.   
  69.                  //进行time次分配和收集;     
  70.   
  71.                  for(int i=0;i<time;i++){     
  72.   
  73.                           
  74.   
  75.                      //分配数组元素;     
  76.   
  77.                     for(int j=0;j<array.length;j++){     
  78.   
  79.                          //得到数字的第time+1位数;   
  80.   
  81.                              int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);  
  82.   
  83.                              ArrayList<Integer> queue2=queue.get(x);  
  84.   
  85.                              queue2.add(array[j]);  
  86.   
  87.                              queue.set(x, queue2);  
  88.   
  89.             }     
  90.   
  91.                      int count=0;//元素计数器;     
  92.   
  93.             //收集队列元素;     
  94.   
  95.                      for(int k=0;k<10;k++){   
  96.   
  97.                 while(queue.get(k).size()>0){  
  98.   
  99.                          ArrayList<Integer> queue3=queue.get(k);  
  100.   
  101.                              array[count]=queue3.get(0);     
  102.   
  103.                              queue3.remove(0);  
  104.   
  105.                     count++;  
  106.   
  107.               }     
  108.   
  109.             }     
  110.   
  111.                }     
  112.   
  113.                       
  114.   
  115.    }    
  116.   
  117.    
  118.   
  119. }  

 

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics