Java学习之旅（二四）：数组排序算法

亦凉 2022-11-20 04:50 202阅读 0赞

**冒泡排序**

在程序设计中，经常需要将一组数列进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序和快速排序等。冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将小数往前放、大数往后放，类似水中气泡上升的动作，所以称为冒泡排序。

1.基本思想

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到后面，也就是将比较的两个元素交换位置，这样较小的元素就像气泡一样从底部上升到顶部。

2.算法示例

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，一般为待排序数组的长度减1，因为最后一次循环只剩下一个数组元素，不需要对比，同时数组已经完成排序了。内层循环主要用于对比数组中相邻元素的大小，以确定是否交换位置，对比和交换次数随排序轮数而减少。例如，一个拥有6个元素的数组，在排序过程中每一次循环的排序过程如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70][]

第一轮外层循环时把最大的元素63移动到了最后面，第二层循环便不再对最后一个元素63进行比较了，因为它已经被确认为最大的了，需要对比的是其他的剩余元素。于是第二轮比较将24移动到了63的前一个位置。其他循环将以此类推，继续完成排序任务。

3.算法实现

public class Bubble {
    
        public static void main(String[] args) {
    
            int a[] = new int[]{63,4,24,1,3,15};
            System.out.println("排序前：");
            for (int i : a) {
                System.out.print(i + " ");
            }
            System.out.println();
            Bubble bubble  = new Bubble();
            System.out.println("排序后：");
            bubble.bubbleSort(a);
        }
        public void bubbleSort(int a[]) {
            for (int i = 1; i < a.length; i++) {
                for (int j = 0; j < a.length - i; j++) {
                    if (a[j] > a[j + 1]) {
                        int temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                    }
                }
            }
            showArray(a);
        }
        public void showArray(int a[]) {
            for (int i = 0; i < a.length; i++) {
                if (i == a.length - 1) {
                    System.out.print(a[i]);
                } else {
                    System.out.print(a[i] + "-->");
                }
            }
            System.out.println();
        }
    
    }

![20201108215806723.png][]

**直接选择排序**

直接选择排序方法属于选择排序的一种，它的排序速度要比冒泡排序快一些，也是常用的排序算法。

1.基本思想

直接选择排序的基本思想是将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。注意这里与冒泡排序的区别，不是交换相邻的元素，而是把满足条件的元素与指定的排序位置交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，最后整个数组都成为已排序好的格式。这就好比有一个小学生，从包含数字1~10的乱序的数字堆中分别选择合适的数字，组成一个1~10的排序，而这个学生首先从数字堆中选出1，放在第一位，然后选出2（此时数字堆中已经没有1了），放在第二位，以此类推，直到找到数字9，放在8的后面，最后剩下10，就不用选择了，直接放到最后就好了。

与冒泡算法相比，直接选择排序的交换次数要少很多，所以速度会快些。

2.算法示例

每一趟从待排序的数组元素中选出最小或最大的一个元素，顺序的放在已排序好的数组的最后，直到全部待排序数组的元素全部排完。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1][]

3.算法实现

public class Select {
    
        public static void main(String[] args) {
    
            int a[] = new int[]{63,4,24,1,3,15};
            System.out.println("排序前：");
            for (int i : a) {
                System.out.print(i + " ");
            }
            System.out.println();
            Select select  = new Select();
            System.out.println("排序后：");
            select.selectSort(a);
        }
        public void selectSort(int a[]) {
            int index;
            for (int i = 1; i < a.length; i++) {
                index = 0;
                for (int j = 1; j <= a.length - i; j++) {
                    if (a[j] > a[index]) {
                        index = j;
                    }
                }
                //交换在位置 a.length - i 和 index 上的两个数
                int temp = a[a.length - i];
                a[a.length - i] = a[index];
                a[index] = temp;
            }
            showArray(a);
        }
        public void showArray(int a[]) {
            for (int i = 0; i < a.length; i++) {
                if (i == a.length - 1) {
                    System.out.print(a[i]);
                } else {
                    System.out.print(a[i] + "-->");
                }
            }
            System.out.println();
        }
    
    }

![20201108223553768.png][]

**反转排序**

反转排序就是以相反的顺序把原有数组的内容重新排序。

1.基本思想

反转排序的基本思想就是把数组的最后一个元素与第一个元素交换，倒数第二个元素与第二个元素交换，以此类推，直到把所有元素反转交换。

2.算法示例

反转排序是对数组两边的元素进行交换，所以只需要循环数组长度的半数次即可，如数组长度为7的数组，只需要循环三次即可。

![20201108224349917.png][]

3.算法实现

public class ReverseSort {
    
        public static void main(String[] args) {
    
            int a[] = new int[]{10,20,30,40,50,60};
            System.out.println("排序前：");
            for (int i : a) {
                System.out.print(i + " ");
            }
            System.out.println();
            ReverseSort reverse  = new ReverseSort();
            System.out.println("排序后：");
            reverse.reverseSort(a);
        }
        public void reverseSort(int a[]) {
            int temp;
            int length = a.length;
            for (int i = 0; i < length / 2; i++) {
                temp = a[i];
                a[i] = a[length - 1 - i];
                a[length - 1 - i] = temp;
            }
            showArray(a);
        }
        public void showArray(int a[]) {
            for (int i = 0; i < a.length; i++) {
                if (i == a.length - 1) {
                    System.out.print(a[i]);
                } else {
                    System.out.print(a[i] + "-->");
                }
            }
            System.out.println();
        }
    
    }

![20201108224916462.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70]: /images/20221120/a1bd076b50844211be3944331fe4edb2.png
[20201108215806723.png]: /images/20221120/81e22c2788114270a7b11f5dbca4d208.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW9tdWJhaQ_size_16_color_FFFFFF_t_70 1]: /images/20221120/f803f99238c141469de5d3857884596d.png
[20201108223553768.png]: /images/20221120/ce24d07546db47a881df4dc2b7f55d58.png
[20201108224349917.png]: /images/20221120/52bed5f44cc6451d8c92c632874dc01c.png
[20201108224916462.png]: /images/20221120/9ca60dc5f7ee47c59286e8ef9e751215.png