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 - i - 1; 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[minIndex];
           arr[minIndex] = arr[i];
           arr[i] = 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 = j - 1;
           }
           arr[j + 1] = key;
       }
   }

4. 快速排序（Quick Sort）：选择一个基准元素，将小于基准的元素放在它的左边，大于基准的元素放在它的右边，然后对左右两个子数组递归地进行快速排序。平均时间复杂度为O(nlogn)，但最坏情况下可能达到O(n^2)。

   public static void quickSort(int[] arr, int low, int high) {
       if (low < high) {
           int pi = partition(arr, low, high);
           quickSort(arr, low, pi - 1);
           quickSort(arr, pi + 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(nlogn)，但空间复杂度较高。

   public static void mergeSort(int[] arr, int left, int right) {
       if (left < right) {
           int mid = (left + right) / 2;
           mergeSort(arr, left, mid);
           mergeSort(arr, mid + 1, right);
           merge(arr, left, mid, right);
       }
   }
   
   private static void merge(int[] arr, 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] = arr[left + i];
       }
       for (int j = 0; j < n2; ++j) {
           R[j] = arr[mid + 1 + j];

6. 堆排序（Heap Sort）：将数组构建成一个最大堆（或最小堆），然后不断取出堆顶元素并调整堆，直至排序完成。时间复杂度为O(nlogn)，空间复杂度较低。