排序（冒泡排序、选择排序、插入排序）

1. 选择排序

选择排序是一种简单直观的排序算法，其基本原理如下（假设从小到大排序）：

对于给定的一组记录，经过第一轮比较后得到最小的记录，然后将该记录与第一个记录的位置进行交换；接着对不包括第一个记录以外的其他记录进行第二轮比较，得到最小的记录并与第二个记录进行位置交换；重复该过程，直到进行比较的记录只有一个时为止。

以数组 { 38,，65, 97, 76, 13, 27, 49 }为例，选择排序的具体步骤如下：

第一趟排序后： 13 [ 65 97 76 38 27 49 ]
第二趟排序后： 13 27 [ 97 76 38 65 49 ]
第三趟排序后： 13 27 38 [ 76 97 65 49 ]
第四趟排序后： 13 27 38 49 [ 97 65 76 ]
第五趟排序后： 13 27 38 49 65 [ 97 76 ]
第六趟排序后： 13 27 38 49 65 76 [ 97 ]

 public static void selectSort(int[] array) {
    int temp = 0; //用来记录每轮得到最小值
    int flag = 0; //用来记录每轮最小值的索引
    for(int i = 0; i < array.length-1; i++) {
        temp = array[i];
        flag = i;
        for(int j = i+1; j < array.length; j++) {
            if(array[j] < temp) {
                temp = array[j];
                flag = j;
            }
        }
        // 将最小记录的位置与array[i]的位置进行交换
        if(flag != i) {
            array[flag] = array[i];
            array[i] = temp;
        }
     System.out.println("第 " + (i+1) + "趟排序后： " + Arrays.toString(array));
    }
}/* Output: 以数组{36,25,48,12,25,65,43,57}为例，输出结果为：
第 1 趟排序后： [12, 25, 48, 36, 25, 65, 43, 57]
第 2 趟排序后： [12, 25, 48, 36, 25, 65, 43, 57]
第 3 趟排序后： [12, 25, 25, 36, 48, 65, 43, 57]
第 4 趟排序后： [12, 25, 25, 36, 48, 65, 43, 57]
第 5 趟排序后： [12, 25, 25, 36, 43, 65, 48, 57]
第 6 趟排序后： [12, 25, 25, 36, 43, 48, 65, 57]
第 7 趟排序后： [12, 25, 25, 36, 43, 48, 57, 65]
*///~

2. 冒泡排序

单向冒泡排序的思想（假设由小到大排序）：

对于给定的 n 个记录，从第一个记录开始依次对相邻的两个记录进行比较，当前面的记录大于后面的记录时，交换位置，进行一轮比较和换位后，n 个记录中的最大记录将位于第 n 位；然后对前（n-1）个记录进行第二轮比较；重复该过程直到进行比较的记录只剩下一个为止。

 public static void bubbleSort(int array[]) {
    int len = array.length;
    int temp;
    for(int i = 0; i < len-1; i++) {//控制轮数
        for(int j = 0; j < len-1; j++) {//找出每轮的记录中的最大值
            if(array[j] > array[j+1]) {
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
}

以数组{36,25,48,12,25,65,43,57}为例，冒泡排序的具体步骤如下：
初始状态：[ 36 25 48 12 25 65 43 57 ]
1趟排序： [ 25 36 12 25 48 43 57 ] 65
2趟排序： [ 25 12 25 36 43 48 ] 57 65
3趟排序： [ 12 25 25 36 43 ] 48 57 65
4趟排序： [ 12 25 25 36 ] 43 48 57 65
5趟排序： [ 12 25 25 ] 36 43 48 57 65
6趟排序： [ 12 25 ] 25 36 43 48 57 65
7趟排序： [ 12 ] 25 25 36 43 48 57 65

3. 插入排序

思想： 对于给定的一组记录，初始时假设第一个记录自成一个有序序列，其余记录为无序序列。接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其之前的有序序列中，直至最后一个记录插入到有序序列中为止。

仍以数组 { 38,，65, 97, 76, 13, 27, 49 }为例，插入排序的具体步骤如下：

第一步插入38以后：[ 38 ] 65 97 76 13 27 49
第二步插入65以后：[ 38 65 ] 97 76 13 27 49
第三步插入97以后：[ 38 65 97 ] 76 13 27 49
第四步插入76以后：[ 38 65 76 97 ] 13 27 49
第五步插入13以后：[ 13 38 65 76 97 ] 27 49
第六步插入27以后：[ 13 27 38 65 76 97 ] 49
第六步插入49以后：[ 13 27 38 49 65 76 97 ]

 public static void insertSort(int[] a) {
    if(a!=null) {
        print("第  1 步插入后： " + Arrays.toString(a));
        for(int i = 1; i < a.length; i++) {
            int temp = a[i];
            int j = i;
            if(a[j-1] > temp) {
                while(j >= 1 && a[j-1] > temp){
                    a[j] = a[j-1];
                    j--;
                }
            }
            a[j] = temp;
            print("第 " + (i+1) + " 步插入后： " + Arrays.toString(a));
        }
    }
}/* Output：以数组 {36,25,48,12,25,65,43,57} 为例，输出结果如下：
第  1 步插入后： [36, 25, 48, 12, 25, 65, 43, 57]
第 2 步插入后： [25, 36, 48, 12, 25, 65, 43, 57]
第 3 步插入后： [25, 36, 48, 12, 25, 65, 43, 57]
第 4 步插入后： [12, 25, 36, 48, 25, 65, 43, 57]
第 5 步插入后： [12, 25, 25, 36, 48, 65, 43, 57]
第 6 步插入后： [12, 25, 25, 36, 48, 65, 43, 57]
第 7 步插入后： [12, 25, 25, 36, 43, 48, 65, 57]
第 8 步插入后： [12, 25, 25, 36, 43, 48, 57, 65]
*/