java几种常见的排序算法总结

java

[java] view plain copy

  1. /*************几种常见的排序算法总结***************************/  
  2.   
  3. package paixu;  
  4.   
  5. public class PaiXu {  
  6.    final int MAX=20;  

  7.    int num[]=new int[MAX];  

  8.    {  
  9.        System.out.print("生成的随机数组是:");  

  10.        for(int i=0;i<20;i++){  

  11.            num[i]=(int)(Math.random()*100);  

  12.            System.out.print(num[i]+" ");  

  13.        }  
  14.        System.out.println();  
  15.    }  
  16.      
  17.    int num2[]=new int[MAX]; //只用于合并排序法中  

  18.    {  
  19.        System.out.print("合并排序法需要使用的数组2是:");  

  20.        for(int i=0;i<20;i++){  

  21.            num2[i]=(int)(Math.random()*100);  

  22.            System.out.print(num2[i]+" ");  

  23.        }  
  24.        System.out.println();  
  25.    }  
  26.      
  27.    int num3[]=new int[MAX+MAX]; //用于存放合并排序法中被合并排序好的数组  

  28.      
  29.      
  30.    public PaiXu(){  

  31.        selsort(num.clone());                        //选择排序法  

  32.        insort(num.clone());                         //插入排序法  

  33.        bubsort(num.clone());                        //冒泡排序法  

  34.        shellsort(num.clone());                      //希尔排序法  

  35.        shakersort(num.clone());                     //shake排序法  

  36.        heapsort(num.clone());                       //堆排序  

  37.        quicksort_one(num.clone());                  //快速排序法(一)    

  38.        quicksort_two(num.clone());                  //快速排序法(二)  

  39.        quicksort_three(num.clone());                //快速排序法(三)  

  40.        mergesort(num.clone(),num2.clone(),num3);    //合并排序法  

  41.        basesort(num.clone());                       //基数排序法  

  42.    }  
  43.     
  44.    /*----------------------------选择排序法------------------------------------------- 

  45.           将要排序的对象分作两部份,一个是已排序的,一个是未排序的,从后端未排序部份选择一个最小值,并放入前端已排序部份的最后一个。 
  46.    -------------------------------------------------------------------------------*/  
  47.    public void selsort(int number[]) {  

  48.         int i, j, k, m, temp;  

  49.         long start,end;  

  50.           
  51.         start=System.nanoTime();  
  52.         for(i = 0; i < MAX-1; i++) {  

  53.             m = i;  
  54.             for(j = i+1; j < MAX; j++){  

  55.                 if(number[j] < number[m]){  

  56.                  m = j;  
  57.                 }  
  58.             }  
  59.             if( i != m){  

  60.                 temp=number[i];  
  61.                 number[i]=number[m];  
  62.                 number[m]=temp;  
  63.             }  
  64.         }  
  65.         end=System.nanoTime();  
  66.           
  67.         System.out.println("-----------------选择排序法------------------");  

  68.         System.out.print("排序后是:");  

  69.         for(i=0;i<=MAX-1;i++){  

  70.             System.out.print(number[i]+" ");  

  71.         }  
  72.         System.out.println();  
  73.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  74.     }  
  75.      
  76.      
  77.      
  78.    /*-------------------------插入排序法-------------------------------- 

  79.             像是玩朴克一样,我们将牌分作两堆,每次从后面一堆的牌抽出最前端的牌,然后插入前面一堆牌的适当位置 
  80.    -----------------------------------------------------------------*/  
  81.    public void insort(int number[]){  

  82.         int i, j, k, temp;  

  83.         long start,end;  

  84.           
  85.         start=System.nanoTime();  
  86.         for(j = 1; j < MAX; j++) {  

  87.             temp = number[j];  
  88.             i = j - 1;  

  89.             while(temp < number[i]) {  

  90.                 number[i+1] = number[i];  

  91.                 i--;  
  92.                 if(i == -1){  

  93.                     break;  

  94.                 }  
  95.             }  
  96.         number[i+1] = temp;  

  97.         }  
  98.         end=System.nanoTime();  
  99.           
  100.         System.out.println("-----------------插入排序法------------------");  

  101.         System.out.print("排序后是:");  

  102.         for(i=0;i<=MAX-1;i++){  

  103.             System.out.print(number[i]+" ");  

  104.         }  
  105.         System.out.println();  
  106.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  107.    }  
  108.      
  109.      
  110.    /*-----------------------------------------冒泡排序法---------------------------------------- 

  111.                    顾名思义,就是排序时,最大的元素会如同气泡一样移至右端,其利用比较相邻元素的方法,将大的元素交换至右端, 
  112.           所以大的元素会不断的往右移动,直到适当的位置为止。 
  113.                   基本的气泡排序法可以利用旗标的方式稍微减少一些比较的时间,当寻访完阵列后都没有发生任何的交换动作, 
  114.          表示排序已经完成,而无需再进行之后的回圈比较与交换动作。 
  115.    ----------------------------------------------------------------------------------------*/  
  116.    public void bubsort(int number[]){  

  117.         int i, j, k, temp, flag = 1;  

  118.         long start,end;  

  119.           
  120.         start=System.nanoTime();  
  121.         for(i = 0; i < MAX-1 && flag == 1; i++) {  

  122.             flag = 0;  

  123.             for(j = 0; j < MAX-i-1; j++) {  

  124.                 if(number[j+1] < number[j]) {  

  125.                     temp=number[j+1];  

  126.                     number[j+1]=number[j];  

  127.                     number[j]=temp;  
  128.                     flag = 1;  

  129.                 }  
  130.             }  
  131.         }  
  132.         end=System.nanoTime();  
  133.           
  134.         System.out.println("-----------------冒泡排序法------------------");  

  135.         System.out.print("排序后是:");  

  136.         for(i=0;i<=MAX-1;i++){  

  137.             System.out.print(number[i]+" ");  

  138.         }  
  139.         System.out.println();  
  140.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  141.    }  
  142.      
  143.      
  144.      
  145.    /*--------------------------shell(希尔)排序法---------------------------- 

  146.     Shell首先将间隔设定为n/2,然后跳跃进行插入排序,再来将间隔n/4,跳跃进行排序动作,再来 
  147.     间隔设定为n/8、n/16,直到间隔为1之后的最后一次排序终止,由于上一次的排序动作都会将 
  148.     固定间隔内的元素排序好,所以当间隔越来越小时,某些元素位于正确位置的机率越高,因此 
  149.     最后几次的排序动作将可以大幅减低。 
  150.     ---------------------------------------------------------------------*/  
  151.    public void shellsort(int number[]) {  

  152.         int i, j, k, gap, temp;  

  153.         long start,end;  

  154.           
  155.         start=System.nanoTime();  
  156.         gap = MAX / 2;  

  157.         while(gap > 0) {  

  158.             for(k = 0; k < gap; k++) {  

  159.                 for(i = k+gap; i < MAX; i+=gap) {  

  160.                     for(j = i - gap; j >= k; j-=gap) {  

  161.                         if(number[j] > number[j+gap]) {  

  162.                             temp=number[j];  
  163.                             number[j]=number[j+gap];  
  164.                             number[j+gap]=temp;  
  165.                         }else{  

  166.                             break;  

  167.                         }  
  168.                     }  
  169.                 }  
  170.             }  
  171.             gap /= 2;  

  172.         }  
  173.         end=System.nanoTime();  
  174.           
  175.         System.out.println("-----------------shell(希尔)排序法(改进的插入排序法)------------------");  

  176.         System.out.print("排序后是:");  

  177.         for(i=0;i<=MAX-1;i++){  

  178.             System.out.print(number[i]+" ");  

  179.         }  
  180.         System.out.println();  
  181.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  182.    }  
  183.      
  184.      
  185.      
  186.    /*---------------------Shake排序法(改良的冒泡排序法)-------------------------- 

  187.               方法就在于气泡排序的双向进行,先让气泡排序由左向右进行,再来让气泡排序由右往左进行, 
  188.               如此完成一次排序的动作,而您必须使用left与right两个旗标来记录左右两端已排序的元素位置。  
  189.     --------------------------------------------------------------------*/  
  190.    public void shakersort(int number[]) {   

  191.         int i, temp, left = 0, right = MAX - 1, shift = 0;   

  192.         long start,end;  

  193.           
  194.         start=System.nanoTime();  
  195.         while(left < right) {   

  196.             // 向右進行氣泡排序   

  197.             for(i = left; i < right; i++) {   

  198.                 if(number[i] > number[i+1]) {   

  199.                     temp=number[i];  
  200.                     number[i]=number[i+1];  

  201.                     number[i+1]=temp;  

  202.                     shift = i;   
  203.                 }   
  204.             }   
  205.             right = shift;    
  206.       
  207.             // 向左進行氣泡排序   

  208.             for(i = right; i > left; i--) {   

  209.                 if(number[i] < number[i-1]) {   

  210.                     temp=number[i];  
  211.                     number[i]=number[i-1];  

  212.                     number[i-1]=temp;   

  213.                     shift = i;   
  214.                 }   
  215.             }   
  216.             left = shift;   
  217.         }  
  218.         end=System.nanoTime();  
  219.           
  220.         System.out.println("-----------------shake排序法(改进的冒泡排序法)------------------");  

  221.         System.out.print("排序后是:");  

  222.         for(i=0;i<=MAX-1;i++){  

  223.             System.out.print(number[i]+" ");  

  224.         }  
  225.         System.out.println();  
  226.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  227.     }   
  228.      
  229.      
  230.      
  231.      
  232.    /*-----------------------heap排序(堆排序法--改进的选择排序)---------------------------- 

  233.            利用堆积树的原理,先构造一个堆积树(看堆积树的定义,笔记本上有),然后将根节点与最后的叶子节点交换,并屏蔽掉最后一个叶子节点, 
  234.            然后再将未被屏蔽的部分重新构造堆积树,然后再重复上面的步骤,直到所有的数被按顺序排好。 
  235.     --------------------------------------------------------------------------------*/  
  236.    public void heapsort(int number[]) {  

  237.        int i, m, p, s, temp;  

  238.        long start,end;  

  239.          
  240.        start=System.nanoTime();  
  241.        int number_temp[]=new int[MAX+1];  

  242.        for(int temp_i=1;temp_i<MAX+1;temp_i++){  

  243.            number_temp[temp_i]=number[temp_i-1];  

  244.        }  
  245.        createheap(number_temp);  
  246.        m = MAX;  
  247.        while(m > 1) {  

  248.            temp=number_temp[1];  

  249.            number_temp[1]=number_temp[m];  

  250.            number_temp[m]=temp;  
  251.            m--;  
  252.            p = 1;  

  253.            s = 2 * p;  

  254.            while(s <= m) {  

  255.                if(s < m && number_temp[s+1] > number_temp[s])  

  256.                    s++;  
  257.                if(number_temp[p] >= number_temp[s])  

  258.                    break;  

  259.                temp=number_temp[p];  
  260.                number_temp[p]=number_temp[s];  
  261.                number_temp[s]=temp;  
  262.                p = s;  
  263.                s = 2 * p;  

  264.            }  
  265.        }  
  266.        for(int temp_j=1;temp_j<MAX+1;temp_j++){  

  267.            number[temp_j-1]=number_temp[temp_j];  

  268.        }  
  269.        end=System.nanoTime();  
  270.          
  271.          
  272.         System.out.println("-----------------heap排序(堆排序法--改进的选择排序)------------------");  

  273.         System.out.print("排序后是:");  

  274.         for(i=0;i<=MAX-1;i++){  

  275.             System.out.print(number[i]+" ");  

  276.         }  
  277.         System.out.println();  
  278.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  279.    }  
  280.      
  281.    //将原数组构造为从下标1开始的一个新数组,便于处理,同时将这个新数组构造为最初始的堆积树结构  

  282.    public void createheap(int number[]) {  

  283.        int i, s, p, temp;  

  284.        int heap[] = new int[MAX+1];  

  285.        for(i = 1; i <= MAX; i++) {  

  286.            heap[i] = number[i];  
  287.            s = i;  
  288.            p = i / 2;  

  289.            while(s >= 2 && heap[p] < heap[s]) {  

  290.                temp=heap[p];  
  291.                heap[p]=heap[s];  
  292.                heap[s]=temp;  
  293.                s = p;  
  294.                p = s / 2;  

  295.            }  
  296.        }  
  297.        for(i = 1; i <= MAX; i++){  

  298.           number[i] = heap[i];   
  299.        }  
  300.    }  
  301.      
  302.      
  303.      
  304.      
  305.      
  306.      
  307.    /*-----------------------快速排序法(一)--------------------------------------------- 

  308.     这边所介绍的快速演算如下:将最左边的数设定为轴,并记录其值为s 
  309.     廻圈处理: 
  310.     令索引i 从数列左方往右方找,直到找到大于s 的数 
  311.     令索引j 从数列左右方往左方找,直到找到小于s 的数 
  312.     如果i >= j,则离开回圈 
  313.     如果i < j,则交换索引i与j两处的值 
  314.     将左侧的轴与j 进行交换 
  315.     对轴左边进行递回 
  316.     对轴右边进行递回   
  317.     --------------------------------------------------------------------------------*/  
  318.    public void quicksort_one(int number[]){  

  319.        long start,end;  

  320.          
  321.        start=System.nanoTime();  
  322.        quicksort_1(number,0,MAX-1);  

  323.        end=System.nanoTime();  
  324.          
  325.         System.out.println("-----------------快速排序法( 一 )------------------");  

  326.         System.out.print("排序后是:");  

  327.         for(int i=0;i<=MAX-1;i++){  

  328.             System.out.print(number[i]+" ");  

  329.         }  
  330.         System.out.println();  
  331.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  332.          
  333.          
  334.    }  
  335.      
  336.      
  337.    public void quicksort_1(int number[],int left,int right) {  

  338.        int i, j, s, temp;  

  339.        if(left < right) {  

  340.            s = number[left];  
  341.            i = left;  
  342.            j = right + 1;  

  343.            while(true) {  

  344.                // 向右找  

  345.                while(i + 1 < number.length && number[++i] < s) ;  

  346.                // 向左找  

  347.                while(j -1 > -1 && number[--j] > s) ;  

  348.                if(i >= j)  

  349.                    break;  

  350.                temp=number[i];  
  351.                number[i]=number[j];  
  352.                number[j]=temp;  
  353.            }  
  354.        number[left] = number[j];  
  355.        number[j] = s;  
  356.        quicksort_1(number, left, j-1); // 对左边进行递回  

  357.        quicksort_1(number, j+1, right); // 对右边进行递回  

  358.        }  
  359.    }  
  360.      
  361.      
  362.      
  363.    /*-----------------------快速排序法(二)--------------------------------------------- 

  364.     在这个例子中,取中间的元素s作比较,同样的先得右找比s大的索引i,然后找比s小的 
  365.     索引j,只要两边的索引还没有交会,就交换i 与j 的元素值,这次不用再进行轴的交换了, 
  366.     因为在寻找交换的过程中,轴位置的元素也会参与交换的动作,例如: 
  367.     41 24 76 11 45 64 21 69 19 36 
  368.     首先left为0,right为9,(left+right)/2 = 4(取整数的商),所以轴为索引4的位置,比较的元素是 
  369.     45,您往右找比45大的,往左找比45小的进行交换: 
  370.     41 24 76* 11 [45] 64 21 69 19 *36 
  371.     41 24 36 11 45* 64 21 69 19* 76 
  372.     41 24 36 11 19 64* 21* 69 45 76 
  373.    [41 24 36 11 19 21] [64 69 45 76] 
  374.     完成以上之后,再初别对左边括号与右边括号的部份进行递回,如此就可以完成排序的目的。 
  375.    --------------------------------------------------------------------------------*/  
  376.    public void quicksort_two(int number[]){  

  377.        long start,end;  

  378.          
  379.        start=System.nanoTime();  
  380.        quicksort_2(number,0,MAX-1);  

  381.        end=System.nanoTime();  
  382.          
  383.         System.out.println("-----------------快速排序法( 二 )------------------");  

  384.         System.out.print("排序后是:");  

  385.         for(int i=0;i<=MAX-1;i++){  

  386.             System.out.print(number[i]+" ");  

  387.         }  
  388.         System.out.println();  
  389.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  390.    }  
  391.      
  392.      
  393.    public void quicksort_2(int number[], int left, int right) {  

  394.        int i, j, s, temp;  

  395.        if(left < right) {  

  396.            s = number[(left+right)/2];  

  397.            i = left - 1;  

  398.            j = right + 1;  

  399.            while(true) {  

  400.                while(number[++i] < s) ; // 向右找  

  401.                while(number[--j] > s) ; // 向左找  

  402.                if(i >= j)  

  403.                    break;  

  404.                temp=number[i];  
  405.                number[i]=number[j];  
  406.                number[j]=temp;  
  407.            }  
  408.        quicksort_2(number, left, i-1); // 对左边进行递回  

  409.        quicksort_2(number, j+1, right); // 对右边进行递回  

  410.        }  
  411.    }  
  412.      
  413.      
  414.      
  415.      
  416.    /*-----------------------快速排序法(三)--------------------------------------------- 

  417.             先说明这个快速排序法的概念,它以最右边的值s作比较的标准,将整个数列分为三个部份, 
  418.     一个是小于s的部份,一个是大于s的部份,一个是未处理的部份,如下所示: 
  419.             i           j 
  420.     --------|-----------|----------|s 
  421.         小于s     大于s         未处理 
  422.     在排序的过程中,i 与j 都会不断的往右进行比较与交换,最后数列会变为以下的状态: 
  423.     -------------|-----------------|s 
  424.         小于s             大于s 
  425.     然后将s的值置于中间,接下来就以相同的步骤会左右两边的数列进行排序的动作,如下所示: 
  426.     -------------|s|--------------- 
  427.         小于s             大于s 
  428.     然后采用递归的方法重复上面的步骤,就可以实现排序了。 
  429.    --------------------------------------------------------------------------------*/  
  430.    public void quicksort_three(int number[]){  

  431.        long start,end;  

  432.          
  433.        start=System.nanoTime();  
  434.        quicksort_3(number,0,MAX-1);  

  435.        end=System.nanoTime();  
  436.          
  437.         System.out.println("-----------------快速排序法( 三 )------------------");  

  438.         System.out.print("排序后是:");  

  439.         for(int i=0;i<=MAX-1;i++){  

  440.             System.out.print(number[i]+" ");  

  441.         }  
  442.         System.out.println();  
  443.         System.out.println("排序使用时间:"+(end-start)+" ns");  

  444.          
  445.    }  
  446.      
  447.      
  448.    public int partition(int number[], int left, int right) {  

  449.        int i, j, s, temp;  

  450.        s = number[right];  
  451.        i = left - 1;  

  452.        for(j = left; j < right; j++) {  

  453.            if(number[j] <= s) {  

  454.                i++;  
  455.                temp=number[i];  
  456.                number[i]=number[j];  
  457.                number[j]=temp;  
  458.            }  
  459.        }  
  460.        temp=number[i+1];  

  461.        number[i+1]=number[right];  

  462.        number[right]=temp;  
  463.        return i+1;  

  464.    }  
  465.      
  466.    public void quicksort_3(int number[], int left, int right) {  

  467.        int q;  

  468.        if(left < right) {  

  469.            q = partition(number, left, right);  
  470.            quicksort_3(number, left, q-1);  

  471.            quicksort_3(number, q+1, right);  

  472.        }  
  473.    }  
  474.      
  475.      
  476.      
  477.      
  478.      
  479.    /*-----------------------合并排序法--------------------------------------------- 

  480.              合并排序法基本是将两笔已排序的资料合并并进行排序,如果所读入的资料尚未排序, 
  481.              可以先利用其它的排序方式来处理这两笔资料,然后再将排序好的这两笔资料合并。 
  482.              合并排序法中用到了  快速排序法(三) 
  483.    --------------------------------------------------------------------------------*/  
  484.      
  485.    public void mergesort(int number1[],int number2[],int number3[]){  

  486.        long start,end;  

  487.          
  488.        start=System.nanoTime();  
  489.        quicksort_3(number1,0,MAX-1);  

  490.        quicksort_3(number2,0,MAX-1);  

  491.        mergesort_merge(number1,MAX,number2,MAX,number3);  
  492.        end=System.nanoTime();  
  493.          
  494.        System.out.println("-----------------合并排序法------------------");  

  495.        System.out.print("排序后是:");  

  496.        for(int i=0;i<=MAX+MAX-1;i++){  

  497.             System.out.print(number3[i]+" ");  

  498.        }  
  499.        System.out.println();  
  500.        System.out.println("排序使用时间:"+(end-start)+" ns");     

  501.    }  
  502.      
  503.      
  504.    public void mergesort_merge(int number1[], int M, int number2[], int N, int number3[]) {  

  505.        int i = 0, j = 0, k = 0;  

  506.        while(i < M && j < N) {  

  507.            if(number1[i] <= number2[j]){  

  508.                number3[k++] = number1[i++];  
  509.            }else{  

  510.                number3[k++] = number2[j++];  
  511.            }     
  512.        }  
  513.        while(i < M){  

  514.            number3[k++] = number1[i++];  
  515.        }    
  516.        while(j < N){  

  517.            number3[k++] = number2[j++];  
  518.        }  
  519.    }  
  520.      
  521.      
  522.      
  523.      
  524.    /*-----------------------基数排序法--------------------------------------------- 

  525.             基数排序的方式可以采用LSD(Least sgnificant digital)或MSD(Most sgnificant digital), 
  526.     LSD的排序方式由键值的最右边开始,而MSD则相反,由键值的最左边开始。 
  527.     以LSD为例,假设原来有一串数值如下所示: 
  528.     73, 22, 93, 43, 55, 14, 28, 65, 39, 81 
  529.     首先根据个位数的数值,在走访数值时将它们分配至编号0到9的桶子中: 
  530.     0   1   2   3   4   5   6   7   8   9 
  531.         81              65              39 
  532.                 43  14  55          28 
  533.                 93 
  534.             22  73 
  535.     接下来将这些桶子中的数值重新串接起来,成为以下的数列: 
  536.     81, 22, 73, 93, 43, 14, 55, 65, 28, 39 
  537.     接着再进行一次分配,这次是根据十位数来分配: 
  538.     接下来将这些桶子中的数值重新串接起来,成为以下的数列: 
  539.     0   1   2   3   4   5   6   7   8   9 
  540.             28  39 
  541.         14  22      43  55  65  73  81  93 
  542.     14, 22, 28, 39, 43, 55, 65, 73, 81, 93 
  543.     这时候整个数列已经排序完毕;如果排序的对象有三位数以上,则持续进行以上的动作直至最 
  544.     高位数为止。 
  545.     LSD的基数排序适用于位数小的数列,如果位数多的话,使用MSD的效率会比较好,MSD的方 
  546.     式恰与LSD相反,是由高位数为基底开始进行分配,其他的演算方式则都相同。       
  547.    --------------------------------------------------------------------------------*/  
  548.    public void basesort(int number[]){  

  549.        int temp[][] = new int[MAX][MAX];  

  550.        int order[] = new int[MAX];  

  551.        int i, j, k, n, lsd;  

  552.        long start,end;  

  553.        k = 0;  

  554.        n = 1;  

  555.          
  556.          
  557.        start=System.nanoTime();  
  558.        while(n <= 10) {  

  559.            for(i = 0; i < MAX; i++) {  

  560.                lsd = ((number[i] / n) % 10);  

  561.                temp[lsd][order[lsd]] = number[i];  
  562.                order[lsd]++;  
  563.            }  
  564.            //重新排列  

  565.            for(i = 0; i < MAX; i++) {  

  566.                if(order[i] != 0)  

  567.                    for(j = 0; j < order[i]; j++) {  

  568.                        number[k] = temp[i][j];  
  569.                        k++;  
  570.                    }  
  571.                order[i] = 0;  

  572.            }  
  573.            n *= 10;  

  574.            k = 0;  

  575.         }  
  576.        end=System.nanoTime();  
  577.          
  578.        System.out.println("-----------------基数排序法------------------");  

  579.        System.out.print("排序后是:");  

  580.        for(int ii=0;ii<=MAX-1;ii++){  

  581.             System.out.print(number[ii]+" ");  

  582.        }  
  583.        System.out.println();  
  584.        System.out.println("排序使用时间:"+(end-start)+" ns");  

  585.    }  
  586.      
  587.   
  588.    public static void main(String[] args){  

  589.        System.out.println("以下的测试时间仅供参考...");  

  590.        new PaiXu();  

  591.    }  
  592.      
  593. }  

以上代码的运行结果如下所示:

[plain] view plain copy

    1. 以下的测试时间仅供参考...  
    2. 生成的随机数组是:53 82 61 70 75 31 30 68 22 56 48 23 12 74 13 85 69 62 21 55   
    3. 合并排序法需要使用的数组2是:2 12 48 18 93 13 98 87 55 77 89 56 6 31 56 38 59 76 90 30   
    4. -----------------选择排序法------------------  
    5. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    6. 排序使用时间:7815 ns  
    7. -----------------插入排序法------------------  
    8. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    9. 排序使用时间:7475 ns  
    10. -----------------冒泡排序法------------------  
    11. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    12. 排序使用时间:18008 ns  
    13. -----------------shell(希尔)排序法(改进的插入排序法)------------------  
    14. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    15. 排序使用时间:11212 ns  
    16. -----------------shake排序法(改进的冒泡排序法)------------------  
    17. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    18. 排序使用时间:14610 ns  
    19. -----------------heap排序(堆排序法--改进的选择排序)------------------  
    20. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    21. 排序使用时间:15969 ns  
    22. -----------------快速排序法( 一 )------------------  
    23. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    24. 排序使用时间:8834 ns  
    25. -----------------快速排序法( 二 )------------------  
    26. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    27. 排序使用时间:9853 ns  
    28. -----------------快速排序法( 三 )------------------  
    29. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    30. 排序使用时间:10533 ns  
    31. -----------------合并排序法------------------  
    32. 排序后是:2 6 12 12 13 13 18 21 22 23 30 30 31 31 38 48 48 53 55 55 56 56 56 59 61 62 68 69 70 74 75 76 77 82 85 87 89 90 93 98   
    33. 排序使用时间:20387 ns  
    34. -----------------基数排序法------------------  
    35. 排序后是:12 13 21 22 23 30 31 48 53 55 56 61 62 68 69 70 74 75 82 85   
    36. 排序使用时间:8495 ns 

以上是 java几种常见的排序算法总结 的全部内容, 来源链接: utcz.com/z/392279.html

回到顶部