一，冒泡排序BubbleSort

算法思想

冒泡排序是一种比较简单的排序算法，在每一次循环中，依次比较相邻的两个元素的大小，每次循环把最大的值交换到右边，最终完成排序。

排序过程

无序数组：2，3，9，5，4，1

第一趟排序：2，3，9，5，1，4（第一次循环开始）
第二趟排序：2，3，9，1，5，4
第三趟排序：2，3，1，9，5，4
第四趟排序：2，1，3，9，5，4
第五趟排序：1，2，3，9，5，4
第六趟排序：1，2，3，9，4，5（第二次循环开始）
第七趟排序：1，2，3，4，9，5
......
第某趟排序：1，2，3，4，5，9

代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int temp =0;    //定义临时变量（用于值交换）
        int[] arr = new int[]{2,3,9,5,4,1};  //定义一个无序数组

        for (int i=0;i<arr.length;i++){             //外层循环 
            for (int j=arr.length-1;j>i;j--){     //内层循环，用于比较相邻的两个数大小
                if (arr[j]<arr[j-1]){
                    //交换值
                    temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
        System.out.println("排序后结果:");
        for (int i:arr){ System.out.print(i); }
    }
}

排序后结果

排序后结果:
123459

二、选择排序SelectionSort

算法思想

选择排序的算法思想为，从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零

排序过程

无序数组：2，3，9，5，4，1

第一趟排序：（1），3，9，5，4，2
第二趟排序：（1，2），9，5，4，3
第三趟排序：（1，2，3），5，4，9
第四趟排序：（1，2，3，4），5，9
第五趟排序：（1，2，3，4，5），9

代码实现

public class SelectionSort {
    public static void main(String[] args) {
        int temp =0;    //定义临时变量（用于值交换）
        int[] arr = new int[]{2,3,9,5,4,1};  //定义一个无序数组
        int k = 0;      //定义索引


        for (int i = 0;i < arr.length-1;i++){
            k=i;
            for (int j = i+1;j < arr.length;j++){
                if (arr[j]<arr[k]){
                    k=j;
                }
            }
            //把循环比较出的最小值元素与第i位置的元素进行交换
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }


        System.out.println("排序后结果:");
        for (int i:arr){ System.out.print(i); }
    }
}

排序后结果

排序后结果:
123459

三、插入排序InsertSort

算法思想

插入排序也被称为直接插入排序，它的算法思想是将数组的第一个数认为是有序数组，从后往前（从前往后）扫描该有序数组，把数组中其余n-1个数，根据数值的大小，插入到有序数组中，直至数组中的所有数有序排列为止。这样的话，n个元素需要进行n-1趟排序！！！

排序过程

无序数组：43,32,18,26,21,4

第一趟排序：（43），32，18，26，21，4
第二趟排序：（32，43），18，26，21，4
第三趟排序：（18，32，43），26，21，4
第四趟排序：（18，26，32，43），21，4
第五趟排序：（18，21，26，32，43），4
第六趟排序：（4，18，21，26，32，43）

插入排序比较抽象，因此这里解释一下：

初始时，默认第一个元素43为一个新的有序数组（43）
第一趟排序中，比较顺序为从右往左，因此用32和43比较，32小于43,因此把32插入到43的左边，新的有序数组为（32，43）

第二趟排序中，让18先与数组（32，43）的43比较，18小于43，在比较18与32，发现18也小于32，因此把18插入到32的左边，因而新的数组为（18，32，43）

第三趟排序中，让26先与数组（18，32，43）中的43比较，发现26小于43，再往左一位比较，26小于32，再与左边比较，此时32大于18，因此！让18往左移一位，把26插入到此处，最终新的数组（18，26，32，43）

第四趟排序中......

代码实现

public class InsertSort {
    public static void main(String[] args) {
        int temp =0;    //定义临时变量（用于值交换）
        int[] arr = new int[]{43,32,18,26,21,4};  //定义一个无序数组

        for (int i=1;i<arr.length;i++){

            //待排元素小于有序序列的最后一个元素时，向前插入
            if (arr[i]<arr[i-1]){
                temp = arr[i];
                for (int j=i;j>=0;j--){
                    if (j>0 && arr[j-1]>temp) {
                        arr[j]=arr[j-1];
                    }else {
                        arr[j]=temp;
                        break;
                    }
                }
            }
            
        }

        System.out.println("排序后结果:");
        for (int c:arr){ System.out.print(c+","); }
    }
}

排序后结果：