[OJ] 经典排序算法之冒泡排序、选择排序、插入排序(Java描述）

1. 冒泡排序(bubble Sort)

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  3. 针对所有的元素重复以上的步骤，除了最后一个。
  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

public class BubbleSort implements IArraySort {
 
     @Override
    public int[] sort(int[] sourceArray) throws Exception {
         // 对 arr 进行拷贝，不改变参数内容
         int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
 
         for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;

           for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                   arr[j] = arr[j + 1];
                   arr[j + 1] = tmp;

                    flag = false;
                }
            }

            if (flag) {
                break;
            }
        }
        return arr;
    }
}

思考（以升序为例）：

1. 简单的数学概念，由于是相邻的两个数字对比，总共需要对比次数为：
   (i-1) + ( i -2) + ( i -3) + …1 = ( i - 1) * i/2
   2个数字，只需要对比一次；3个数字，需要对比3次（2+1）

2. 每当内循环，循环一次之后，由于经历了一次两两对比，至少可以保证
   最后一个数字是最大的；所以此时内循环j<len-1-i，即可无需考虑最后一个
   数字，内循环需要对比的次数持续-1，最终全部对比完.

2. 选择排序（Selection Sort）

选择排序原理:从待排序的元素中选出最小(大)的元素放在起始位置,然后再从剩余的元素中选出最小(大)的元素放在已排好的部分之后,直到只剩最后一个待排序的元素为止.

 public class SelectionSort implements IArraySort {
 
    @Override
     public int[] sort(int[] sourceArray) throws Exception {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
 
         // 总共要经过 N-1 轮比较
         for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每轮需要比较的次数 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                   // 记录目前能找到的最小值元素的下标
                   min = j;
               }
            }

            // 将找到的最小值和i位置所在的值进行交换
            if (i != min) {
                int tmp = arr[i];
               arr[i] = arr[min];
                arr[min] = tmp;
            }

        }
        return arr;
    }
}

思考（以升序为例）：

1. 第一个数会和后面的每一个数做对比，如果发现比第一个数更小的，那么就替换
   第一个数的位置。

2. 第一个最小的数确定好了之后，那么从第二个数开始，和第二个数之后的每一个数做
   对比， 如果发现比第二个数更小的，那么这个数就替换到第二个数的位置上。以此类推.

3. 插入排序（Insert Sort)

基本思想：

1. 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

2. 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

 //Java 代码实现
 public class InsertSort implements IArraySort {
 
     @Override
     public int[] sort(int[] sourceArray) throws Exception {
         // 对 arr 进行拷贝，不改变参数内容
         int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
 
        // 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，
        //默认是有序的
        for (int i = 1; i < arr.length; i++) {

            // 记录要插入的数据
           int tmp = arr[i];

           // 从已经排序的序列最右边的开始比较，找到比其小的数
            int j = i;
            while (j > 0 && tmp < arr[j - 1]) { 
                arr[j] = arr[j - 1];
                j--;
            }

            // 存在比其小的数，插入
            if (j != i) {
                arr[j] = tmp;
            }

        }
       return arr;
    }
}

思考：

1. tmp为当前想要插入的数据。

2. j > 0 && tmp < arr[j - 1])，对比当前对应的下标以及下标之前（邻近）的的值，
   如果tmp比之前的值要小，那么替换两者的值。

3. 以三个数字 A，B，C为例子， A > B > C，需要有效 到达排序。

首先默认A为最小值，此时对应代码i为2，对应arr[3] = { A, B , C }

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

需要for循环两次，

3.1 当i = 1时，记录下 tmp = arr[1] = B，

由于 j=i;
while (j > 0 && tmp < arr[j - 1]) { ----->>>>> while (1 > 0 && tmp < arr[0]) {

由于 tmp = B < (arr[0] =A)

所以进入这个while循环，然后arr[1] =arr[0] = A ;
j-- // j = 0，。，然后跳出while循环，

此时 j ! = i，所以进入判断语句，

if (j != i) {
arr[j] = tmp; // arr[0] = B
}

for循环输出的第一次结果为： B，A，C

3.2 当i=2时，记录下tmp = arr[2] = C,

先进入while循环第一次(j = i =2)，结果为：

tmp = C，
j=1,
arr[2] = A
arr[1] = A
arr[0] = B

然后进入while循环第二次(j = i =1)，结果为：
tmp = C，
j =0,
arr[2] = A,
arr[1] = B,
arr[0] = B

跳出while循环，进入if 判断

arr[0] = tmp = C，

最终结果arr[3] = { C,B,A};

其他依次类比，over.

参考链接：https://www.jianshu.com/p/88759596c944
https://www.jianshu.com/p/5223afa8796c
https://www.cnblogs.com/antusheng/p/10313347.html
https://www.jianshu.com/p/7cf0656e76dd