数组排序的四种方法

在程序设计中，经常需要将一组数列进行排序，这样更加方便与统计与查询。这篇博客，我就来介绍几种关于数组排序的方法。

一）通过Arrays类的静态sort()方法，实现对数组进行排序，sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。

语法如下：

Arrays.sort(object)     //其中，object是指进行排序的数组名称。

算法实例：

import java.util.Arrays;        //导入java.util.Arrays类

public class Demo1 {
    public static void main(String[] args) {
        int arr[]=new int[]{5,25,1,77};
        Arrays.sort(arr);       //运用sort()方法进行排序
        for(int i=0 ; i<4 ; i++){ //循环遍历排序后的数组
            System.out.print(arr[i]+" "); //将排序后的数组的各个元素进行输出
        }
    }
}

运行结果：

上述实例是对整形数据进行排序，Java中的String类型数组的排序算法，是根据字典编排顺序排序的，因此数字排在字母前边，大写字母排在小写字母前面。

 二）冒泡排序：这是广大学习者最先接触的一种排序算法，它排序数组元素的过程总是将小数往前放、大数往后放，类似于水中气泡往上升的动作，所以称冒泡排序。

基本思想：冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

算法实例：

public class Demo2 {
    public static void main(String[] args) {
        int array[]={55,88,78,12,3,1};
        Demo2 demo2=new Demo2();
        demo2.sort(array);   //调用后面的排序方法将数组进行排序
    }
    /**
     * 冒泡排序
     * 
     * @param array
     *          要排序的数组
     */
    public void sort(int[] array){
        for(int i=1 ; i<array.length;i++){
            //比较两个相邻的元素，较大的数往冒泡
            for(int j=0;j<array.length-i;j++){
                if(array[j]>array[j+1]){
                    int temp=array[j];   //第一个元素存于临时变量temp中
                    array[j]=array[j+1]; //第二个元素保存在第一个元素单元中
                    array[j+1]=temp;  //把临时变量（也就是第一个元素原值）保存在第二个元素单元
                }
            }
        }
        showArray(array);    //输出冒泡排序后的数组
    }
    /**
     * 显示数组胡所有元素
     * 
     * @param  array
     *          要显示的数组
     */
    public void showArray(int[] array){
        for(int i:array){                    //遍历数组
            System.out.print(">"+i);         //输出每个数组的元素值
        }
        System.out.println();
    }
}

运行结果：

冒泡排序的主要思想就是：把相邻两个元素进行比较，如满足一定条件则进行交换（如判断大小或日期前后等），每次循环都将最大（或最小）的元素排在最后，下一次循环是对数组中其他元素进行类似操作。

三）直接选择排序：直接选择排序属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法。

基本思想：将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值，注意这里区别冒泡排序，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换。

算法实例：

/**
 * 直接选择排序算法实例
 */

public class Demo2 {
    public static void main(String[] args) {
        int array[]={22,45,85,1,2,0,32};
        Demo2 demo2=new Demo2();
        demo2.sort(array);  //调用后面的排序方法
    }
    /**
     * 直接选择排序
     * 
     * @param array
     *          要排序的数组
     */
    public void sort(int[] array){
        int index;
        for(int i=1 ; i<array.length;i++){
            index=0;
            for(int j=0;j<array.length-i;j++){
                if(array[j]>array[index]){
                    index=j;  //找出本次循环数组中最大的元素的位置
                }
            }
            //交换在位置array.length-i和index（最大值）上的两个元素
            int temp=array[array.length-i];
            array[array.length-i]=array[index];
            array[index]=temp;
        }
        showArray(array);
    }
    /**
     * 显示数组胡所有元素
     * 
     * @param  array
     *          要显示的数组
     */
    public void showArray(int[] array){
        for(int i:array){
            System.out.print(">"+i);
        }
        System.out.println();
    }
}

运行结果：

将直接选择排序算法与冒泡排序算法相比较，我们可以看出，冒泡排序是交换满足条件的相邻元素值，而直接选择排序则是先找大最大（或最小）元素值的位置，然后与相应位置的元素进行交换。

四）反转排序：顾名思义，反转排序就是以相反的顺序把原数组的内容进行重新排序。

基本思想：把数组最后一个元素与第一个元素进行替换，倒数第二个与第二个元素进行替换，以此类推，直到把所有元素反转替换。

算法实例：

/**
 * 反转排序算法实例
 */

public class Demo2 {
    public static void main(String[] args) {
        int array[]={1,2,3,4,5,6,7,8,9,10};
        Demo2 demo2=new Demo2();
        demo2.sort(array);
    }
    /**
     * 反转排序
     * 
     * @param array
     *          要排序的数组
     */
    public void sort(int[] array){
        System.out.println("数组原有内容：" );
        showArray(array);
        int temp;
        int len=array.length;
        for(int i=0; i<len/2;i++){
           temp=array[i];
           array[i]=array[len-1-i];
           array[len-1-i]=temp;
        }
        System.out.println("数组反转后内容：");
        showArray(array);
    }
    /**
     * 显示数组胡所有元素
     * 
     * @param  array
     *          要显示的数组
     */
    public void showArray(int[] array){
        for(int i:array){
            System.out.print("\t"+i);
        }
        System.out.println();
    }
}

运行结果：

最后，需要注意的是，数组的下标都是从0开始的，最后一个元素的表示总是“数组名.length-1”。