排序复杂度

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

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`，如果没有发生交换说明数组已经有序，直接退出循环。

在每一轮排序结束后，使用一个循环输出当前数组的内容，以及当前轮数。这样就能够清晰地查看每一轮排序后的结果。

需要注意的是，在实际使用时，可以将冒泡排序封装成一个函数，然后在函数中打印每一轮排序后的结果，这样能够使代码更加清晰、易于维护。