Java中的八大排序实现

1. 冒泡排序（Bubble Sort）：

   • 原理：冒泡排序通过重复遍历待排序序列，比较相邻元素，并交换它们直到序列有序。
   • 时间复杂度：最坏情况下为 O(n^2)，平均情况下也为 O(n^2)。
   • 空间复杂度：O(1)。
   • 代码实现：

     public class BubbleSort {
         public static void bubbleSort(int[] array) {
             int n = array.length;
             for (int i = 0; i < n - 1; i++) {
                 for (int j = 0; j < n - i - 1; j++) {
                     if (array[j] > array[j + 1]) {
                         // 交换元素
                         int temp = array[j];
                         array[j] = array[j + 1];
                         array[j + 1] = temp;
                     }
                 }
             }
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             bubbleSort(arr);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

2. 选择排序（Selection Sort）：

   • 原理：选择排序通过重复从未排序部分选择最小（或最大）元素，然后与未排序部分的第一个元素交换位置，直到整个序列有序。
   • 时间复杂度：最坏情况下为 O(n^2)，平均情况下也为 O(n^2)。
   • 空间复杂度：O(1)。
   • 代码实现：

     public class SelectionSort {
         public static void selectionSort(int[] array) {
             int n = array.length;
             for (int i = 0; i < n - 1; i++) {
                 int minIndex = i;
                 for (int j = i + 1; j < n; j++) {
                     if (array[j] < array[minIndex]) {
                         minIndex = j;
                     }
                 }
                 // 交换元素
                 int temp = array[minIndex];
                 array[minIndex] = array[i];
                 array[i] = temp;
             }
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             selectionSort(arr);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

3. 插入排序（Insertion Sort）：

   • 原理：插入排序通过将一个元素插入到已排序序列的正确位置来对数组进行排序。
   • 时间复杂度：最坏情况下为 O(n^2)，平均情况下为 O(n^2)，最好情况下为 O(n)。
   • 空间复杂度：O(1)。
   • 代码实现：

     public class InsertionSort {
         public static void insertionSort(int[] array) {
             int n = array.length;
             for (int i = 1; i < n; ++i) {
                 int key = array[i];
                 int j = i - 1;
                 while (j >= 0 && array[j] > key) {
                     array[j + 1] = array[j];
                     j = j - 1;
                 }
                 array[j + 1] = key;
             }
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             insertionSort(arr);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

4. 希尔排序（Shell Sort）：

   • 原理：希尔排序是插入排序的一种改进版本，它通过插入排序对间隔较大的元素进行排序，从而使得数组中任意间隔为 h 的元素都是部分有序的。然后逐渐缩小 h 直至为 1，最终完成排序。
   • 时间复杂度：希尔排序的时间复杂度取决于所选取的间隔序列，最坏情况下为 O(n^2)，平均情况下为 O(n log n)。
   • 空间复杂度：O(1)。
   • 代码实现：

     public class ShellSort {
         public static void shellSort(int[] array) {
             int n = array.length;
             for (int gap = n / 2; gap > 0; gap /= 2) {
                 for (int i = gap; i < n; i++) {
                     int temp = array[i];
                     int j = i;
                     while (j >= gap && array[j - gap] > temp) {
                         array[j] = array[j - gap];
                         j -= gap;
                     }
                     array[j] = temp;
                 }
             }
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             shellSort(arr);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

5. 快速排序（Quick Sort）：

   • 原理：快速排序采用分治法，通过选取一个基准元素将数组分成两个子数组，然后递归地对子数组进行排序，最终合并成有序数组。
   • 时间复杂度：最坏情况下为 O(n^2)，平均情况下为 O(n log n)。
   • 空间复杂度：最坏情况下为 O(n)，平均情况下为 O(log n)。
   • 代码实现：

     import java.util.Arrays;
     
     public class QuickSort {
         public static void quickSort(int[] array, int low, int high) {
             if (low < high) {
                 int pivot = partition(array, low, high);
                 quickSort(array, low, pivot - 1);
                 quickSort(array, pivot + 1, high);
             }
         }
     
         public static int partition(int[] array, int low, int high) {
             int pivot = array[high];
             int i = low - 1;
             for (int j = low; j < high; j++) {
                 if (array[j] < pivot) {
                     i++;
                     int temp = array[i];
                     array[i] = array[j];
                     array[j] = temp;
                 }
             }
             int temp = array[i + 1];
             array[i + 1] = array[high];
             array[high] = temp;
             return i + 1;
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             quickSort(arr, 0, arr.length - 1);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

6. 归并排序（Merge Sort）：

   • 原理：归并排序也是采用分治法，将数组递归地分成两个子数组，然后将两个有序子数组合并成一个有序数组。
   • 时间复杂度：归并排序的时间复杂度为 O(n log n)。
   • 空间复杂度：归并排序的空间复杂度为 O(n)。
   • 代码实现：

     import java.util.Arrays;
     
     public class MergeSort {
         public static void mergeSort(int[] array, int left, int right) {
             if (left < right) {
                 int mid = (left + right) / 2;
                 mergeSort(array, left, mid);
                 mergeSort(array, mid + 1, right);
                 merge(array, left, mid, right);
             }
         }
     
         public static void merge(int[] array, int left, int mid, int right) {
             int n1 = mid - left + 1;
             int n2 = right - mid;
             int[] L = new int[n1];
             int[] R = new int[n2];
             for (int i = 0; i < n1; ++i)
                 L[i] = array[left + i];
             for (int j = 0; j < n2; ++j)
                 R[j] = array[mid + 1 + j];
             int i = 0, j = 0;
             int k = left;
             while (i < n1 && j < n2) {
                 if (L[i] <= R[j]) {
                     array[k] = L[i];
                     i++;
                 } else {
                     array[k] = R[j];
                     j++;
                 }
                 k++;
             }
             while (i < n1) {
                 array[k] = L[i];
                 i++;
                 k++;
             }
             while (j < n2) {
                 array[k] = R[j];
                 j++;
                 k++;
             }
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             mergeSort(arr, 0, arr.length - 1);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

7. 堆排序（Heap Sort）：

   • 原理：堆排序利用了堆这种数据结构。它将待排序的序列构建成一个大顶堆（或小顶堆），然后将堆顶元素与末尾元素交换，使得最大（或最小）元素沉到数组末尾，然后重新调整堆，再将堆顶元素与当前末尾元素交换，如此反复进行，直到整个序列有序。
   • 时间复杂度：堆排序的时间复杂度为 O(n log n)。
   • 空间复杂度：堆排序的空间复杂度为 O(1)。
   • 代码实现：

     import java.util.Arrays;
     
     public class HeapSort {
         public static void heapSort(int[] array) {
             int n = array.length;
             // 构建堆
             for (int i = n / 2 - 1; i >= 0; i--)
                 heapify(array, n, i);
             // 依次取出堆顶元素，调整堆
             for (int i = n - 1; i > 0; i--) {
                 int temp = array[0];
                 array[0] = array[i];
                 array[i] = temp;
                 heapify(array, i, 0);
             }
         }
     
         public static void heapify(int[] array, int n, int i) {
             int largest = i;
             int left = 2 * i + 1;
             int right = 2 * i + 2;
             if (left < n && array[left] > array[largest])
                 largest = left;
             if (right < n && array[right] > array[largest])
                 largest = right;
             if (largest != i) {
                 int temp = array[i];
                 array[i] = array[largest];
                 array[largest] = temp;
                 heapify(array, n, largest);
             }
         }
     
         public static void main(String[] args) {
             int[] arr = {64, 34, 25, 12, 22, 11, 90};
             heapSort(arr);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }

8. 基数排序（Radix Sort）：

   • 原理：基数排序是一种非比较性的排序算法，它将整数按照位数切割成不同的数字，然后按每个位数分别比较。通过分配和收集的过程，实现对整数的排序。
   • 时间复杂度：基数排序的时间复杂度为 O(d * (n + k))，其中 d 是位数，n 是数组长度，k 是基数范围。
   • 空间复杂度：基数排序的空间复杂度取决于分配和收集过程的辅助空间，通常为 O(n + k)。
   • 代码实现：

     import java.util.Arrays;
     
     public class RadixSort {
         public static void radixSort(int[] array) {
             int max = Arrays.stream(array).max().getAsInt();
             for (int exp = 1; max / exp > 0; exp *= 10)
                 countingSort(array, exp);
         }
     
         public static void countingSort(int[] array, int exp) {
             int n = array.length;
             int[] output = new int[n];
             int[] count = new int[10];
             Arrays.fill(count, 0);
             for (int i = 0; i < n; i++)
                 count[(array[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[(array[i] / exp) % 10] - 1] = array[i];
                 count[(array[i] / exp) % 10]--;
             }
             for (int i = 0; i < n; i++)
                 array[i] = output[i];
         }
     
         public static void main(String[] args) {
             int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};
             radixSort(arr);
             System.out.println("Sorted array: " + Arrays.toString(arr));
         }
     }