冒泡排序、选择排序、插入排序，效率以及应用场景

1.冒泡排序：
    冒泡排序是原理最简单的排序，但是他是三种排序算法中效率最低的，他的比较次数和交换数据次数时间复杂度都是O(N²)。

    原理：冒泡排序是双重循环，他每次排序都将最大的元素移动到最后一位，比较方式为：0 vs 1，1 vs 2，2 vs 3，。。。直到N-1 vs N，每次比较之后，下次比较不会再去比较上去比较得出的并且移动的最大数据，所以他需要逐条比较。
相应Java代码：
public long[] bubbleSort(long []a){
int out,in;//out外层循环变量，in内层循环变量
int count = 0;//比较次数
int num = 0;//交换次数
int length = a.length;//数组长度
for(out=length-1;out>=1;out--){
for(in=0;in<out;in++){
if(a[in]>a[in+1]){
change(in,in+1);
num++;
}
count++;
}
}
System.out.println("比较了"+count+"次！交换了"+num+"次！");
return a;

}
2.选择排序：
    选择排序优于冒泡排序，选择排序的对比时间复杂度为O（N²），但是他的数据交换时间复杂度仅为O(N)，在数组排序过程中，数据的移动交换是比较耗时的，所以相对于冒泡排序而言，选择排序的效率大大提高。

原理：选择排序是先将数组中最小的元素找到并且标记，即记录最小数据的下标，将找到的最小元素移动到最左侧，也就是目前的下标最小的位置，下次比较就除去上次找到并且移动的最小值，对剩下数据继续重复上述操作，直到排序结束。所以只需要移动N-1次即可完成排序，但是对比次数还是O（N²）。
对应Java代码：
public long[] chooseSort(long []a){
int out,in,minIndex;//out外层循环，in内层循环，minIndex最小值下标
int countChange = 0;
int countCompare = 0;
int length = a.length;
for(out=0;out<length-1;out++){
minIndex = out;
for(in=out+1;in<length;in++){
if(a[in]<a[minIndex]){
minIndex = in;
countCompare++;
}
}
change(out, minIndex);
countChange++;
}
System.out.println("交换了"+countChange+"次！");
System.out.println("比较了"+countCompare+"次！");
return a;

}
3.插入排序：
    插入排序的时间复杂度不好计算，因为他的时间复杂度是根据目前有序部分的多少决定的

    原理：插入排序会将目前基本有序的一部分数组提取出来，然后将这部分数组的最右侧的一个元素的右侧元素做标记，将这个元素与前面基本有序的数组进行比较，找到比他稍大的元素，并且移动到比他稍大的元素前面，剩余的未排序元素重复执行上述操作，知道排序结束。所以插入排序的时间复杂度与他的基本有序部分的大小有关，如果数组是正好逆序的，他的时间复杂度甚至不会比，冒泡排序高。

对应Java代码：
public long[] insertSort(long []a){
int in,out;
int length = a.length;
//out标记未排序部分的最左侧元素
for(out=1;out<length;out++){
long temp = a[out];
in = out;
while(in>0&&a[in-1]>=temp){
a[in] = a[in-1];
in--;
}
a[in] = temp;
}
return a;

}

三种排序算法的使用场景：
冒泡排序：
    适用于数据量很小的排序场景，因为冒泡原理简单
选择排序：
    适用于大多数排序场景，虽然他的对比次数较多，但是数据量大的时候，他的效率明显优于冒泡，而且数据移动是非常耗时的，选择排序移动次数少。
插入排序：
    插入排序适用于已有部分数据有序的情况，有序部分越大越好。