<1>冒泡排序
这个名词的还是很形象的，就是每次比较相邻的两个数，大的数总是往后面冒，所以每轮比较结束后，大数都会冒到最后面。
每次比较的结果如下：
无序数组 ：8 2 4 3 5 7 1 9 6 （后面所有的排序都将使用这个数组）
第一轮比较：2 4 3 5 7 1 8 6 9
第二轮。。：2 3 4 5 1 7 6 8 9
第三轮。。：2 3 4 5 1 6 7 8 9
第四轮。。：2 3 4 1 5 6 7 8 9
第五轮。。：2 3 1 4 5 6 7 8 9
第六轮。。：2 1 3 4 5 6 7 8 9
第七轮。。：1 2 3 4 5 6 7 8 9
我们用程序来描述这种变化：
/**
* 冒泡排序，默认为从小到大排序
* @param array 需要排序的数组
*/
public static void bubbleSort(int[] array) {
int length = array.length;
for (int i = 1; i < length; i++) {//外层循环表示每一轮的比较,为了便于理解我们将i初始化为1,表示从第一轮开始，也能避免内层循环的下标越界
for (int j = 0; j < length-i; j++) {//内层循环表示相邻的两个数比较,我们同数组下标一样,从0开始
if (array[j] > array[j+1]) {
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
如果是递减排序：
/**
* 冒泡排序
* @param array 需要排序的数组
* @param pattern 当参数不为空的时候，表示递减排序
*/
public static void bubbleSort(int[] array, String pattern) {
if (StringHelper.isEmpty(pattern)) {//isEmpty()这是我自己写的一个工具类,用于判断字符串是否为null或者空
bubbleSort(array);//当pattern 为空或者为null时候递增排序
return;
}
int length = array.length;
for (int i = 1; i < length; i++) {
for (int j = 0; j < length-i; j++) {
if (array[j] < array[j+1]) {//递减排序的话,那就让小的往后面冒就行了
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}<2>插入排序
插入排序个人认为是很好理解的一种算法，实现的话也比较简单。
对于一个要排序的数组，我们将第一个数作为有序数组，然后后面的元素一次插入到这个有序数组中。
那么对于无序数组，他的元素就会分为已经插入的，和尚未插入的。
唯一不好理解的就是，用程序插入时候，移动元素怎么移动。
我们先看看数组每次的变化，我们还用上面的无序数组：
无序数组 ：8 2 4 3 5 7 1 9 6
已插入数组： 8 尚未插入元素：2 4 3 5 7 1 9 6
已插入数组： 2 8 尚未插入元素：4 3 5 7 1 9 6
已插入数组： 2 4 8 尚未插入元素：3 5 7 1 9 6
已插入数组： 2 3 4 8 尚未插入元素：5 7 1 9 6
已插入数组： 2 3 4 5 8 尚未插入元素：7 1 9 6
已插入数组： 2 3 4 5 7 8 尚未插入元素：1 9 6
已插入数组： 1 2 3 4 5 7 8 尚未插入元素：9 6
已插入数组： 1 2 3 4 5 7 8 9 尚未插入元素：6
已插入数组：1 2 3 4 5 6 7 8 9 尚未插入元素：
我们用程序来描述这个插入过程：
/**
* 插入排序,默认递增排序
* @param array 要排序的数组
*/
public static void insertSort(int[] array) {
int length = array.length;
for (int i = 1; i < length; i ++) {//因为第一个我们默认为已经排序了的，所以我们从第二个开始插入，也就是下标为1
int j = i;
int temp = array[j];
while (j > 0 && temp < array[j-1]) {
array[j] = array[j-1];//我们这里不需要交换，找到要插入的位置，后面的元素整体后移就行了
j--;
}
array[j] = temp;//插入到对应的位置
}
}
递减排序：
/**
* 插入排序
* @param array 待排序数组
* @param parttern 排序方式,值不为空时候表示递减排序
* @return 有序数组
*/
public static void insertSort(int [] array, String parttern) {
if (StringHelper.isEmpty(parttern)) {
insertSort(array);
return;
}
int j = 0;
for (int i = 1; i < array.length; i++) {
j = i;
int temp = array[i];//记录要插入的值
while (j >0 && temp > array[j-1]) {
array[j] = array[j-1];
j--;
}
array[j] = temp;
}
}
<3>选择排序
交换排序的思路是每一轮选出较小元素然后交换。
第一轮交换的时候，找出剩余9个元素中最小的，和第一个交换；
第二轮交换的时候，找出剩余8个元素中修小的，和第二个交换；
...
这个和冒泡排序有点类似的，但是算法实现不一样。
我们先看交换排序的过程：
无序数组 ：8 2 4 3 5 7 1 9 6
第一轮交换：1 2 4 3 5 7 8 9 6 (8和1交换 )
第二轮交换：1 2 4 3 5 7 8 9 6 (2不用交换)
第三轮交换：1 2 3 4 5 7 8 9 6 (4和3交换)
第四轮交换：1 2 3 4 5 7 8 9 6 (4不用交换)
第五轮交换：1 2 3 4 5 7 8 9 6 (5不用交换)
第六轮交换：1 2 4 3 5 6 8 9 7 (7和6交换)
第七轮交换：1 2 4 3 5 6 7 9 8 (8和7交换)
第八轮交换：1 2 4 3 5 6 7 8 9 (9和8交换)
我们看程序实现这种算法：
/**
* 选择排序,默认递增排序
* @param array 需要排序的数组
*/
public static void selectSort(int[] array) {
int length = array.length;
for (int i = 0; i < length; i++) {//外层控制选择次数
int min = i;
for (int j = i+1; j < length; j++) {//选择出最小元素的下标
if (array[min] > array[j]) {
min = j;
}
}
if (i != min) {
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}
递减排序：
/**
* 选择排序
* @param array 需要排序的数组
* @param pattern 当传值不为空时候,递减排序
*/
public static void selectSort(int[] array, String pattern) {
if (StringHelper.isEmpty(pattern)) {
selectSort(array);
return;
}
int length = array.length;
for (int i = 0; i < length; i++) {//外层控制选择次数
int min = i;
for (int j = i+1; j < length; j++) {//选择出最小元素的下标
if (array[min] < array[j]) {
min = j;
}
}
if (i != min) {
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}