排序算法，冒泡、直接选择排序

排序算法分类

常用的排序算法都是内部排序，是指将数据加载到内部存储器中进行排序。外部排序是由于数据量过大，需要借助外部存储器进行排序。

冒泡排序

冒泡排序在排序数组元素时，将大数往后移，小数往前移，类似水泡上升。基本思想：每次比较相邻的两个数，将大的数放在后面，进行一趟排序后，会将最大的数放在数组的最后位置。对一个长度为6的数组{4，24，64，3，1，15}，冒泡排序需要进行n-1=6-1=5（n为数组长度）趟排序。每进行一趟排序，内部的比较次数减少一次，因为最后一个数最大不需要进行比较。可以得出：第一趟排序：比较5次；第二趟排序：比较4次；。。。第五趟排序：比较1次。

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr= {4,24,64,3,1,15};
        bubbleSort(arr);
    }
    private static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){  //外层循环控制循环趟数
            for(int j=0;j<arr.length-1-i;j++){  //内层循环控制比较次数
                if(arr[j]>arr[j+1]){
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        for(int i:arr){
            System.out.print(i+"\t");
        }
        System.out.println();
    }
}

对上面的标准冒泡排序算法可以进行一定的改进。
适用的情形：如当数据基本有序，{1，18，2，3，4}，该数组进行第一趟排序后就可以得到有序的数组，将不需要进行后续的排序比较。
对上述的情况，可以在冒泡排序的循环内添加标识，如果在一趟排序中没有进行任何一次的数据位置交换，说明数据已经排序成功，此时直接退出排序的外循环即可。改进代码如下

import java.util.Arrays;
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr= {1,18,2,3,4};
        bubbleSort(arr);
    }
    private static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            boolean flag = false;
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    flag=true;
                    int temp =arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
            System.out.printf("第%d趟排序",i+1);
            System.out.println(Arrays.toString(arr));
            if(!flag){
                break;
            }
        }
        /*for(int i:arr){
            System.out.print(i+"\t");
        }
        System.out.println();*/
    }
}
第1趟排序[1, 2, 3, 4, 18]
第2趟排序[1, 2, 3, 4, 18]

结果进行了两趟排序就结束，第一趟排序得到有序数组，第二趟排序比较没有元素互换位置，直接退出循环得到结果。

直接选择排序

直接选择排序与冒泡排序不同，其内循环不是比较相邻的元素进行位置交换，而是找到数组中最大（小）的元素将其放在最后（前）的位置。其交换次数要比冒泡排序少很多。
同样的，对一个长度为6的数组{4，24，64，3，1，15}，也要进行n-1=5轮排序，每轮排序的比较次数也依次递减。

import java.util.Arrays;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr= {1,18,2,3,4};
        selectSort(arr);
    }
    private static void selectSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            int index = 0;
            for(int j=1;j<arr.length-i;j++){
                if(arr[index]<arr[j]){    //内循环找出最大值索引
                    index=j;
                }
            }
            int temp = arr[arr.length-i-1]; //进行一轮排序后找出最大值与
            arr[arr.length-i-1]=arr[index]; //最后位置元素互换 
            arr[index]=temp;
        }
        System.out.println(Arrays.toString(arr));
    }
}