数组中冒泡排序、直接选择排序、反序排序原理与区别

冒泡排序

冒泡排序是最常用的排序算法之一，它排序的原理是 比较相邻元素的值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面，因为类似水中气泡往上升的动作，所以称作冒泡排序。

冒泡排序有双层循环，外层循环用于控制循环次数，内层循环用于比较值的大小，因此外层循环的次数=数组长度 - 1，内层循环的次数 = 每次比较数组长度 - 1，并且内层循环受外层循环影响。

冒泡排序实现代码如下：

public class BubbleSort {

    public static void main(String[] args) {
        //创建一维数组        
        int arr[] = {4, 24, 1, 63, 3, 15};
        //创建实例对象
        BubbleSort bubbleSort = new BubbleSort();
        //调用排序的方法，被排序的对象是arr数组
        bubbleSort.sort(arr);
    }
    
    /**
     * 冒泡排序
     * 将小数往前放，大数往后放
     */
    public void sort(int arr[]){
        /*
         * 外层循环 控制排序轮数
         *     排序次数 = 数组长度 - 1
         * 内层循环 控制大小
         *     内层次数受外层次数影响，每次比较长度 = 长度 - 1
         */
        for(int i=1;i<arr.length;i++){
            //比较相邻两个元素，较大的往后冒
            for(int j=0;j<arr.length-i;j++){
                if(arr[j]>arr[j+1]){
                    //定义一个临时变量
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //输出排序后的所有元素
        showArray(arr);
    }
    
    /**
     * 显示数组
     * @param arr
     */
    public void showArray(int arr[]){
        for(int x:arr){
            System.out.print(x + "<");
        }
    }

}

直接选择排序

注意与冒泡排序区别，不是交换相邻元素，而是从整个数组中选出最大的放到排好的数组里相对最里或最外的位置，依次倒推

与冒泡排序相比，交换次数少，速度更快。

直接选择排序实现代码如下：

public class SelectSort {

    public static void main(String[] args) {
        //创建一维数组        
        int arr[] = {4, 24, 1, 63, 3, 15};
        //创建实例对象
        SelectSort selectSort = new SelectSort();
        //调用排序的方法，被排序的对象是arr数组
        selectSort.sort(arr);
    }
    
    /**
     * 直接排序
     * 注意与冒泡排序区别
     * 不是交换相邻元素，而是从整个数组中选出最大的放到排好的数组里相对最里或最外的位置，依次倒推
     * 与冒泡排序相比，交换次数少，速度更快
     */
    public void sort(int arr[]){
        int index;
        //外层循环
        for(int i=1;i<arr.length-1;i++){
            index=0;
            //内层循环
            //System.out.println("i = " + i);
            for(int j=1;j<=arr.length - i;j++){
                //System.out.println("前：index = " + index + ",j = " + j);
                if (arr[j]>arr[index]){
                    /*
                     * index是用来选出数组中最大的那个数
                     * 把这个选出来的数赋值给arr[arr.length-i]
                     */
                    index = j;
                    //System.out.println("后：index = " + index + ",j = " + j);
                }
            }
            //System.out.println("****************");
            //交换位置
            int temp = arr[arr.length - i];
            arr[arr.length - i] = arr[index];
            arr[index] = temp;
        }
        showArray(arr);
    }
    
    /**
     * 显示数组
     * @param arr
     */
    public void showArray(int arr[]){
        for(int x:arr){
            System.out.print(x + "<");
        }
    }

}

反序排序

只能适用于已经排好序的数组，想要改变其排序方式。

比如 将 从大到小 排序的数组改为 从小到大 顺序的数组。

反序排序实现代码如下：

public class ReverseSort {

    public static void main(String[] args) {
        //创建一维数组        
        int arr[] = {10,20,30,40,50};
        //创建实例对象
        ReverseSort reverseSort = new ReverseSort();
        //调用排序的方法，被排序的对象是arr数组
        reverseSort.sort(arr);
    }
    
    /**
     * 反转排序
     * 只能适用于已经排好序的数组，想要改变其排序方式
     * 比如 将 从大到小 排序的数组改为 从小到大 顺序的数组
     */
    public void sort(int arr[]){
        //排序前数组原有内容
        System.out.println("数组原有内容：");
        showArray(arr);
        int temp;
        int len = arr.length ;
        for(int i=0;i<len/2;i++){
            temp = arr[i];
            arr[i] = arr[len- 1- i];
            arr[len- 1- i] = temp;
        }
        System.out.println("
" + "数组反转后内容：");
        //排序后的内容
        showArray(arr);
    }
    
    /**
     * 显示数组
     * @param arr
     */
    public void showArray(int arr[]){
        for(int x:arr){
            System.out.print("	" + x);
        }
    }

}

三者之间的区别：

冒泡排序和直接选择排序都可以对乱序的数组进行排序，而反序排序则只能对已经排好序的数组进行排序，如将从大到小排序的数组改为从小到大。