Java 快速排序

快速排序是一种常用的基于比较的排序算法,其时间复杂度为 O(nlogn),并且具有稳定性和广泛的应用场景。本文将全面详细的讲解一下 Java 中快速排序算法的原理、实现以及时间复杂度等问题。

一、快速排序的原理

快速排序是一种分治思想的排序算法,其基本原理可以概括为以下三步:

  1. 选取一个基准元素,将待排序数组划分为左右两个子数组;

  2. 将比基准元素小的数都移到左子数组中,将比基准元素大的数都移到右子数组中;

  3. 对左右两个子数组递归执行上述操作,直到每个子数组只剩下一个元素为止。

具体来说,快速排序的过程如下:

  1. 首先选取待排序数组中一个元素作为基准元素,通常选择第一个元素或最后一个元素作为基准元素。

  2. 遍历数组,将小于基准元素的元素放到左边,大于等于基准元素的元素放到右边,此时数组被划分成了两个部分。

  3. 对左半部分和右半部分分别递归执行上述操作,直到排序完成。

需要注意的是,在遍历数组时,一般采用双指针法来实现。具体来说,我们使用一个左指针指向数组的第一个元素,用一个右指针指向数组的最后一个元素,然后从左到右依次遍历数组中的元素,如果当前元素小于基准元素,就将它和左指针所指的元素交换,然后将左指针向右移动一位;如果当前元素大于等于基准元素,就将它和右指针所指的元素交换,然后将右指针向左移动一位。重复上述操作直到左指针和右指针相遇为止。

二、快速排序的实现

在 Java 中,我们可以使用以下代码来实现快速排序算法:

public static void quickSort(int[] arr, int left, int right) {
    if (left < right) { // 当数组只有一个元素时结束递归
        int partitionIndex = partition(arr, left, right); // 对数组进行划分,获取基准元素位置
        quickSort(arr, left, partitionIndex - 1); // 对左子数组递归执行快速排序
        quickSort(arr, partitionIndex + 1, right); // 对右子数组递归执行快速排序
    }
}

public static int partition(int[] arr, int left, int right) {
    int pivot = arr[left]; // 将数组的第一个元素设置为基准元素
    int i = left; // 初始化左指针
    int j = right; // 初始化右指针
    while (i < j) { // 当左指针和右指针没有相遇时循环
        while (i < j && arr[j] >= pivot) { // 右指针从右向左遍历,找到第一个小于基准元素的元素
            j--;
        }
        if (i < j) { // 如果左指针和右指针没有相遇,将右指针所指的元素赋值给左指针所指的位置
            arr[i] = arr[j];
            i++;
        }
        while (i < j && arr[i] < pivot) { // 左指针从左向右遍历,找到第一个大于等于基准元素的元素
            i++;
        }
        if (i < j) { // 如果左指针和右指针没有相遇,将左指针所指的元素赋值给右指针所指的位置
            arr[j] = arr[i];
            j--;
        }
    }
    arr[i] = pivot; // 将基准元素放到最终位置
    return i; // 返回基准元素的位置
}

在上述代码中,quickSort() 方法是快速排序算法的入口,它采用递归的方式对左右两个子数组进行排序。partition() 方法则是用来对数组进行划分的,它使用双指针法来实现。

具体来说,我们首先将数组的第一个元素作为基准元素 pivot,然后初始化左指针 i 和右指针 j。接着,我们先让右指针 j 从右向左遍历数组,找到第一个小于基准元素的元素,并将其赋值给左指针所指的位置;然后让左指针 i 从左向右遍历数组,找到第一个大于等于基准元素的元素,并将其赋值给右指针所指的位置。重复上述操作直到左指针和右指针相遇。

最后,将基准元素 pivot 放到最终位置,即左指针所指的位置,这样就完成了对数组的一次划分。在 partition() 方法中,返回的是基准元素的位置,这个位置将用于快速排序算法的递归操作。

三、快速排序的时间复杂度

快速排序算法的时间复杂度主要取决于对数组进行划分的过程。在最坏情况下,如果每次划分都只能规模减少 1,那么快速排序的时间复杂度为 O(n^2),这种情况发生在数组已经排好序或基本排好序的情况下。

在平均情况下,假设每次划分可以将数组分成大小分别为 k 和 (n-k-1) 的两个子数组,那么快速排序的时间复杂度为 O(nlogn)。这是因为快速排序算法的递归深度为 logn,每一层的比较次数为 n,因此总体比较次数为 nlogn。

需要注意的是,快速排序算法的时间复杂度并不稳定,因为基准元素的选择对算法的效率有很大的影响。如果每次都选取最大或最小的元素作为基准元素,那么算法的时间复杂度将退化到 O(n^2)。因此,在实际应用中,我们通常会采用一些优化技巧来提高快速排序算法的效率,如随机选择基准元素、三数取中法等。

  • 5
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
Java快速排序的实现可以使用递归的方式来实现。快速排序的基本思想是选取一个基准元素,然后将数组中小于基准元素的数放在左边,大于基准元素的数放在右边,再对左右两个子数组分别进行快速排序,直到整个数组有序为止。 下面是Java快速排序的示例代码: ```java public class QuickSort { public static void quickSort(int[] arr, int left, int right) { if (left < right) { int partitionIndex = partition(arr, left, right); quickSort(arr, left, partitionIndex - 1); quickSort(arr, partitionIndex + 1, right); } } public static int partition(int[] arr, int left, int right) { int pivot = left; int index = pivot + 1; for (int i = index; i <= right; i++) { if (arr[i] < arr[pivot]) { swap(arr, i, index); index++; } } swap(arr, pivot, index - 1); return index - 1; } public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } public static void main(String[] args) { int[] arr = {5, 4, 3, 2, 1}; quickSort(arr, 0, arr.length - 1); System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5] } } ``` 在上面的代码中,`quickSort()` 方法调用了 `partition()` 方法来选取基准元素并进行分区,然后再递归调用 `quickSort()` 方法对左右两个子数组进行快速排序。`partition()` 方法中使用了双指针来确定小于基准元素和大于基准元素的分界点,并将小于基准元素的数放在左边,大于基准元素的数放在右边。最后,将基准元素和分界点的数交换位置,并返回分界点的位置。 运行结果为 `[1, 2, 3, 4, 5]`,说明快速排序算法成功地对数组进行了排序。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大家都说我身材好

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值