java各类排序算法及实现

时间  2019-11-10
标签 java 各类 排序算法 实现 栏目 Java 繁體版
原文   原文链接

先来看看8种排序之间的关系：javascript

 

下图是各类排序的比较：java

 

 

1，  直接插入排序算法

   （1）基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已是排shell

好顺序的，如今要把第n个数插到前面的有序数中，使得这n个数数组

也是排好顺序的。如此反复循环，直到所有排好顺序。数据结构

在插入算法中，若是有一个最小的数在数组的最后面，用插入算法就会从最后一个app

位置移动到第一个。dom

（2）实例函数

 

package cglib;性能

 

public class StringNumber {
    
      public static void insertSort(int[] a) {  
            if (a == null || a.length < 2) {  
                return;  
            }  
            int length=a.length; //数组长度  
            int j;               //当前值的位置  
            int i;               //指向j前的位置  
            int key;             //当前要进行插入排序的值  
            //从数组的第二个位置开始遍历值  
            for(j=1;j<length;j++){  
                key=a[j];  
                i=j-1;
                System.out.println(" 将i="+i);
                //a[i]比当前值大时，a[i]后移一位,空出i的位置，好让下一次循环的值后移  
                while(i>=0 && a[i]>key){
                    System.out.println("进 i="+i);
                    a[i+1]=a[i]; //将a[i]值后移  
                    i--;         //i前移  
                    System.out.println(" i="+i);
                }//跳出循环(找到要插入的中间位置或已遍历到0下标)
                System.out.println(" 退出while");
                System.out.println(" i="+i);
                a[i+1]=key;    //将当前值插入  
            }  
        }  
        
      
        public static void main(String[] args) {  
            int[] array = { 3, -1, 0, -8, 2, 1 };  
            ArrayUtils.printArray(array);  
            insertSort(array);  
            ArrayUtils.printArray(array);  
        }
}

class ArrayUtils {  
    
    public static void printArray(int[] array) {  
        System.out.print("{");  
        for (int i = 0; i < array.length; i++) {  
            System.out.print(array[i]);  
            if (i < array.length - 1) {  
                System.out.print(", ");  
            }  
        }  
        System.out.println("}");  
    }  
}  
     输出：

{3, -1, 0, -8, 2, 1}
 将i=0
进 i=0
 i=-1
 退出while
 i=-1
 将i=1
进 i=1
 i=0
 退出while
 i=0
 将i=2
进 i=2
 i=1
进 i=1
 i=0
进 i=0
 i=-1
 退出while
 i=-1
 将i=3
进 i=3
 i=2
 退出while
 i=2
 将i=4
进 i=4
 i=3
进 i=3
 i=2
 退出while
 i=2
{-8, -1, 0, 1, 2, 3}

希尔排序（最小增量排序）

基本算法：

先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，而后依次缩减增量再进行排序，待整个序列中的元 素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。由于直接插入排序在元素基本有序的状况下（接近最好状况），效率是很高的，所以希尔排序在时间效率上比前两种方法有较大提升。步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列均可以工做。

算法最开始以必定的步长进行排序,而后会继续以必定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为插入排序，这就保证了数据一 定会被排序。Donald Shell 最初建议步长选择为\frac{n}{2}而且对步长取半直到步长达到 1。虽然这样取能够比\mathcal{O}(n^2)类的算法（插入排序）更好，但这样仍然有减小平均时间和最差时间的余地。

希尔排序示例:n=10的一个数组 58 27 32 93 65 87 58 46 9 65，步长为n/2。

第一次排序 步长为 10/2 = 5

   58  27  32  93  65  87  58  46  9  65
    1A                        1B
        2A                          2B
            3A                           3B
                  4A                           4B
                      5A                           5B

    首先将待排序元素序列分组，以5为步长，(1A,1B), (2A,2B),(3A,3B)等为分组标记，大写字母表示是该组的第几个元素,数字相同的表示在同一组，这样就分红5组，即(58,87), (27,58),(32,46),(93,9),(65,65)，而后分别对各分组进行直接插入排序，排序后5组为(58,87),(27,58), (32,46),(9,93),(65,65)，分组排序只是变得各个分组内的下表，下同。

    第二次排序 步长为 5/2 = 2

    58  27  32  9  65  87  58  46  93  65

    1A       1B     

          2A      2B    

                3A      3B

                 .............................................

    第三次排序 步长为 2/2 = 1

    32  9  58  27  58  46  65  65  93  87

   1A 1B 1C 1D 1E  1F  1G 1H  1I  1J

    第四次排序 步长为 1/2 = 0 获得有序元素序列

    9  27  32  46  58  58  65  65  87  93

希尔排序的时间性能优于直接插入排序的缘由：
     ①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。
     ②当n值较小时，n和n2的差异也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差异不大。
     ③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减小，而各组的记录数目逐渐增多，但因为已经按di-1做为距离排过序，使文件较接近于有序状态，因此新的一趟排序过程也较快。

增量序列的选择：Shell排序的执行时间依赖于增量序列。
    好的增量序列的共同特征(查到的资料都这么讲)：
     ① 最后一个增量必须为1；
     ② 应该尽可能避免序列中的值(尤为是相邻的值)互为倍数的状况。     

package cglib;

 

public class StringNumber {
    
    public static void main(String[] args) {

        int[] arr = new int[]{44,33,99,10,30,20,59,78,23,48};

        System.out.print("排序前：");

        for(int o: arr) {

            System.out.print(o+" ");

        }

        System.out.println();

        shellSort(arr);

        System.out.print("排序后：");

        for(int o: arr) {

            System.out.print(o+" ");

        }

        System.out.println();

    }

    private static void shellSort(int[] arr) {

        int j;

        int len = arr.length;

        for(int val=len>>1; val>0; val>>=1) {

            //下面是对本次的全部分组作直接插入排序

            for(int i=val; i<len; i++) {
                System.out.println("for:i="+i);
                System.out.println("for:arr[i]="+arr[i]);
                System.out.println("for:val="+val);
                int temp = arr[i];

                /*

                 * 为何每次都用temp比较呢？

                 * 由于直接插入就是找到temp的合适位置。

                 * 为何temp<arr[j-val]这个条件能够放在for内呢？

                 * 由于原来的组内数据已经有序，找到位置就中止即是。

                 *

                 */

                for(j=i; j>=val&&temp<arr[j-val]; j-=val) {
                    System.out.println("er:j="+j);
                    System.out.println("er:arr[j]="+arr[j]);
                    System.out.println("er:j-val="+(j-val));
                    System.out.println("er:arr[j-val]="+arr[j-val]);
                    /*

                     * 为何是arr[j-val]不是arr[j]呢？

                     * 由于j=i开始的，并且条件是j>=val&&temp<arr[j-val]

                     */

                    arr[j] = arr[j-val];
                    System.out.println("赋值er:arr[j]="+arr[j]);
                }

                /*

                 * 注意不是arr[i] = temp

                 * 直接插入排序也是这样的。

                 * 为何呢？

                 * 由于j是位置，i是待插入元素

                 */

                arr[j] = temp;

            }

        }

    }
 
}  
      

输出：

排序前：44 33 99 10 30 20 59 78 23 48
for:i=5
for:arr[i]=20
for:val=5
er:j=5
er:arr[j]=20
er:j-val=0
er:arr[j-val]=44
赋值er:arr[j]=44
for:i=6
for:arr[i]=59
for:val=5
for:i=7
for:arr[i]=78
for:val=5
er:j=7
er:arr[j]=78
er:j-val=2
er:arr[j-val]=99
赋值er:arr[j]=99
for:i=8
for:arr[i]=23
for:val=5
for:i=9
for:arr[i]=48
for:val=5
for:i=2
for:arr[i]=78
for:val=2
for:i=3
for:arr[i]=10
for:val=2
er:j=3
er:arr[j]=10
er:j-val=1
er:arr[j-val]=33
赋值er:arr[j]=33
for:i=4
for:arr[i]=30
for:val=2
er:j=4
er:arr[j]=30
er:j-val=2
er:arr[j-val]=78
赋值er:arr[j]=78
for:i=5
for:arr[i]=44
for:val=2
for:i=6
for:arr[i]=59
for:val=2
er:j=6
er:arr[j]=59
er:j-val=4
er:arr[j-val]=78
赋值er:arr[j]=78
for:i=7
for:arr[i]=99
for:val=2
for:i=8
for:arr[i]=23
for:val=2
er:j=8
er:arr[j]=23
er:j-val=6
er:arr[j-val]=78
赋值er:arr[j]=78
er:j=6
er:arr[j]=78
er:j-val=4
er:arr[j-val]=59
赋值er:arr[j]=59
er:j=4
er:arr[j]=59
er:j-val=2
er:arr[j-val]=30
赋值er:arr[j]=30
for:i=9
for:arr[i]=48
for:val=2
er:j=9
er:arr[j]=48
er:j-val=7
er:arr[j-val]=99
赋值er:arr[j]=99
for:i=1
for:arr[i]=10
for:val=1
er:j=1
er:arr[j]=10
er:j-val=0
er:arr[j-val]=20
赋值er:arr[j]=20
for:i=2
for:arr[i]=23
for:val=1
for:i=3
for:arr[i]=33
for:val=1
for:i=4
for:arr[i]=30
for:val=1
er:j=4
er:arr[j]=30
er:j-val=3
er:arr[j-val]=33
赋值er:arr[j]=33
for:i=5
for:arr[i]=44
for:val=1
for:i=6
for:arr[i]=59
for:val=1
for:i=7
for:arr[i]=48
for:val=1
er:j=7
er:arr[j]=48
er:j-val=6
er:arr[j-val]=59
赋值er:arr[j]=59
for:i=8
for:arr[i]=78
for:val=1
for:i=9
for:arr[i]=99
for:val=1
排序后：10 20 23 30 33 44 48 59 78 99

 

选择排序

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到所有待排序的数据元素排完。

package cglib;

import java.util.Arrays;
import java.util.Date;
import java.util.Random;

public class StringNumber {
    
    public static void main(String[] args){  
        Random random = new Random();  
        int[] array = new int[2000];  
          
          
            for (int j = 0; j < 2000; j++) {  
                array[j] = random.nextInt(100000);  
            }  
        
        System.out.println(Arrays.toString(array));  
        selectSortTest(array);  
        System.out.println(Arrays.toString(array));       
    }  
    
     public static void selectSortTest(int a[]) {  
             
            Date dateStart = new Date();  
            selectSort(a);  
            Date dateEnd = new Date();  
            System.out.println("选择排序耗费时间："  
                    + (dateEnd.getTime() - dateStart.getTime()));  
              
           
        }  
    
    
      
    public static void selectSort(int a[]){  
        int n = a.length;  
        for(int k=0; k<n-1; k++) {  
            int min = k;  
            for(int i=k+1; i<n; i++) {//找出最小值  
                if(a[i] < a[min]) {  
                    min = i;  
                }  
            }  
            if(k != min) {  
                int temp = a[k];  
                a[k] = a[min];  
                a[min] = temp;  
            }  
        }  
    }  
}  
      

堆

         堆排序和合并排序同样，是一种时间复杂度为O(nlgn)的算法，同时和插入排序同样，是一种就地排序算法(不须要额外的存储空间)。堆排序须要用到一种 被称为最大堆的数据结构，与java或者lisp的gc不同，这里的堆是一种数据结构，他能够被视为一种彻底二叉树，即树里面除了最后一层其余层都是填 满的。也正是由于这样，树里面每一个节点的子女和双亲节点的序号均可以根据当前节点的序号直接求出。

  Parent(i)=i/2

  Left(i)=2*i

Right(i)=2*i+1

 

 

如 上图所示，1位置的子女节点分别为2,3  2节点的子女节点为4,5 2的双亲节点为1 考察其余节点也很容易发现上述关系。最大堆是一种特殊的堆，其特色是每一个双亲节点的值都比子女节点大。他的这一特色使得他能够实现nlgn的就地排序。现 在咱们先来看看怎么构建和保持一个最大堆。

最大堆的构建和保持

         咱们如今有一个数组A,大小是n，假设其中元素按照彻底二叉树的方式排列。如何将其构形成一个最大堆？首先咱们知道最大堆的每一个子树都符合最大堆的性质 （根节点值大于全部子节点）。同时咱们知道序号为（n/2+1）~n的元素都是叶子节点（由于其子女节点的序号都大于n，即说明没有子女节点），所以咱们 构建最大堆的操做就在序号为1~n/2的元素内进行（其余元素已知足最大堆性质）。咱们定义以下操做maxify(i):将以i位置节点为根的子树改形成 最大堆。其操做内容以下：对于每一个节点i，咱们考察他与子女节点的大小，若是他比某个子女节点小，则将他与子女节点中最大的那个互换位置，而后在相应的子 女节点位置重复操做，直到到达堆的叶子节点或者考察的位置比子女节点的值都要大为止。由此可知咱们构造最大堆buildmaxheap的过程就是在每一个内 部节点上调用maxify过程，依次到树的根部，此时其左右子树都是最大堆，如今
      

步骤&实例
实现堆排序需解决两个问题：
(1)如何将n 个待排序的数建成堆；
(2)输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。
建堆方法（小顶堆）：
对初始序列建堆的过程，就是一个反复进行筛选的过程。
n 个结点的彻底二叉树，则最后一个结点是第n/2个结点的子树。
筛选从第n/2个结点为根的子树开始（n/2是最后一个有子树的结点），使该子树成为堆。
以后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。
如图建堆初始过程
无序序列：(49, 38, 65, 97, 76, 13, 27, 49)

201668103056618.jpg (450×268)

(a) 无序序列，初始二叉树，97（第8/2=4个结点）为最后一个结点（49）的父结点。
(b) 97>=49,替换位置，接下来对n/2的上一个结点65进行筛选。
(c) 13<=27且65>=13,替换65和13的位置，接下来对38进行替换（都大于它，不需操做），对49进行筛选。
(d) 13<=38且49>=13,替换49和13的位置，49>=27,替换49和27的位置。
(e) 最终获得一个堆，13是咱们获得的最小数。
调整堆的方法（小顶堆）：
设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶，堆被破坏，其缘由仅是根结点不知足堆的性质。
将根结点与左、右子树中较小元素的进行交换。
若与左子树交换：若是左子树堆被破坏，则重复方法(2).
若与右子树交换，若是右子树堆被破坏，则重复方法(2).
继续对不知足堆性质的子树进行上述交换操做，直到叶子结点，堆被建成。
调整堆只需考虑被破坏的结点，其余的结点不需调整。

package cglib;


public class StringNumber {
    
     public static void main(String[] args) {
            int[] array = { 49, 38, 65, 97, 76, 13, 27, 49 };
            heapSort(array, true);
            System.out.print("\n"+"排完:");
            for (int i : array) {
                  System.out.print(i + " ");
                }
            
          }
          /**
           * 调整为小顶堆（排序后结果为从大到小）
           *
           * @param array是待调整的堆数组
           * @param s是待调整的数组元素的位置
           * @param length是数组的长度
           *
           */
          public static void heapAdjustS(int[] array, int s, int length) {
            int tmp = array[s];
            int child = 2 * s + 1;// 左孩子结点的位置
            System.out.println("待调整结点为：array[" + s + "] = " + tmp);
            while (child < length) {
              // child + 1 是当前调整结点的右孩子
              // 若是有右孩子且小于左孩子，使用右孩子与结点进行比较，不然使用左孩子
              if (child + 1 < length && array[child] > array[child + 1]) {
                child++;
              }
              System.out.println("将与子孩子 array[" + child + "] = " + array[child] + " 进行比较");
              // 若是较小的子孩子比此结点小
              if (array[s] > array[child]) {
                System.out.println("子孩子比其小，交换位置");
                array[s] = array[child];// 把较小的子孩子向上移动，替换当前待调整结点
                s = child;// 待调整结点移动到较小子孩子原来的位置
                array[child] = tmp;
                child = 2 * s + 1;// 继续判断待调整结点是否须要继续调整
                 
                if (child >= length) {
                  System.out.println("没有子孩子了，调整结束");
                } else {
                  System.out.println("继续与新的子孩子进行比较");
                }
                // continue;
              } else {
                System.out.println("子孩子均比其大，调整结束");
                break;// 当前待调整结点小于它的左右孩子，不需调整，直接退出
              }
            }
          }
           
          /**
           * 调整为大顶堆（排序后结果为从小到大）
           *
           * @param array是待调整的堆数组
           * @param s是待调整的数组元素的位置
           * @param length是数组的长度
           *
           */
          public static void heapAdjustB(int[] array, int s, int length) {
            int tmp = array[s];
            int child = 2 * s + 1;// 左孩子结点的位置
            System.out.println("待调整结点为：array[" + s + "] = " + tmp);
            while (child < length) {
              // child + 1 是当前调整结点的右孩子
              // 若是有右孩子且大于左孩子，使用右孩子与结点进行比较，不然使用左孩子
              if (child + 1 < length && array[child] < array[child + 1]) {
                child++;
              }
              System.out.println("将与子孩子 array[" + child + "] = " + array[child] + " 进行比较");
              // 若是较大的子孩子比此结点大
              if (array[s] < array[child]) {
                System.out.println("子孩子比其大，交换位置");
                array[s] = array[child];// 把较大的子孩子向上移动，替换当前待调整结点
                s = child;// 待调整结点移动到较大子孩子原来的位置
                array[child] = tmp;
                child = 2 * s + 1;// 继续判断待调整结点是否须要继续调整
                 
                if (child >= length) {
                  System.out.println("没有子孩子了，调整结束");
                } else {
                  System.out.println("继续与新的子孩子进行比较");
                }
                // continue;
              } else {
                System.out.println("子孩子均比其小，调整结束");
                break;// 当前待调整结点大于它的左右孩子，不需调整，直接退出
              }
            }
          }
            
          /**
           * 堆排序算法
           *
           * @param array
           * @param inverse true 为倒序排列，false 为正序排列
           */
          public static void heapSort(int[] array, boolean inverse) {
            // 初始堆
            // 最后一个有孩子的结点位置 i = (length - 1) / 2, 以此向上调整各结点使其符合堆
            System.out.println("初始堆开始");
            for (int i = (array.length - 1) / 2; i >= 0; i--) {
              if (inverse) {
                heapAdjustS(array, i, array.length);
              } else {
                heapAdjustB(array, i, array.length);
              }
            }
            System.out.println("初始堆结束");
            for (int i = array.length - 1; i > 0; i--) {
              // 交换堆顶元素H[0]和堆中最后一个元素
              int tmp = array[i];
              array[i] = array[0];
              array[0] = tmp;
              // 每次交换堆顶元素和堆中最后一个元素以后，都要对堆进行调整
              if (inverse) {
                heapAdjustS(array, 0, i);
              } else {
                heapAdjustB(array, 0, i);
              }
            }
          }
        
        
}  
      


输出：

初始堆开始
待调整结点为：array[3] = 97
将与子孩子 array[7] = 49 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
待调整结点为：array[2] = 65
将与子孩子 array[5] = 13 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
待调整结点为：array[1] = 38
将与子孩子 array[3] = 49 进行比较
子孩子均比其大，调整结束
待调整结点为：array[0] = 49
将与子孩子 array[2] = 13 进行比较
子孩子比其小，交换位置
继续与新的子孩子进行比较
将与子孩子 array[6] = 27 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
初始堆结束
待调整结点为：array[0] = 97
将与子孩子 array[2] = 27 进行比较
子孩子比其小，交换位置
继续与新的子孩子进行比较
将与子孩子 array[6] = 49 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
待调整结点为：array[0] = 97
将与子孩子 array[1] = 38 进行比较
子孩子比其小，交换位置
继续与新的子孩子进行比较
将与子孩子 array[3] = 49 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
待调整结点为：array[0] = 65
将与子孩子 array[1] = 49 进行比较
子孩子比其小，交换位置
继续与新的子孩子进行比较
将与子孩子 array[4] = 76 进行比较
子孩子均比其大，调整结束
待调整结点为：array[0] = 76
将与子孩子 array[2] = 49 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
待调整结点为：array[0] = 97
将与子孩子 array[1] = 65 进行比较
子孩子比其小，交换位置
没有子孩子了，调整结束
待调整结点为：array[0] = 76
将与子孩子 array[1] = 97 进行比较
子孩子均比其大，调整结束
待调整结点为：array[0] = 97

排完:97 76 65 49 49 38 27 13

5.冒泡排序

（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的所有数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）实例：

package cglib;


public class StringNumber {
    
    public static void main(String[] args){
                int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
                 for (int i = 0; i < score.length -1; i++){    //最多作n-1趟排序
                    for(int j = 0 ;j < score.length - i - 1; j++){    //对当前无序区间score[0......length-i-1]进行排序(j的范围很关键，这个范围是在逐步缩小的)
                       if(score[j] < score[j + 1]){    //把小的值交换到后面
                            int temp = score[j];
                           score[j] = score[j + 1];
                           score[j + 1] = temp;
                       }
                  }            
                   System.out.print("第" + (i + 1) + "次排序结果：");
                   for(int a = 0; a < score.length; a++){
                       System.out.print(score[a] + "\t");
                   }
                    System.out.println("");
            }
                      System.out.print("最终排序结果：");
                    for(int a = 0; a < score.length; a++){
                         System.out.print(score[a] + "\t");
                }
             }
        
}  
      


输出：

第1次排序结果：69    75    87    89    90    99    100    67    
第2次排序结果：75    87    89    90    99    100    69    67    
第3次排序结果：87    89    90    99    100    75    69    67    
第4次排序结果：89    90    99    100    87    75    69    67    
第5次排序结果：90    99    100    89    87    75    69    67    
第6次排序结果：99    100    90    89    87    75    69    67    
第7次排序结果：100    99    90    89    87    75    69    67    
最终排序结果：  100    99    90    89    87    75    69    67  

 

快速排序

算法思想：基于分治的思想，是冒泡排序的改进 型。首先在数组中选择一个基准点（该基准点的选取可能影响快速排序的效率，后面讲解选取的方法），而后分别从数组的两端扫描数组，设两个指示标志（lo指 向起始位置，hi指向末尾)，首先从后半部分开始，若是发现有元素比该基准点的值小，就交换lo和hi位置的值，而后从前半部分开始扫秒，发现有元素大于 基准点的值，就交换lo和hi位置的值，如此往复循环，直到lo>=hi,而后把基准点的值放到hi这个位置。一次排序就完成了。之后采用递归的方 式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就天然有序了。

排序过程：

          

 

public static int partition(int []array,int lo,int hi){
        //固定的切分方式
        int key=array[lo];
        while(lo<hi){
            while(array[hi]>=key&&hi>lo){//从后半部分向前扫描
                hi--;
            }
            array[lo]=array[hi];
            while(array[lo]<=key&&hi>lo){从前半部分向后扫描
                lo++;
            }
            array[hi]=array[lo];
        }
        array[hi]=key;
        return hi;
    }
    
    public static void sort(int[] array,int lo ,int hi){
        if(lo>=hi){
            return ;
        }
        int index=partition(array,lo,hi);
        sort(array,lo,index-1);
        sort(array,index+1,hi); 
    }

 

快速排序的优化

对于基准位置的选取通常有三种方法：固定切分，随机切分和三取样切分。固定切分的效率并非太好，随机切分是经常使用的一种切分，效率比较高，最坏状况下时间复杂度有可能为O(N2).对于三数取中选择基准点是最理想的一种。

三数取中切分：

快速排序的优化

对于基准位置的选取通常有三种方法：固定切分，随机切分和三取样切分。固定切分的效率并非太好，随机切分是经常使用的一种切分，效率比较高，最坏状况下时间复杂度有可能为O(N2).对于三数取中选择基准点是最理想的一种。

三数取中切分：

复制代码

public static int partition(int []array,int lo,int hi){
        //三数取中
        int mid=lo+(hi-lo)/2;
        if(array[mid]>array[hi]){//7,5,2
            swap(array[mid],array[hi]);//7,2,5
        }
        if(array[lo]>array[hi]){
            swap(array[lo],array[hi]);//5,2,7
        }
        if(array[mid]>array[lo]){
            swap(array[mid],array[lo]);
        }
        int key=array[lo];//取第二大的
        
        while(lo<hi){
            while(array[hi]>=key&&hi>lo){
                hi--;
            }
            array[lo]=array[hi];
            while(array[lo]<=key&&hi>lo){
                lo++;
            }
            array[hi]=array[lo];
        }
        array[hi]=key;
        return hi;
    }
    
    public static void swap(int a,int b){
        int temp=a;
        a=b;
        b=temp;
    }
    public static void sort(int[] array,int lo ,int hi){
        if(lo>=hi){
            return ;
        }
        int index=partition(array,lo,hi);
        sort(array,lo,index-1);
        sort(array,index+1,hi);
    }

复制代码

 

快速排序在序列中元素不多时，效率将比较低，否则插入排序，所以通常在序列中元素不多时使用插入排序，这样能够提升总体效率。

复制代码

public static void quick(int []array ,int lo,int hi){
        if(hi-lo+1<10){
            insertSort(array);
        }else{
            quickSort(array,lo,hi);
        }
    }

 

 

归并排序的基本思想

将待排序序列R[0...n-1]当作是n个长度为1的有序序列，将相邻的有序表成对归并，获得n/2个长度为2的有序表；将这些有序序列再次归并，获得n/4个长度为4的有序序列；如此反复进行下去，最后获得一个长度为n的有序序列。

综上可知：

归并排序其实要作两件事：

（1）“分解”——将序列每次折半划分。

（2）“合并”——将划分后的序列段两两合并后排序。

 

咱们先来考虑第二步，如何合并？

在每次合并过程当中，都是对两个有序的序列段进行合并，而后排序。

这两个有序序列段分别为 R[low, mid] 和 R[mid+1, high]。

先将他们合并到一个局部的暂存数组R2中，带合并完成后再将R2复制回R中。

为了方便描述，咱们称 R[low, mid] 第一段，R[mid+1, high] 为第二段。

每次从两个段中取出一个记录进行关键字的比较，将较小者放入R2中。最后将各段中余下的部分直接复制到R2中。

通过这样的过程，R2已是一个有序的序列，再将其复制回R中，一次合并排序就完成了。

 

基本排序：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每一个子序列是有序的。而后再把有序子序列合并为总体有序序列。

（2）实例：

核心代码

复制代码

public void Merge(int[] array, int low, int mid, int high) {
    int i = low; // i是第一段序列的下标
    int j = mid + 1; // j是第二段序列的下标
    int k = 0; // k是临时存放合并序列的下标
    int[] array2 = new int[high - low + 1]; // array2是临时合并序列

    // 扫描第一段和第二段序列，直到有一个扫描结束
    while (i <= mid && j <= high) {
        // 判断第一段和第二段取出的数哪一个更小，将其存入合并序列，并继续向下扫描
        if (array[i] <= array[j]) {
            array2[k] = array[i];
            i++;
            k++;
        } else {
            array2[k] = array[j];
            j++;
            k++;
        }
    }

    // 若第一段序列还没扫描完，将其所有复制到合并序列
    while (i <= mid) {
        array2[k] = array[i];
        i++;
        k++;
    }

    // 若第二段序列还没扫描完，将其所有复制到合并序列
    while (j <= high) {
        array2[k] = array[j];
        j++;
        k++;
    }

    // 将合并序列复制到原始序列中
    for (k = 0, i = low; i <= high; i++, k++) {
        array[i] = array2[k];
    }
}

复制代码

掌握了合并的方法，接下来，让咱们来了解  如何分解。

在某趟归并中，设各子表的长度为gap，则归并前R[0...n-1]中共有n/gap个有序的子表：R[0...gap-1], R[gap...2*gap-1], ... , R[(n/gap)*gap ... n-1]。

调用Merge将相邻的子表归并时，必须对表的特殊状况进行特殊处理。

若子表个数为奇数，则最后一个子表无须和其余子表归并（即本趟处理轮空）：若子表个数为偶数，则要注意到最后一对子表中后一个子表区间的上限为n-1。 

核心代码

复制代码

public void MergePass(int[] array, int gap, int length) {
    int i = 0;

    // 归并gap长度的两个相邻子表
    for (i = 0; i + 2 * gap - 1 < length; i = i + 2 * gap) {
        Merge(array, i, i + gap - 1, i + 2 * gap - 1);
    }

    // 余下两个子表，后者长度小于gap
    if (i + gap - 1 < length) {
        Merge(array, i, i + gap - 1, length - 1);
    }
}

public int[] sort(int[] list) {
    for (int gap = 1; gap < list.length; gap = 2 * gap) {
        MergePass(list, gap, list.length);
        System.out.print("gap = " + gap + ":\t");
        this.printAll(list);
    }
    return list;
}

package cglib;

import java.util.Arrays;

public class StringNumber {
    
       /**
     * 归并排序
     * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每一个子序列是有序的。而后再把有序子序列合并为总体有序序列
     * 时间复杂度为O(nlogn)
     * 稳定排序方式
     * @param nums 待排序数组
     * @return 输出有序数组
     */  
    public static int[] sort(int[] nums, int low, int high) {  
        int mid = (low + high) / 2;  
        if (low < high) {  
            // 左边  
            sort(nums, low, mid);  
            // 右边  
            sort(nums, mid + 1, high);  
            // 左右归并  
            merge(nums, low, mid, high);  
        }  
        return nums;  
    }  
 
    public static void merge(int[] nums, int low, int mid, int high) {  
        int[] temp = new int[high - low + 1];  
        int i = low;// 左指针  
        int j = mid + 1;// 右指针  
        int k = 0;  
 
        // 把较小的数先移到新数组中  
        while (i <= mid && j <= high) {  
            if (nums[i] < nums[j]) {  
                temp[k++] = nums[i++];  
            } else {  
                temp[k++] = nums[j++];  
            }  
        }  
 
        // 把左边剩余的数移入数组  
        while (i <= mid) {  
            temp[k++] = nums[i++];  
        }  
 
        // 把右边边剩余的数移入数组  
        while (j <= high) {  
            temp[k++] = nums[j++];  
        }  
 
        // 把新数组中的数覆盖nums数组  
        for (int k2 = 0; k2 < temp.length; k2++) {  
            nums[k2 + low] = temp[k2];  
        }  
    }  
 
      
    // 归并排序的实现  
    public static void main(String[] args) {  
 
        int[] nums = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };  
 
        StringNumber.sort(nums, 0, nums.length-1);  
        System.out.println(Arrays.toString(nums));  
    }
        
}  
      

Java版本

复制代码

 1 package notes.javase.algorithm.sort;
 2 
 3 public class MergeSort {
 4     public void Merge(int[] array, int low, int mid, int high) {
 5         int i = low; // i是第一段序列的下标
 6         int j = mid + 1; // j是第二段序列的下标
 7         int k = 0; // k是临时存放合并序列的下标
 8         int[] array2 = new int[high - low + 1]; // array2是临时合并序列
 9 
10         // 扫描第一段和第二段序列，直到有一个扫描结束
11         while (i <= mid && j <= high) {
12             // 判断第一段和第二段取出的数哪一个更小，将其存入合并序列，并继续向下扫描
13             if (array[i] <= array[j]) {
14                 array2[k] = array[i];
15                 i++;
16                 k++;
17             } else {
18                 array2[k] = array[j];
19                 j++;
20                 k++;
21             }
22         }
23 
24         // 若第一段序列还没扫描完，将其所有复制到合并序列
25         while (i <= mid) {
26             array2[k] = array[i];
27             i++;
28             k++;
29         }
30 
31         // 若第二段序列还没扫描完，将其所有复制到合并序列
32         while (j <= high) {
33             array2[k] = array[j];
34             j++;
35             k++;
36         }
37 
38         // 将合并序列复制到原始序列中
39         for (k = 0, i = low; i <= high; i++, k++) {
40             array[i] = array2[k];
41         }
42     }
43 
44     public void MergePass(int[] array, int gap, int length) {
45         int i = 0;
46 
47         // 归并gap长度的两个相邻子表
48         for (i = 0; i + 2 * gap - 1 < length; i = i + 2 * gap) {
49             Merge(array, i, i + gap - 1, i + 2 * gap - 1);
50         }
51 
52         // 余下两个子表，后者长度小于gap
53         if (i + gap - 1 < length) {
54             Merge(array, i, i + gap - 1, length - 1);
55         }
56     }
57 
58     public int[] sort(int[] list) {
59         for (int gap = 1; gap < list.length; gap = 2 * gap) {
60             MergePass(list, gap, list.length);
61             System.out.print("gap = " + gap + ":\t");
62             this.printAll(list);
63         }
64         return list;
65     }
66 
67     // 打印完整序列
68     public void printAll(int[] list) {
69         for (int value : list) {
70             System.out.print(value + "\t");
71         }
72         System.out.println();
73     }
74 
75     public static void main(String[] args) {
76         int[] array = {
77                 9, 1, 5, 3, 4, 2, 6, 8, 7
78         };
79 
80         MergeSort merge = new MergeSort();
81         System.out.print("排序前:\t\t");
82         merge.printAll(array);
83         merge.sort(array);
84         System.out.print("排序后:\t\t");
85         merge.printAll(array);
86     }
87 }

复制代码


运行结果 

排序前:     9   1   5   3   4   2   6   8   7  
gap = 1:   1   9   3   5   2   4   6   8   7  
gap = 2:   1   3   5   9   2   4   6   8   7  
gap = 4:   1   2   3   4   5   6   8   9   7  
gap = 8:   1   2   3   4   5   6   7   8   9  
排序后:     1   2   3   4   5   6   7   8   9  

 

基数排序
 
（1）基本思想：将全部待比较数值（正整数）统一为一样的数位长度，数位较短的数前面补零。而后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成之后,数列就变成一个有序序列。
（2）实例：

 

桶式排序

一、概念：有限个数字m，每一个数字的大小都在1与n之间，则咱们能够假设有n个桶，遍历m个数字，将其存入对应的桶中（如数字的值为3，就存入3号桶，桶的值对应存入数字的个数）

二、例子

有数字3,3,5,1,2，大小均在0-5之间，因此咱们假设有5个桶，分别标号1,2,3,4,5，遍历全部数字，将其存入桶中，则存储以后，全部桶的计数以下：

桶号 1 2 3 4 5
计数 1 1 2 0 1

咱们按照桶的序号将数字倒出来，以下：

桶的倒出顺序 数字队列
5号桶倒出1个5 5
4号桶倒出0个4 5
3号桶倒出2个3 5,3,3
2号桶倒出1个2 5,3,3,2
1号桶倒出1个1 5,3,3,2,1

如上所示，咱们成功将所给数列按照从大到小的排序，反之，若是从1号桶开始倒出，咱们会获得从小到大排列的数字

三、代码实现（JAVA）

//桶式排序
public class BucketSort{
	public static void main(String[] args){
		int[] a = {2,4,15,11,6,3,7,19,8,5,4};
		sort(a,19);
	}

	//桶式排序函数
	//a是要排序的数组
	//max是最大数字（这里咱们默认数字最小为0）
	public static void sort(int[] a,int max){
		//声明一个数组，这就是桶，编号从0到max的桶，一共max+1个
		int[] count = new int[max + 1];
		//遍历数组，用桶计数
		for(int i = 0;i < a.length;i++){
			count[a[i]]++;
		}
		//将桶里面的数字倒出
		for(int i = max;i > 0;i--){
			while(count[i] > 0){
				System.out.print(i + " ");
				count[i]--;
			}
		}
	}
}

四、弊端：若是咱们的数字波动范围很是大，好比1到10000，那么咱们须要一个10000元素数组的空间开销，并且在倒出数字的时候须要遍历10000个桶，这样效率是很是低的，因而咱们有了基于桶式排序的基数排序

2、基数排序

一、基于桶式排序，将要排序的数字一位一位的比较，经历屡次桶式排序，得出最终的序列

若是要排序的元素能够分红多位，而且每一位都在一个固定的范围内，则能够用这种排序方法，如对10进制数字的排序

二、例子

有数字23,35,9,73,3,314,11,1234,5，能够看出来，每一位数字的取值范围都是0到9，因此咱们能够用10个桶来进行排序，分别编号0到9。

如今有数组：278，109，63,930,589,184,505,269,8,83

第一次根据各位数将数组划分为10个队列(固然其中的某些队列可能不含有元素)

0:930

1:

2:

3:63,83

4:184

5:505

6：

7:

8:278,8

9:109,589,269

而后收集成序列：

930,63,83,184,505，278,8,109,589,269

在进行第二次分组：

0:505,8,109

1:

2:

3:930

4:

5:

6：63,269

7:278

8:83,184，589

9:

第二次收集：

505,8,109，930，63,269，278，83,184，589

第三次分配：

0:8,63,83

1:109,184

2:278,269

3:

4:

5:505,589

6:

7:

8:

9:930

最后获得序列：

8,63,83,109,184，269,278,505,589,930

完成排序！

基数排序实际上是利用多关键字先达到局部有序，再调整达到全局有序。

 

 

 

 

 

Java代码 收藏代码

  1. public static void radixSort(int[] array){  
  2.           
  3.         //首先肯定排序的趟数;  
  4.         int max=array[0];  
  5.         for(int i=1;i<array.length;i++){  
  6.             if(array[i]>max){  
  7.                 max=array[i];  
  8.             }  
  9.         }  
  10.           
  11.         int time=0;  
  12.         //判断位数;  
  13.         while(max>0){  
  14.             max/=10;  
  15.             time++;  
  16.         }  
  17.           
  18.         //创建10个队列;  
  19.         LinkQueue<Integer>[] queue=new LinkQueue[10];  
  20.         for(int i=0;i<10;i++){  
  21.             queue[i]=new LinkQueue<Integer>();  
  22.         }  
  23.           
  24.         //进行time次分配和收集;  
  25.         for(int i=0;i<time;i++){  
  26.               
  27.             //分配数组元素;  
  28.             for(int j=0;j<array.length;j++){  
  29.                 //获得数字的第time+1位数;  
  30.                 queue[array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i)].enQueue(array[j]);  
  31.             }  
  32.             int count=0;//元素计数器;  
  33.             //收集队列元素;  
  34.             for(int k=0;k<10;k++){  
  35.                 while(queue[k].size()>0){  
  36.                     array[count]=(Integer) queue[k].deQueue().getElement();  
  37.                     count++;  
  38.                 }  
  39.             }  
  40.         }  
  41.           
  42.     }  

 若是待排序列的关键字不是天然数，咱们固然能够对其进行转化，而后利用相似的方式排序。

代码实现（JAVA）

  1. public class RadixSort {  
  2.     /** 
  3.      * 基于最低位优先方式对一个整型数组排序，数组中整数是d位数； 
  4.      * 以3位整数排序为例，基于最低位优先方式排序的步骤是：建立十个队列，用于临时存储整数； 
  5.      * 首先按个位排序，按照每一个整数的个位数字把整数放进相应队列，好比120放进第0个队列， 
  6.      * 124放进第4个队列，当把全部整数都放进相应队列后，依次从第零个队列到第9个队列收集整数， 
  7.      * 收集获得的全部整数按照个位数大小从小到大排序了； 
  8.      * 而后按十位数排序，以一样的方式把每一个整数按十位数放进相应队列，对于十位数相同的整数， 
  9.      * 个位数小的整数先放进队列，由于上一步按个位数的排序致使个位数小的数在前面，接下来， 
  10.      * 依次从第零个队列到第9个队列收集整数，总体上先收集十位数小的数，局部到具体队列中， 
  11.      * 也就是十位数相同的那些数，按照队列先进先出的特性，个位数小的数先被收集，因而，收集 
  12.      * 获得的全部整数是按照十位和个位组合后的大小从小到大排列的； 
  13.      * 最后按百位数排序，以一样的方式把每一个整数按百位数放进相应队列，对于百位数相同的整数， 
  14.      * 十位数和个位数组合后小的整数先被放进队列，由于上一步的排序致使十位数和个位数组合后小 
  15.      * 的整数在前面，接下来，依次从第零个队列到第9个队列收集整数，总体上，先收集百位数小 
  16.      * 的数，局部到具体队列中，也就是百位数相同的那些数，按照队列的先进先出特性，十位数和 
  17.      * 个位数组合后小的整数先被收集，因而，收集获得的全部整数按从小到大排列。 
  18.      * 一句话总结排序过程，总体上从小到大，局部上也是从小到大。 
  19.      * @param integers 待排序整数数组 
  20.      * @param d 待排序数组中整数的位数 
  21.      */  
  22.     public void sort(Integer[] integers, int d) {  
  23.         /** 
  24.          * 建立队列集合并初始化，集合中的队列用于存放相应的元素，好比按最低为排序，234应该 
  25.          * 放在queues.get(4)这个队列中 
  26.          */  
  27.         LinkedList<LinkedList<Integer>> queues = new LinkedList<>();  
  28.         for(int i = 0; i < 10; i++){  
  29.             LinkedList<Integer> queue = new LinkedList<>();  
  30.             queues.add(queue);  
  31.         }  
  32.         for(int i = d - 1; i >= 0; i--) {  
  33.             // 根据排序key，把元素放进相应的队列里  
  34.             for (int j = 0; j < integers.length; j++) {  
  35.                 Integer key = getValueByIndex(integers[j], i);  
  36.                 queues.get(key).add(integers[j]);  
  37.             }  
  38.             /** 
  39.              * 把元素收回来； 
  40.              * for循环从头至尾便利集合 
  41.              */  
  42.             int index = 0;  
  43.             for (LinkedList<Integer> linkedList : queues) {  
  44.                 for (Integer integer : linkedList) {  
  45.                     integers[index] = integer;  
  46.                     index++;  
  47.                 }  
  48.                 // 清空queues里的全部队列，为二次利用作准备  
  49.                 linkedList.clear();  
  50.             }  
  51.         }  
  52.     }  
  53.     /** 
  54.      * 得到integer中第index + 1个数字 
  55.      * @param integer 
  56.      * @param index 
  57.      * @return 
  58.      */  
  59.     public Integer getValueByIndex(Integer integer, int index) {  
  60.         Objects.requireNonNull(integer);  
  61.         String iString = integer.toString();  
  62.         if (index < 0 || index >= iString.length()) {  
  63.             throw new IndexOutOfBoundsException();  
  64.         }  
  65.         String value = iString.substring(index, index + 1);  
  66.         return Integer.valueOf(value);  
  67.     }  
  68.       
  69.     public static void main(String[] args) {  
  70.         Integer[] integers = new Integer[]{654, 122, 987, 123, 345, 234};  
  71.         new RadixSort().sort(integers, 3);  
  72.         for (int i = 0; i < integers.length; i++) {  
  73.             System.out.println(integers[i]);  
  74.         }  
  75.     }  
  76.   
  77. }

 

注： 正常状况下，咱们是要告诉咱们的排序方法，咱们最高位的数字是几位的，这样在最高位也排序完成后就会中止排序，可是咱们在这段代码中用了一个叫 hasNum的boolean型变量，用来表征咱们的数组中是否还存在更高的位数，（PS：虽然省事了，方法更 通用了，可是也产生了额外的开销）

public class RadixSort{
	public static void main(String[] args){
		//声明要排序的数组
		int[] data = {73,22,93,867494,43,55,123,8978,10000,14,28,65,39,81,33,100,567};
		//调用基数排序函数
		sort(data,10);
		//输出排序后的数组
		for(int i = 0;i < data.length;i++){
			System.out.print(data[i] + " ");
		}
	}

	///基数排序函数
	//a表示要排序的数组
	//d表示每一位数字的范围（这里是10进制数，有0~9一共10种状况）
	public static void sort(int[] a,int d){
		//n用来表示当前排序的是第几位
		int n = 1;
		//hasNum用来表示数组中是否有至少一个数字存在第n位
		boolean hasNum = false;
		//二维数组temp用来保存当前排序的数字
		//第一维d表示一共有d个桶
		//第二维a.length表示每一个桶最多可能存放a.length个数字
		int[][] temp = new int[d][a.length];
		int[] order = new int[d];
		while(true){
			//判断是否全部元素均无比更高位，由于第一遍必定要先排序一次，因此有n!=1的判断
			if(n != 1 && !hasNum){
				break;
			}
			hasNum = false;
			//遍历要排序的数组，将其存入temp数组中（按照第n位上的数字将数字放入桶中）
			for(int i = 0;i < a.length;i++){
				int x = a[i]/(n*10);
				if(x != 0){
					hasNum = true;
				}
				int lsd = (x%10);
				temp[lsd][order[lsd]] = a[i];
				order[lsd]++;
			}
			//k用来将排序好的temp数组存入data数组（将桶中的数字倒出）
			int k = 0;
			for(int i = 0;i < d;i++){
				if(order[i] != 0){
					for(int j = 0;j < order[i];j++){
						a[k] = temp[i][j];
						k++;
					}				    
				}
				order[i] = 0;
			}
			n++;
		}
	}
}

 

3、基数排序（给英文字符串排序）

一、排序规则

①字符串更长的在前

②z在最前，a在最后

二、代码实现（JAVA）

public class RadixSort_Letter{
	public static void main(String[] args){
		//声明要排序的数组
		String[] a = {"ac","ee","ef","b","z","f","ep","gaaa","azh","az","r"};
		//调用基数排序函数
		sort(a,4);
		//输出排序后的数组
		for(int i = a.length - 1;i >= 0;i--){
			System.out.print(a[i] + " ");
		}
	}

	///基数排序函数
	//a是要排序的数组
	//m表示数组元素最高位数，如咱们排序的数组中位数最高的元素为gaaa，有4位
	public static void sort(String[] a,int m){
		int n = 0;
		//27表示每一位字符分红27类，其中1~26对应'a'~'z'
		//第0位专门用来存放没有高位字符的数组元素，如在比较第二位字符时，b,z,f等没有第二位字符的元素就存在temp[0]中
		//相对应的，ac存在temp[1]中，ef存在temp[5]中
		String[][] temp = new String[27][a.length];
		int[] order = new int[27];
		while(n < m){
			//这里声明String类型的数组b，将数组a中的每一个元素倒序，而后放入数组b
			//如a[0]="abc"，则b[0]="cba"
			//之因此这样作，是为了解决下面调用charAt方法时索引的问题，脑子太笨，没想到更好的方法
			String[] b = new String[a.length];
			for(int i = 0;i < a.length;i++){
				if(a[i].length() > 1){
					StringBuffer sb = new StringBuffer(a[i]);
					sb.reverse();
					b[i] = new String(sb);
				}else{
					b[i] = a[i];
				}
			}

			for(int i = 0;i < a.length;i++){
				if(a[i].length() > n){
					int lsd = b[i].charAt(n) - 'a' + 1;
					temp[lsd][order[lsd]] = a[i];
					order[lsd]++;
				}else{
					temp[0][order[0]] = a[i];
					order[0]++;
				}
			}

			int k = 0;
			for(int i = 0;i < 27;i++){
				for(int j = 0;j < order[i];j++){
					a[k] = temp[i][j];
					k++;
				}
				order[i] = 0;
			}

			n++;
		}
	}
}

 

字典排序

  1. import java.util.Comparator;  
  2. import java.util.ArrayList;  
  3. import java.util.Collections;  
  4. public class Tester {  
  5.  public static void main(String[] args) {  
  6.   ArrayList list = new ArrayList();  
  7.   list.add("东海湾");  
  8.   list.add("傲来");  
  9.   list.add("东海湾-岩洞");  
  10.   list.add("傲来药店");  
  11.   /* 
  12.    * 运用Collections的sort（）方法对其进行排序 sort（）方法须要传 连个参数，一个是须要进行排序的Collection 另外一个是一个Comparator 
  13.    */  
  14.   Collections.sort(list, new SpellComparator());  
  15.   for (int i = 0; i < list.size(); i++) {  
  16.    System.out.println(list.get(i));  
  17.   }  
  18.  }  
  19. }  
  20. /** 
  21.  * 汉字拼音排序比较器 
  22.  */  
  23. class SpellComparator implements Comparator {  
  24.  public int compare(Object o1, Object o2) {  
  25.   try {  
  26.    // 取得比较对象的汉字编码，并将其转换成字符串  
  27.    String s1 = new String(o1.toString().getBytes("GB2312"), "ISO-8859-1");  
  28.    String s2 = new String(o2.toString().getBytes("GB2312"), "ISO-8859-1");  
  29.    // 运用String类的 compareTo（）方法对两对象进行比较  
  30.    return s1.compareTo(s2);  
  31.   } catch (Exception e) {  
  32.    e.printStackTrace();  
  33.   }  
  34.   return 0;  
  35.  }  
  36. }
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程