JAVA 三种排序算法 (选择排序、插入排序、冒泡排序）形象图解，一看就会。

注：
以下均使用升序介绍。

选择排序：

从数组中找到最小的元素，和第一个位置的元素互换。
从第二个位置开始，找到最小的元素，和第二个位置的元素互换。
…
直到选出array.length-1个较小元素，剩下的最大的元素自动排在最后一位。

在这里插入图片描述

代码实现：
public class Selection {

public static void sort(int[] arr){
    for(int i=0; i<arr.length-1; i++) {
        int minPos = i;
        for (int j = i; j < arr.length; j++) {
            if (arr[j] < arr[minPos]) {
                minPos = j;//找出当前最小元素的位置
            }
        }
        if(arr[minPos]!=arr[i]) {
            swap(arr,minPos,i);
        }
    }
}
public static void swap(int[] arr,int a,int b){
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

}
衍生算法：
双向选择排序（每次循环，同时选出最大值放在末尾，最小值放在前方）。

代码实现：
public class Selection {

public static void doubleSort(int[] arr){
    for(int i=0; i<arr.length/2-1; i++) {
        int minPos = i,maxPos = arr.length -i -1;
        for (int j = i; j < arr.length -i; j++) {
            if (arr[j] < arr[minPos]) {
                minPos = j;
            }

            if(arr[maxPos] <arr[j]){
                maxPos = j;
            }
        }
        if(i!=minPos) {
            swap(arr,i,minPos);//(1)
        }
        if(maxPos!=arr.length - i - 1) {
            if (maxPos == i){//若当前最大值在循环起始位置，则最大值一定在(1)处被交换到了minPos的位置
                maxPos = minPos;
            }
            swap(arr,maxPos,arr.length -i -1);
        }
    }
}
public static void swap(int[] arr,int a,int b){
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

}
插入排序：

从第二个元素开始，将当前元素插入到前面对应位置，使当前元素i
和之前元素形成有序数组。

比较规则：
正常：
从第一个元素开始，若当前元素i小于有序数组中的元素j，则从该元素开始将有序数组依次后移一位，
并将当前元素i放置到该元素j位置。（插入）

简易：
从有序数组最后一个元素开始，若当前元素i小于该元素j，则交换当前元素和该元素。

简易版代码实现：
public class Insertion {

public static void sort(int[] arr){
    int pos,temp;
    for(int i=1;i<arr.length;i++){
        pos = i;
        while(pos!=0&&arr[pos]<arr[pos-1]){
            temp = arr[pos];
            arr[pos] = arr[pos-1];
            arr[pos-1] = temp;
            pos--;
        }
    }
}

}

冒泡排序：

从前往后，依次比较相邻的两个数，把较大的数放到后面。一次循环，可以在当前最末尾位置得到一个当前最大值。

代码实现：
public class Bubble {

public static void sort(int[] arr){
    int temp;
    //依次将最大的数放置到数组末尾，将第二大的数放到倒数第二位...
    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]) {
                swap(arr,j,j+1);
                changed = true;
            }
        }
    }
}

public static void swap(int []arr,int a ,int b){
    int temp=arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

}
代码优化：
在某些时候，循环还未终止，整个数组已经排好序，此时应及时终止循环。
（冒泡每次都会比较相邻两个数并交换次序不对的组，若一次循环后，都没进行交换，则已经完成排序）

优化代码实现：
public class Bubble {

public static void sort(int[] arr){
    int temp;
    boolean changed;
    for(int i = 0;i < arr.length-1;i++){
        changed = false;
        for(int j = 0;j < arr.length-1-i;j++){

            if(arr[j]>arr[j+1]) {
                swap(arr,j,j+1);
                changed = true;
            }
        }
        if(!changed){
            break;
        }
    }
}

public static void swap(int []arr,int a ,int b){
    int temp=arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}

}

鸡尾酒排序：

鸡尾酒是冒泡排序的升级版，该排序从左往右找出最大值后，再从右往左
找出最小值，类似鸡尾酒搅拌左右循环。在某些情况下，优于冒泡排序，
以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次 ）
次序列就可以完成排序，但如果使用冒泡排序则需要四次。

代码实现：
public class CockTail {

public static void sort(int[] arr){
    //依次将最大的数放置到数组末尾，将第二大的数放到倒数第二位...
    boolean changed;
    for(int i = 0;i < arr.length/2;i++){
        changed = false;
        //从前往后,比较相邻两个数,把大的放在后边.之前已放置成功的可以不再参与比较
        for(int j = i;j < arr.length-1-i;j++){

            if(arr[j]>arr[j+1]) {
                swap(arr,j,j+1);
                changed =true;
            }
        }
        if(!changed){
            break;
        }
        for(int j = arr.length-1-i; j > i; j--){

            if(arr[j]<arr[j-1]) {
                swap(arr,j,j-1);
                changed = true;
            }
        }
        if(!changed){
            break;
        }
    }
}

public static void swap(int[] arr, int pos1, int pos2){
    int temp = arr[pos1];
    arr[pos1] = arr[pos2];
    arr[pos2] = temp;
}