JAVA七种常见排序算法

小鱼儿 2024-02-20 12:53 56阅读 0赞

> 前言： 排序算法在计算机科学中扮演着至关重要的角色，它们用于将无序数据变为有序数据，以便更有效地检索和处理信息。不同的排序算法适用于不同的情况，因此了解它们的工作原理和性能特点对于选择正确的算法至关重要。本文提供的Java示例代码有助于理解这些排序算法的基本原理和实现方式，以便在实际应用中选择合适的排序算法来提高效率。无论是面试准备还是实际开发中，对排序算法的理解都是非常有价值的知识。

> 1、冒泡排序（Bubble Sort）： 冒泡排序是一种简单的比较排序算法，它重复地遍历待排序数组，比较相邻元素，并交换它们，直到整个数组有序为止。它的时间复杂度为O(n^2)，不适用于大规模数据集。
> 
>     public static void bubbleSort(int[] arr) {
>         int n = arr.length;
>         for (int i = 0; i < n - 1; i++) {
>             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;
>                 }
>             }
>         }
>     }

> 2、选择排序（Selection Sort）： 选择排序也是一种简单的比较排序算法，它将数组分为已排序和未排序两部分，每次从未排序部分选择最小的元素并将其放入已排序部分。它的时间复杂度为O(n^2)，不适用于大规模数据集。
> 
>     public static void selectionSort(int[] arr) {
>         int n = arr.length;
>         for (int i = 0; i < n - 1; i++) {
>             int minIndex = i;
>             for (int j = i + 1; j < n; j++) {
>                 if (arr[j] < arr[minIndex]) {
>                     minIndex = j;
>                 }
>             }
>             int temp = arr[i];
>             arr[i] = arr[minIndex];
>             arr[minIndex] = temp;
>         }
>     }

> 3、插入排序（Insertion Sort）： 插入排序是一种简单的比较排序算法，它将数组分为已排序和未排序两部分，每次从未排序部分选择一个元素插入已排序部分的适当位置。它的时间复杂度为O(n^2)，对于小型数据集和基本有序的数组性能较好。
> 
>     public static void insertionSort(int[] arr) {
>         int n = arr.length;
>         for (int i = 1; i < n; i++) {
>             int key = arr[i];
>             int j = i - 1;
>             while (j >= 0 && arr[j] > key) {
>                 arr[j + 1] = arr[j];
>                 j--;
>             }
>             arr[j + 1] = key;
>         }
>     }

> 4、快速排序（Quick Sort）： 快速排序是一种分而治之的比较排序算法，它选择一个基准元素，将数组分成两部分，左边的元素小于基准，右边的元素大于基准，然后递归地对这两部
> 
> 分进行排序。它的平均时间复杂度为O(n log n)，性能较好。
> 
>     public static void quickSort(int[] arr, int low, int high) {
>         if (low < high) {
>             int pivot = partition(arr, low, high);
>             quickSort(arr, low, pivot - 1);
>             quickSort(arr, pivot + 1, high);
>         }
>     }
>     
>     private static int partition(int[] arr, int low, int high) {
>         int pivot = arr[high];
>         int i = low - 1;
>         for (int j = low; j < high; j++) {
>             if (arr[j] < pivot) {
>                 i++;
>                 int temp = arr[i];
>                 arr[i] = arr[j];
>                 arr[j] = temp;
>             }
>         }
>         int temp = arr[i + 1];
>         arr[i + 1] = arr[high];
>         arr[high] = temp;
>         return i + 1;
>     }

> 5、归并排序（Merge Sort）： 归并排序也是一种分而治之的比较排序算法，它将数组分成两部分，分别对这两部分进行排序，然后将它们合并为一个有序数组。它的时间复杂度为O(n log n)，性能稳定。
> 
>     public static void mergeSort(int[] arr) {
>         if (arr.length > 1) {
>             int mid = arr.length / 2;
>             int[] left = Arrays.copyOfRange(arr, 0, mid);
>             int[] right = Arrays.copyOfRange(arr, mid, arr.length);
>     
>             mergeSort(left);
>             mergeSort(right);
>     
>             merge(arr, left, right);
>         }
>     }
>     
>     private static void merge(int[] arr, int[] left, int[] right) {
>         int i = 0, j = 0, k = 0;
>         while (i < left.length && j < right.length) {
>             if (left[i] < right[j]) {
>                 arr[k] = left[i];
>                 i++;
>             } else {
>                 arr[k] = right[j];
>                 j++;
>             }
>             k++;
>         }
>         while (i < left.length) {
>             arr[k] = left[i];
>             i++;
>             k++;
>         }
>         while (j < right.length) {
>             arr[k] = right[j];
>             j++;
>             k++;
>         }
>     }

> 6、堆排序（Heap Sort）： 堆排序是一种选择排序，它使用二叉堆数据结构来进行排序。它的基本思想是将待排序的数组构建成一个最大堆（或最小堆），然后将堆顶元素与堆底元素交换，从堆中移除最大（或最小）元素，并递减堆的大小，重复这个过程直到堆为空。它的时间复杂度为O(n log n)，性能稳定。
> 
>     public static void heapSort(int[] arr) {
>         int n = arr.length;
>     
>         // 构建最大堆
>         for (int i = n / 2 - 1; i >= 0; i--) {
>             heapify(arr, n, i);
>         }
>     
>         // 依次取出堆顶元素并调整堆
>         for (int i = n - 1; i > 0; i--) {
>             int temp = arr[0];
>             arr[0] = arr[i];
>             arr[i] = temp;
>     
>             heapify(arr, i, 0);
>         }
>     }
>     
>     private static void heapify(int[] arr, int n, int i) {
>         int largest = i;
>         int left = 2 * i + 1;
>         int right = 2 * i + 2;
>     
>         if (left < n && arr[left] > arr[largest]) {
>             largest = left;
>         }
>     
>         if (right < n && arr[right] > arr[largest]) {
>             largest = right;
>         }
>     
>         if (largest != i) {
>             int swap = arr[i];
>             arr[i] = arr[largest];
>             arr[largest] = swap;
>     
>             heapify(arr, n, largest);
>         }
>     }

> 7、基数排序（Radix Sort）： 基数排序是一种非比较排序算法，它根据元素的位数进行排序。它将待排序的元素分成多个桶，然后按照位数的顺序依次对每个桶进行排序。它可以用于整数或字符串的排序。基数排序的时间复杂度取决于元素的位数和桶的数量，通常为O(n \* k)，其中n是元素数量，k是位数。
> 
>     public static void radixSort(int[] arr) {
>         int max = Arrays.stream(arr).max().getAsInt();
>         int exp = 1;
>     
>         while (max / exp > 0) {
>             countingSort(arr, exp);
>             exp *= 10;
>         }
>     }
>     
>     private static void countingSort(int[] arr, int exp) {
>         int n = arr.length;
>         int[] output = new int[n];
>         int[] count = new int[10];
>     
>         for (int i = 0; i < n; i++) {
>             count[(arr[i] / exp) % 10]++;
>         }
>     
>         for (int i = 1; i < 10; i++) {
>             count[i] += count[i - 1];
>         }
>     
>         for (int i = n - 1; i >= 0; i--) {
>             output[count[(arr[i] / exp) % 10] - 1] = arr[i];
>             count[(arr[i] / exp) % 10]--;
>         }
>     
>         for (int i = 0; i < n; i++) {
>             arr[i] = output[i];
>         }
>     }

> 总结：冒泡排序、选择排序和插入排序是最基本的排序算法，适用于小型数据集或作为排序算法的基础。快速排序和归并排序是分而治之的排序算法，适用于中等规模数据集，性能良好。堆排序是一种选择排序，适用于大规模数据集，性能稳定。基数排序是非比较排序算法，适用于整数或字符串排序。