排序算法比较和实现

常见的排序算法

常见的排序算法包括：

• 冒泡排序

• 选择排序

• 插入排序

• 希尔排序

• 归并排序

• 快速排序

• 堆排序

冒泡排序是一种简单的排序算法，其时间复杂度为O(n^2)。该算法的基本思想是比较相邻的两个元素，如果前一个元素大于后一个元素，则交换这两个元素的位置。重复以上操作，直到没有任何一对元素需要交换位置。冒泡排序具有简单易懂、易于实现等特点，但时间复杂度较高，因此不适用于大规模数据的排序。

选择排序是一种简单的排序算法，其时间复杂度为O(n^2)。该算法的基本思想是将数组分为已排序区间和未排序区间，每次从未排序区间中选择最小的元素，放到已排序区间的末尾。重复以上操作，直到未排序区间为空。选择排序具有简单易懂、原地排序等特点，但时间复杂度较高，因此不适用于大规模数据的排序。

插入排序是一种简单的排序算法，其时间复杂度为O(n^2)。该算法的基本思想是将数组分为已排序区间和未排序区间，每次将未排序区间的第一个元素插入到已排序区间的合适位置。重复以上操作，直到未排序区间为空。插入排序具有简单易懂、稳定等特点，但时间复杂度较高，因此不适用于大规模数据的排序。

希尔排序是一种高效的排序算法，其时间复杂度为O(n log n)。该算法的基本思想是将数组分为若干个子数组，对每个子数组进行插入排序，然后逐步缩小子数组的规模，直到最后整个数组成为一个有序序列。希尔排序具有时间复杂度好、不稳定等特点，因此被广泛应用于排序算法中。

归并排序是一种高效的排序算法，其时间复杂度为O(n log n)。该算法的基本思想是将数组分为若干个子数组，对每个子数组进行排序，然后将排好序的子数组合并成一个有序序列。归并排序具有时间复杂度好、稳定等特点，因此被广泛应用于排序算法中。

快速排序是一种高效的排序算法，其时间复杂度为O(n log n)。该算法的基本思想是选取一个元素作为基准值，将数组中小于该值的元素放在基准值左侧，大于该值的元素放在基准值右侧，然后对左右两个子数组递归进行同样的操作，直到子数组的长度为1或0。快速排序具有空间复杂度低、时间复杂度好、不稳定等特点，因此被广泛应用于排序算法中。

堆排序是一种高效的排序算法，其时间复杂度为O(n log n)。该算法的基本思想是将数组看成一颗完全二叉树，每个节点的值都大于或等于其子节点的值。将数组调整为最大堆后，将堆顶元素与最后一个元素交换位置，然后将堆的大小减1，重复以上操作，直到堆的大小为1。堆排序具有时间复杂度好、不稳定等特点，因此被广泛应用于排序算法中。

Java实现快速排序

冒泡排序是一种简单的排序算法，其时间复杂度为O(n^2)。该算法的基本思想是比较相邻的两个元素，如果前一个元素大于后一个元素，则交换这两个元素的位置。重复以上操作，直到没有任何一对元素需要交换位置。冒泡排序具有简单易懂、易于实现等特点，但时间复杂度较高，因此不适用于大规模数据的排序。

以下是Java实现冒泡排序的示例代码：

public class BubbleSort {
    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

以上代码中的sort方法接受一个整型数组arr作为参数。在sort方法内部，我们首先判断数组是否为空或长度为0，如果是，则直接返回。然后，我们使用两个嵌套的循环来遍历数组，外层循环控制比较的轮数（即数组长度减1），内层循环控制每轮比较时比较的次数（即数组长度减去已排序的元素个数减1）。如果相邻的两个元素顺序不正确，则交换它们的位置。最后，当外层循环结束时，数组已经排好序。

Java实现快速排序

快速排序是一种常用的排序算法，其时间复杂度为O(nlogn)。该算法的基本思想是选取一个元素作为基准值，将数组中小于该值的元素放在基准值左侧，大于该值的元素放在基准值右侧，然后对左右两个子数组递归进行同样的操作，直到子数组的长度为1或0。快速排序具有空间复杂度低、时间复杂度好、不稳定等特点，因此被广泛应用于排序算法中。

以下是Java实现快速排序的示例代码：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (arr == null || arr.length == 0) {
            return;
        }
        if (low >= high) {
            return;
        }
        int mid = low + (high - low) / 2;
        int pivot = arr[mid];
        int i = low, j = high;
        while (i <= j) {
            while (arr[i] < pivot) {
                i++;
            }
            while (arr[j] > pivot) {
                j--;
            }
            if (i <= j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                i++;
                j--;
            }
        }
        if (low < j) {
            sort(arr, low, j);
        }
        if (high > i) {
            sort(arr, i, high);
        }
    }
}

以上代码中的sort方法接受一个整型数组arr、一个整数low和一个整数high作为参数。其中，low表示待排序数组的起始下标，high表示待排序数组的结束下标。

在sort方法内部，我们首先判断数组是否为空或长度为0，如果是，则直接返回；接着判断low和high是否相等，如果是，则直接返回。然后，我们选取数组中的一个中间值（这里选取的是中间元素），将其作为基准值pivot。接着，我们用两个指针i和j从数组两端向中间扫描，当i所指的元素小于pivot时，i向右移动；当j所指的元素大于pivot时，j向左移动。如果i所指的元素大于或等于pivot，j所指的元素小于或等于pivot，且i小于或等于j，则交换i和j所指的元素。最后，我们递归调用sort方法对左右两个子数组进行排序，直到排序完成。

以上就是Java实现快速排序的示例代码。