排序复杂度

• 常见的排序算法中，效率高到低的排名如下：

  1. 快速排序（Quick Sort）：时间复杂度平均情况下为 O(nlogn)，是最快的排序算法之一。
  2. 归并排序（Merge Sort）：时间复杂度稳定为 O(nlogn)，但需要消耗额外的内存空间。
  3. 堆排序（Heap Sort）：时间复杂度为 O(nlogn)，实现简单，不需要额外的内存空间。
  4. 希尔排序（Shell Sort）：时间复杂度为 O(n^(1.3-2))，是插入排序的改进版。
  5. 插入排序（Insertion Sort）：时间复杂度最好情况下为 O(n)，最坏情况下为 O(n^2)。
  6. 冒泡排序（Bubble Sort）：时间复杂度最好情况下为 O(n)，最坏情况下为 O(n^2)。

  需要注意的是，以上排序算法的时间复杂度都是在理论情况下得出的，实际运行效率还受到多种因素的影响，例如数据规模、数据分布等。此外，在实际应用中，还需要综合考虑排序算法的空间复杂度、稳定性、适用性等因素，选择最合适的排序算法。

• 下面是一个基于 Java 实现的快速排序算法，以及打印每一轮排序后的数组内容：
  
  ```java
  public class QuickSort {
      public static void main(String[] args) {
          int[] arr = { 3, 1, 7, 5, 2, 4, 6 };
          int n = arr.length;
  
          quicksort(arr, 0, n - 1);
      }
  
      public static void quicksort(int[] arr, int low, int high) {
          if (low < high) {
              int pivot = partition(arr, low, high);
              System.out.print("第 " + (pivot + 1) + " 轮排序后的数组：");
              printArr(arr);
  
              quicksort(arr, low, pivot - 1);
              quicksort(arr, pivot + 1, high);
          }
      }
  
      public static int partition(int[] arr, int low, int high) {
          int pivot = arr[low];
          int i = low + 1;
          int j = high;
  
          while (i <= j) {
              while (i <= j && arr[i] <= pivot) {
                  i++;
              }
              while (i <= j && arr[j] > pivot) {
                  j--;
              }
  
              if (i < j) {
                  int temp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = temp;
              }
          }
  
          int temp = arr[low];
          arr[low] = arr[j];
          arr[j] = temp;
  
          return j;
      }
  
      public static void printArr(int[] arr) {
          for (int k = 0; k < arr.length; k++) {
              System.out.print(arr[k] + " ");
          }
          System.out.println();
      }
  }
  ```
  
  在上面的代码中，定义了一个数组 `arr` 并初始化了其值。然后通过调用 `quicksort` 函数进行排序。`quicksort` 函数是递归实现的快速排序算法，接收数组、起始位置和结束位置三个参数，当起始位置小于结束位置时进行排序。
  
  在 `quicksort` 函数中，首先通过调用 `partition` 函数将数组分为左右两个部分，并返回分界点的位置，然后分别对左右两个部分进行递归排序。在每次递归调用结束后，会打印当前轮数以及排序后的数组内容。
  
  `partition` 函数实现了快速排序中的分区操作，选择第一个元素作为枢轴（pivot），比枢轴小的元素放在左边，比枢轴大的元素放在右边。最后将枢轴放在分界点上。在函数内部也会打印当前轮数以及排序后的数组内容。
  
  最后，在程序中定义了一个 `printArr` 函数，用于输出当前数组的内容。这样就能够清晰地查看每一轮排序后的结果。
  
  需要注意的是，在实际使用时，可以将快速排序封装成一个函数，然后在函数中打印每一轮排序后的结果，这样能够使代码更加清晰、易于维护。

   

• 下面是一个基于 Java 实现的冒泡排序，以及打印每一轮排序后的数组内容：
  
  ```java
  public class BubbleSort {
      public static void main(String[] args) {
          int[] arr = { 3, 1, 7, 5, 2, 4, 6 };
          int n = arr.length;
  
          // 冒泡排序
          for (int i = 0; i < n - 1; i++) {
              boolean swapped = false;
              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;
                      swapped = true;
                  }
              }
              System.out.print("第 " + (i + 1) + " 轮排序后的数组：");
              for (int k = 0; k < n; k++) {
                  System.out.print(arr[k] + " ");
              }
              System.out.println();
              if (!swapped) {
                  break;
              }
          }
      }
  }
  ```
  
  在上面的代码中，定义了一个数组 `arr` 并初始化了其值。然后使用两层循环实现冒泡排序，外层循环控制排序轮数，内层循环执行每一轮的比较交换操作。
  
  在内层循环中，通过判断相邻两个元素的大小，如果前者大于后者，则交换两个元素的值。同时，记录是否发生了交换的标志 `swapped`，如果没有发生交换说明数组已经有序，直接退出循环。
  
  在每一轮排序结束后，使用一个循环输出当前数组的内容，以及当前轮数。这样就能够清晰地查看每一轮排序后的结果。
  
  需要注意的是，在实际使用时，可以将冒泡排序封装成一个函数，然后在函数中打印每一轮排序后的结果，这样能够使代码更加清晰、易于维护。