八大排序之交换排序与计数排序

 此篇更新完成后，八大排序已经全部写完，还请各位可以多多支持！🥰

八大排序[超级详细]（动图+代码优化）这一篇文章就够了_冷兮雪的博客-CSDN博客

目录

交换排序的基本思想🍭

一、冒泡排序🍭

1、基本思想🍉

2、实现代码🍉

 3、代码优化🍉

4、优缺点🍉

5、算法分析🍉

6、 应用场景🍉

二、快速排序🍭

1、基本思想🍉

2、代码实现（递归与非递归）🍉

 3、代码优化🍉

4、优缺点🍉

5、算法分析🍉

 6、应用场景🍉

计数排序

1、基本思想🍉

2、代码实现🍉

 3、优缺点🍉

4、算法分析🍉

 5、应用场景

---

交换排序的基本思想🍭

交换排序是基于比较的排序算法，其主要思想是不断比较相邻两个元素的大小，将较小的元素不断交换到数组的前面，较大的元素不断交换到数组的后面，直到整个数组有序为止。

一、冒泡排序🍭

1、基本思想🍉

冒泡排序的基本思想是通过比较相邻的两个元素的大小，将较小的元素不断交换到数组的前面，较大的元素不断交换到数组的后面。具体地，排序过程如下：

1. 比较相邻的两个元素，如果前一个元素比后一个元素大，则交换这两个元素的位置。
2. 不断重复第一步，直到将最大的元素交换到数组的最后一个位置。
3. 重复上述操作，每次将待排序的数组长度减一，直到整个数组有序为止。

2、实现代码🍉

    public static void bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

 3、代码优化🍉

 🧁冒泡排序的优化1：如果一次循环中没有发生交换，则说明数组已经有序，可以结束排序。

 优化前：

import java.util.Arrays;

public class Main {
    public static void bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                System.out.print("第 "+(i+1)+" 趟，第 "+(j+1)+" 次比较后的结果：");
                System.out.println(Arrays.toString(arr));
            }
        }
    }
    public static void main(String[] args) {
        int[] arr={2,9,7,15,49,10};
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
    }
}

 

可以看到上方的代码打印，其实有不少循环过程未发生任何变化，且已排序完成，所以此时应该提前退出循环。

优化后：

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        boolean flag = false;
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = true;
            }
        }
        if (!flag) {
            break;
        }
    }
}

 

 可以看到优化之后明显减少了排序的次数。

 🧁冒泡排序的优化2：记录每一次循环中最后一次交换的位置lastIndex，在下一次循环中，只需要比较到lastIndex的位置即可，因为lastIndex之后的元素已经有序。

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    int lastIndex = 0;
    int k = n - 1;
    for (int i = 0; i < n - 1; i++) {
        boolean flag = false;
        for (int j = 0; j < k; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = true;
                lastIndex = j;
            }
        }
        if (!flag) {
            break;
        }
        k = lastIndex;
    }
}

4、优缺点🍉

冒泡排序的主要优点是代码简单易懂，实现方便，适用于小规模的数据排序。冒泡排序的主要缺点是时间复杂度较高，为 O(n²)，不适用于大规模数据的排序。

5、算法分析🍉