数组排序（冒泡排序、选择排序）

数组排序指的是让一堆杂乱无章的数据，按从小到大排列，或者按从大到小排列，让其有规律。这个过 程就是数组排序。排序的算法很多，例如：冒泡排序，选择排序，快速排序，归并排序，插入排序等 等。咱们讲一下冒泡排序和选择排序。

冒泡排序

冒泡排序：海底的气泡由于水压的作用，越深的地方气泡就越小，气泡在上浮的过程中，由于水压的减 小，气泡会越来越大，到达海面的时候，气泡会最大。基于这个启发，数学家们发明了冒泡排序。

冒泡排序的思想：以从小到大排序为例。依次比较相邻的 2 个数据，如果前面的数据大于后面的数据，二 者交换位置，一趟下来之后，最大的数据就跑到了末尾，这个数据在下一趟不再参与比较。第二趟仍然 是依次比较相邻的 2 个数据，如果前面的数据大于后面的数据，二者交换位置，第二趟下来之后，第 2 大 的数据就跑到了倒数第二位，同样这个数据不再参与下一趟的比较，以此类推，对于具有 n 个数的数组 而言，进行 n-1 趟上述过程，就能让数组有序。

需求：有如下一组数 {67, 42, 88, 16, 25, 3} ，对其按从小到大的顺序排列。

代码：

public static void main(String[] args) {
//需求：有如下一组数{67, 42, 88, 16, 25, 3}，对其按从小到大的顺序排列。
int[] array = {67, 42, 88, 16, 25, 3};
for(int i = 0; i < array.length - 1; i++) {
for(int j = 0; j < array.length - 1 - i; j++) {
if(array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
for(int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}

分析：

//1.创建一个数组保存上述数据
//2.使用冒泡法进行排序
//原始数据 67 42 88 16 25 3------一共6个数据，共比较5趟
//第1趟，一共比较5次
// 第1次 42 67 88 16 25 3
// 第2次 42 67 88 16 25 3
// 第3次 42 67 16 88 25 3
// 第4次 42 67 16 25 88 3
// 第5次 42 67 16 25 3 88-----88不再参与下一轮比较。第1趟找出了最大
值
//第2趟，一共比较4次
// 第1次 42 67 16 25 3 88
// 第2次 42 16 67 25 3 88
// 第3次 42 16 25 67 3 88
// 第4次 42 16 25 3 67 88-----67和88不再参与下一轮比较，第2趟找出了
第2大值。
//第3趟，一共比较3次
// 第1次 16 42 25 3 67 88
// 第2次 16 25 42 3 67 88
// 第3次 16 25 3 42 67 88-----42,67,88不再参与下一轮比较，第3趟找出
了第3大值
//第4趟，一共比较2次
// 第1次 16 25 3 42 67 88
// 第2次 16 3 25 42 67 88-----25,42,67,88不再参与下一轮比较，第4趟
找出了第4大值
//第5趟，一共比较1次
// 第1次 3 16 25 42 67 88-----全部数据有序。

字符数组排序：

public class class01 {
    public static void main(String[] args) {
        char[] array={'a','b','1','2','A'};
        for (int i = 0; i < array.length-1 ; i++) {
            for (int j = 0; j < array.length-1-i ; j++) {
                if(array[j]>array[j+1]){
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=(char)temp;
                }
            }
        }
        for (int i = 0; i <array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

​​​​​​​ 冒泡排序的格式很固定：

for(int i = 0; i < 数组名 .length - 1; i++){

for(int j = 0; j < 数组名 .length - 1 - i; j++){

if( 数组名 [j] > 数组名 [j+1]){

数据类型 temp = 数组名 [j];

数组名 [j] = 数组名 [j+1];

数组名 [j+1] = temp;

}

}

}

i用来代表冒泡排序中对应的趟数，每一趟得到一个有序数字；j代表每次比较对应的当前元素 

*注意

冒泡排序的外层循环-1可以省略，只不过效率会受影响；但内层循环-1不能省略，否则会出现数组越界；内层循环控制每趟比较的次数 

选择排序

选择排序思想：以从小到大排序为例。第一趟，从数组中找出最小值，并记录最小值的下标，让最小值 与数组下标为 0 的元素交换位置。第二趟，刨除数组下标为 0 的元素，在剩下的元素中找出最小值，并记 录最小值的下标，与数组下标为 1 的元素交换位置。第三趟，刨除数组下标为 0 和 1 的元素，在剩下的元 素中找出最小值，并记录最小值的下标，与数组下标为 2 的元素交换位置，以此类推，如果要对 n 个数排 序， n-1 趟即可让数组有序。

需求：有如下一组数 {67, 42, 88, 16, 25, 3} ，对其按从小到大的顺序排列。

代码：

public static void main(String[] args) {
//需求：有如下一组数{67, 42, 88, 16, 25, 3}，对其按从小到大的顺序排列。
int[] array = {67, 42, 88, 16, 25, 3};
for(int i = 0; i < array.length - 1; i++) {
int index = i;
for(int j = i + 1; j < array.length; j++) {
if(array[j] < array[index]) {
index = j;
}
}
if(index != i){
int temp = array[index];
array[index] = array[i];
array[i] = temp;
}
}
for(int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println();
}

分析：

//1.创建一个数组保存上述数据
//2.定义变量index保存最小值的下标。
//3.使用选择排序法进行排序
//原始数据 67 42 88 16 25 3------一共6个数据，共比较5趟
//第1趟，一共比较5次 假定下标为0的元素是最小值。即index初始值是0
// 第1次 67 42 88 16 25 3 下标为1的和下标为index的比较，下标为1的更
小，将index更新为1
// 第2次 67 42 88 16 25 3 下标为2的和下标为index的比较，下标为
index比较小，不更新index
// 第3次 67 42 88 16 25 3 下标为3的和下标为index的比较，下标为3的更
小，将index更新为3
// 第4次 67 42 88 16 25 3 下标为4的和下标为index的比较，下标为
index比较小，不更新index
// 第5次 67 42 88 16 25 3 下标为5的和下标为index的比较，下标为5的更
小，将index更新为5
// 第1趟结束后，最小的元素已经找到，即下标为5的元素，让下标为5的元素和下标为0的
元素交换位置。
// 3 42 88 16 25 67---最小值就找出来了。最小值不再参与下一趟比
较。
//第2趟，一共比较4次 假定下标为1的元素是最小值。即index初始值是1
// 第1次 3 42 88 16 25 67 下标为2的和下标为index的比较，下标为
index比较小，不更新index
// 第2次 3 42 88 16 25 67 下标为3的和下标为index的比较，下标为3的更
小，将index更新为3
// 第3次 3 42 88 16 25 67 下标为4的和下标为index的比较，下标为
index比较小，不更新index
// 第4次 3 42 88 16 25 67 下标为5的和下标为index的比较，下标为
index比较小，不更新index
// 第2趟结束后，第二小的元素已经找到，即下标为3的元素，让下标为3的元素和下标为1
的元素交换位置。
// 3 16 88 42 25 67---最小值和次小值就找出来了。二者不再参与下一
趟比较。
//第3趟，一共比较3次 假定下标为2的元素是最小值。即index初始值是2
// 第1次 3 16 88 42 25 67 下标为3的和下标为index的比较，下标为3的更
小，将index更新为3
// 第2次 3 16 88 42 25 67 下标为4的和下标为index的比较，下标为4的更
小，将index更新为4
// 第3次 3 16 88 42 25 67 下标为5的和下标为index的比较，下标为
index比较小，不更新index
// 第3趟结束后，第三小的元素已经找到，即下标为4的元素，让下标为4的元素和下标为2
的元素交换位置。
// 3 16 25 42 88 67---最小的3个数就找出来了。三者不再参与下一趟
比较。
//第4趟，一共比较2次 假定下标为3的元素是最小值。即index初始值是3
// 第1次 3 16 25 42 88 67 下标为4的和下标为index的比较，下标为
index比较小，不更新index
// 第2次 3 16 25 42 88 67 下标为5的和下标为index的比较，下标为
index比较小，不更新index
// 第4趟结束后，第四小的元素已经找到，即下标为3的元素，让下标为3的元素和下标为3
的元素交换位置。
// 3 16 25 42 88 67---最小的4个数就找出来了。四者不再参与下一趟
比较。
//第5趟，一共比较1次 假定下标为4的元素是最小值。即index初始值是4
// 第1次 3 16 25 42 88 67 下标为5的和下标为index的比较，下标为5的更
小，将index更新为5
// 第5趟结束后，第五小的元素已经找到，即下标为5的元素，让下标为5的元素和下标为4
的元素交换位置。
// 3 16 25 42 67 88---至此，数据全部有序。

选择排序的写法很固定：

for(int i = 0; i < 数组名 .length - 1; i++){

int index = i;

for(int j = i + 1; j < 数组名 .length; j++){

if( 数组名 [j] < 数组名 [index]){

index = j;

}

}

if(index != i){

数据类型 temp = 数组名 [i];

数组名 [i] = 数组名 [index];

数组名 [index] = temp;

}

}

总结

冒泡排序和选择排序是两种常见的排序算法。冒泡排序通过多次相邻元素的比较和交换来排序，而选择排序通过多次选取最小值或最大值并放置到正确位置来排序。尽管这两种排序算法的时间复杂度均为O(n^2)，但选择排序通常比冒泡排序更高效。

通过理解这两种排序算法的思想和实现，我们可以更好地处理数组排序的问题，并在实际开发中选择合适的排序算法。希望本文能帮助你更好地理解冒泡排序和选择排序的原理和实现方法。