devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java常用8大排序

作者：小惠珠哦 | 2024-07-25 14:34:37

赞

踩

java常用8大排序

Java中的八大排序算法是编程中常用的排序方法，每种排序算法都有其独特的特点和应用场景。以下是对Java八大排序算法的详细介绍：

1. 冒泡排序（Bubble Sort）

  • 基本思想：通过对待排序序列从前向后（或从后向前），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部（或使值较小的元素逐渐从前移向后部），就像水底的气泡一样逐渐向上冒。
  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：稳定
  1. public class BubbleSort {  
  2.     public static void bubbleSort(int[] arr) {  
  3.         int n = arr.length;  
  4.         for (int i = 0; i < n-1; i++) {  
  5.             for (int j = 0; j < n-i-1; j++) {  
  6.                 if (arr[j] > arr[j+1]) {  
  7.                     // 交换 arr[j+1] 和 arr[j]  
  8.                     int temp = arr[j];  
  9.                     arr[j] = arr[j+1];  
  10.                     arr[j+1] = temp;  
  11.                 }  
  12.             }  
  13.         }  
  14.     }  
  15.   
  16.     public static void main(String[] args) {  
  17.         int[] arr = {64, 34, 25, 12, 22, 11, 90};  
  18.         bubbleSort(arr);  
  19.         System.out.println("Sorted array");  
  20.         for (int i = 0; i < arr.length; i++)  
  21.             System.out.print(arr[i] + " ");  
  22.         System.out.println();  
  23.     }  
  24. }

2. 选择排序（Selection Sort）

  • 基本思想：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。
  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：不稳定
  1. public class SelectionSort {  
  2.     public static void selectionSort(int[] arr) {  
  3.         int n = arr.length;  
  4.         for (int i = 0; i < n-1; i++) {  
  5.             // 找到[i, n-1]区间里的最小值的索引  
  6.             int minIndex = i;  
  7.             for (int j = i+1; j < n; j++) {  
  8.                 if (arr[j] < arr[minIndex]) {  
  9.                     minIndex = j;  
  10.                 }  
  11.             }  
  12.             // 交换arr[i]和arr[minIndex]  
  13.             int temp = arr[i];  
  14.             arr[i] = arr[minIndex];  
  15.             arr[minIndex] = temp;  
  16.         }  
  17.     }  
  18.   
  19.     public static void main(String[] args) {  
  20.         int[] arr = {64, 25, 12, 22, 11};  
  21.         selectionSort(arr);  
  22.         System.out.println("Sorted array");  
  23.         for (int i = 0; i < arr.length; i++)  
  24.             System.out.print(arr[i] + " ");  
  25.         System.out.println();  
  26.     }  
  27. }

3. 插入排序（Insertion Sort）

  • 基本思想：将一个记录插入到已经排好序的有序表中，使得被插入数的序列同样是有序的。按照此法对所有元素进行插入，直到整个序列排为有序的过程。
  • 时间复杂度：O(n^2)（平均和最坏情况），O(n)（最好情况，即数据已经有序）
  • 空间复杂度：O(1)
  • 稳定性：稳定
  1. public class InsertionSort {  
  2.     public static void insertionSort(int[] arr) {  
  3.         int n = arr.length;  
  4.         for (int i = 1; i < n; ++i) {  
  5.             int key = arr[i];  
  6.             int j = i - 1;  
  7.   
  8.             /* 将arr[i]插入到arr[0...i-1]中已排序的序列中 */  
  9.             while (j >= 0 && arr[j] > key) {  
  10.                 arr[j + 1] = arr[j];  
  11.                 j = j - 1;  
  12.             }  
  13.             arr[j + 1] = key;  
  14.         }  
  15.     }  
  16.   
  17.     public static void main(String[] args) {  
  18.         int[] arr = {12, 11, 13, 5, 6};  
  19.         insertionSort(arr);  
  20.         System.out.println("Sorted array");  
  21.         for (int i = 0; i < arr.length; i++)  
  22.             System.out.print(arr[i] + " ");  
  23.         System.out.println();  
  24.     }  
  25. }

4. 希尔排序（Shell Sort）

  • 基本思想：也称缩小增量排序，是插入排序的一种更高效的改进版本。希尔排序通过将原来要排序的数列分割成几个子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
  • 时间复杂度：取决于增量序列的选择，最好为O(nlogn)，最坏为O(n^2)
  • 空间复杂度：O(1)
  • 稳定性：不稳定
  1. public class ShellSort {  
  2.   
  3.     // 希尔排序  
  4.     public static void sort(int[] arr) {  
  5.         int n = arr.length;  
  6.         // 初始步长  
  7.         for (int gap = n / 2; gap > 0; gap /= 2) {  
  8.             // 从第gap个元素开始，逐个对其所在组进行直接插入排序操作  
  9.             for (int i = gap; i < n; i++) {  
  10.                 int temp = arr[i];  
  11.                 int j;  
  12.                 // 对每个组进行插入排序  
  13.                 for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {  
  14.                     arr[j] = arr[j - gap];  
  15.                 }  
  16.                 arr[j] = temp;  
  17.             }  
  18.         }  
  19.     }  
  20.   
  21.     // 测试方法  
  22.     public static void main(String[] args) {  
  23.         int[] arr = {9, 8, 3, 7, 5, 6, 4, 1};  
  24.         sort(arr);  
  25.         System.out.println("Sorted array: ");  
  26.         for (int i = 0; i < arr.length; i++) {  
  27.             System.out.print(arr[i] + " ");  
  28.         }  
  29.     }  
  30. }

5. 快速排序（Quick Sort）

  • 基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
  • 时间复杂度：O(nlogn)（平均情况），O(n^2)（最坏情况，如数组已经有序）
  • 空间复杂度：O(logn)（递归栈空间）
  • 稳定性：不稳定
  1. public class QuickSort {  
  2.   
  3.     // 快速排序的递归方法  
  4.     public static void quickSort(int[] arr, int low, int high) {  
  5.         if (low < high) {  
  6.             // partitionIndex是分区后基准值的正确位置  
  7.             int partitionIndex = partition(arr, low, high);  
  8.   
  9.             // 递归地对基准值左边的子数组进行排序  
  10.             quickSort(arr, low, partitionIndex - 1);  
  11.   
  12.             // 递归地对基准值右边的子数组进行排序  
  13.             quickSort(arr, partitionIndex + 1, high);  
  14.         }  
  15.     }  
  16.   
  17.     // 分区方法  
  18.     private static int partition(int[] arr, int low, int high) {  
  19.         // 选择最右边的元素作为基准值  
  20.         int pivot = arr[high];  
  21.         int i = (low - 1); // 小于基准值的元素的索引  
  22.   
  23.         for (int j = low; j < high; j++) {  
  24.             // 如果当前元素小于或等于基准值  
  25.             if (arr[j] <= pivot) {  
  26.                 i++;  
  27.   
  28.                 // 交换arr[i]和arr[j]  
  29.                 int temp = arr[i];  
  30.                 arr[i] = arr[j];  
  31.                 arr[j] = temp;  
  32.             }  
  33.         }  
  34.   
  35.         // 将基准值交换到它的最终位置  
  36.         int temp = arr[i + 1];  
  37.         arr[i + 1] = arr[high];  
  38.         arr[high] = temp;  
  39.   
  40.         return i + 1;  
  41.     }  
  42.   
  43.     // 测试方法  
  44.     public static void main(String[] args) {  
  45.         int[] arr = {10, 7, 8, 9, 1, 5};  
  46.         quickSort(arr, 0, arr.length - 1);  
  47.   
  48.         System.out.println("Sorted array: ");  
  49.         for (int i = 0; i < arr.length; i++) {  
  50.             System.out.print(arr[i] + " ");  
  51.         }  
  52.     }  
  53. }

6. 归并排序（Merge Sort）

  • 基本思想：采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(n)（需要额外的数组来存储合并后的序列）
  • 稳定性：稳定
  1. public class MergeSort {  
  2.   
  3.     // 归并排序的递归方法  
  4.     public static void mergeSort(int[] arr, int left, int right) {  
  5.         if (left < right) {  
  6.             // 找到中间位置  
  7.             int middle = left + (right - left) / 2;  
  8.   
  9.             // 对左半部分进行归并排序  
  10.             mergeSort(arr, left, middle);  
  11.   
  12.             // 对右半部分进行归并排序  
  13.             mergeSort(arr, middle + 1, right);  
  14.   
  15.             // 合并两个有序数组  
  16.             merge(arr, left, middle, right);  
  17.         }  
  18.     }  
  19.   
  20.     // 合并两个有序数组的方法  
  21.     private static void merge(int[] arr, int left, int middle, int right) {  
  22.         // 创建临时数组来存储合并后的结果  
  23.         int[] temp = new int[right - left + 1];  
  24.   
  25.         // 初始化两个指针，分别指向左右两个子数组的起始位置  
  26.         int i = left;  
  27.         int j = middle + 1;  
  28.         int k = 0;  
  29.   
  30.         // 遍历两个子数组，将较小的元素先放入临时数组  
  31.         while (i <= middle && j <= right) {  
  32.             if (arr[i] <= arr[j]) {  
  33.                 temp[k++] = arr[i++];  
  34.             } else {  
  35.                 temp[k++] = arr[j++];  
  36.             }  
  37.         }  
  38.   
  39.         // 如果左子数组还有剩余元素，将它们复制到临时数组  
  40.         while (i <= middle) {  
  41.             temp[k++] = arr[i++];  
  42.         }  
  43.   
  44.         // 如果右子数组还有剩余元素，将它们复制到临时数组  
  45.         while (j <= right) {  
  46.             temp[k++] = arr[j++];  
  47.         }  
  48.   
  49.         // 将临时数组中的元素复制回原数组  
  50.         for (i = left, k = 0; i <= right; i++, k++) {  
  51.             arr[i] = temp[k];  
  52.         }  
  53.     }  
  54.   
  55.     // 测试方法  
  56.     public static void main(String[] args) {  
  57.         int[] arr = {12, 11, 13, 5, 6, 7};  
  58.         mergeSort(arr, 0, arr.length - 1);  
  59.   
  60.         System.out.println("Sorted array: ");  
  61.         for (int i = 0; i < arr.length; i++) {  
  62.             System.out.print(arr[i] + " ");  
  63.         }  
  64.     }  
  65. }

7. 堆排序（Heap Sort）

  • 基本思想：是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。
  • 时间复杂度：O(nlogn)
  • 空间复杂度：O(1)（原地排序）
  • 稳定性：不稳定
  1. public class HeapSort {  
  2.   
  3.     // 堆排序  
  4.     public static void sort(int[] arr) {  
  5.         int n = arr.length;  
  6.   
  7.         // 构建最大堆  
  8.         for (int i = n / 2 - 1; i >= 0; i--) {  
  9.             heapify(arr, n, i);  
  10.         }  
  11.   
  12.         // 一个个从堆顶取出元素  
  13.         for (int i = n - 1; i > 0; i--) {  
  14.             // 移动当前根到末尾  
  15.             int temp = arr[0];  
  16.             arr[0] = arr[i];  
  17.             arr[i] = temp;  
  18.   
  19.             // 调整剩余元素，使其重新成为最大堆  
  20.             heapify(arr, i, 0);  
  21.         }  
  22.     }  
  23.   
  24.     // 调整最大堆  
  25.     private static void heapify(int[] arr, int n, int i) {  
  26.         int largest = i; // 初始化最大为根  
  27.         int left = 2 * i + 1; // 左 = 2*i + 1  
  28.         int right = 2 * i + 2; // 右 = 2*i + 2  
  29.   
  30.         // 如果左子节点大于根  
  31.         if (left < n && arr[left] > arr[largest]) {  
  32.             largest = left;  
  33.         }  
  34.   
  35.         // 如果右子节点大于目前最大  
  36.         if (right < n && arr[right] > arr[largest]) {  
  37.             largest = right;  
  38.         }  
  39.   
  40.         // 如果最大不是根  
  41.         if (largest != i) {  
  42.             int swap = arr[i];  
  43.             arr[i] = arr[largest];  
  44.             arr[largest] = swap;  
  45.   
  46.             // 递归地调整受影响的子树  
  47.             heapify(arr, n, largest);  
  48.         }  
  49.     }  
  50.   
  51.     // 测试方法  
  52.     public static void main(String[] args) {  
  53.         int[] arr = {12, 11, 13, 5, 6, 7};  
  54.         sort(arr);  
  55.   
  56.         System.out.println("Sorted array: ");  
  57.         for (int i = 0; i < arr.length; i++) {  
  58.             System.out.print(arr[i] + " ");  
  59.         }  
  60.     }  
  61. }

8. 计数排序（Counting Sort）

  • 基本思想：不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
  • 时间复杂度：O(n+k)（k是整数的范围）
  • 空间复杂度：O(k)
  • 稳定性：稳定
  1. public class CountingSort {  
  2.   
  3.     // 计数排序  
  4.     public static void countingSort(int[] arr) {  
  5.         if (arr == null || arr.length == 0) return;  
  6.   
  7.         int max = arr[0];  
  8.         int min = arr[0];  
  9.   
  10.         // 找出数组中的最大值和最小值  
  11.         for (int i = 1; i < arr.length; i++) {  
  12.             if (arr[i] > max) max = arr[i];  
  13.             if (arr[i] < min) min = arr[i];  
  14.         }  
  15.   
  16.         // 计数数组的长度为max-min+1，用于记录每个元素的出现次数  
  17.         int[] count = new int[max - min + 1];  
  18.   
  19.         // 遍历待排序数组，统计每个元素的出现次数  
  20.         for (int i = 0; i < arr.length; i++) {  
  21.             count[arr[i] - min]++;  
  22.         }  
  23.   
  24.         // 更改count[i]，使其包含实际在arr[]中的位置信息  
  25.         // 这一步是为了确保排序的稳定性  
  26.         for (int i = 1; i < count.length; i++) {  
  27.             count[i] += count[i - 1];  
  28.         }  
  29.   
  30.         // 构建输出数组  
  31.         int[] output = new int[arr.length];  
  32.   
  33.         // 反向填充目标数组，以保持稳定性  
  34.         for (int i = arr.length - 1; i >= 0; i--) {  
  35.             output[count[arr[i] - min] - 1] = arr[i];  
  36.             count[arr[i] - min]--;  
  37.         }  
  38.   
  39.         // 将排序后的数组复制到原数组  
  40.         for (int i = 0; i < arr.length; i++) {  
  41.             arr[i] = output[i];  
  42.         }  
  43.     }  
  44.   
  45.     // 测试方法  
  46.     public static void main(String[] args) {  
  47.         int[] arr = {4, 2, 2, 8, 3, 3, 1};  
  48.         countingSort(arr);  
  49.   
  50.         System.out.println("Sorted array: ");  
  51.         for (int i = 0; i < arr.length; i++) {  
  52.             System.out.print(arr[i] + " ");  
  53.         }  
  54.     }  
  55. }

这些排序算法在Java中都有广泛的应用，根据具体的数据情况和性能要求选择合适的排序算法是非常重要的。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/880662
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号