Java快速排序知识点(含面试大厂题和源码)

快速排序(Quick Sort)是一种高效的排序算法,采用分治法(Divide and Conquer)的策略来对一个数组进行排序。快速排序的平均时间复杂度为 O(n log n),在最坏的情况下为 O(n^2),但这种情况很少发生。快速排序因其高效性而在实际应用中非常受欢迎。

快速排序的工作原理:

  1. 选择基准值:从数组中选择一个元素作为基准值(pivot),选择方法有多种,如第一个元素、最后一个元素、中间元素或随机元素。
  2. 分区操作:重新排列数组,所有比基准值小的元素摆放在基准值的前面,所有比基准值大的元素摆放在基准值的后面(相等的可以到任一边)。在这个分区退出之后,基准值所在的位置就是其最终位置。
  3. 递归排序:递归地对基准值左侧和右侧的子数组进行快速排序。

快速排序的优缺点:

优点

  • 在平均情况下,快速排序具有很好的性能,时间复杂度为 O(n log n)。
  • 快速排序是原地排序,不需要额外的存储空间。

缺点

  • 最坏情况下的时间复杂度为 O(n^2),但可以通过随机化来避免。
  • 快速排序是不稳定的排序方法,相等的元素可能会在排序后相对位置发生变化。

快速排序的Java实现:

java 复制代码
public class QuickSort {
    public void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    private 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++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return i + 1;
    }

    private 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) {
        QuickSort solution = new QuickSort();
        int[] arr = {10, 7, 8, 9, 1, 5};
        solution.quickSort(arr, 0, arr.length - 1);
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

在面试中,快速排序是一个重要的知识点,它考察应聘者对分治法策略和递归思想的理解。通过实现快速排序,可以展示你对基本算法和数据结构的掌握程度。希望这些知识点和示例代码能够帮助你更好地准备面试!快速排序是一种流行且高效的排序算法,经常被用于面试中考察应聘者的算法实现能力。以下是三道可能出现在大厂面试中的与快速排序相关的编程题目,以及相应的Java源码实现。

题目 1:快速排序实现

描述

实现快速排序算法,对给定数组进行排序。

示例

输入: [3, 6, 8, 10, 1, 2, 1]
输出: 经过排序后的数组

Java 源码

java 复制代码
import java.util.Arrays;

public class QuickSortImplementation {
    public void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    private 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++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return i + 1;
    }

    private 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) {
        QuickSortImplementation solution = new QuickSortImplementation();
        int[] arr = {3, 6, 8, 10, 1, 2, 1};
        solution.quickSort(arr, 0, arr.length - 1);
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
}

题目 2:快速排序的变种 - 三数取中法的基准选择

描述

在快速排序中,基准值的选择对性能有很大影响。使用三数取中法选择基准值,即在数组中随机选择三个元素,然后取它们的中值作为基准值。

示例

输入: [3, 6, 8, 10, 1, 2, 1]
输出: 经过排序后的数组

Java 源码

java 复制代码
import java.util.Random;

public class QuickSortMedianOfThree {
    // 其他方法与上题相同,仅 partition 方法改变

    private int partition(int[] arr, int low, int high) {
        Random random = new Random();
        int pivotIndex = medianOfThree(arr, low, high);
        swap(arr, pivotIndex, high);
        int pivot = arr[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, high);
        return i + 1;
    }

    private int medianOfThree(int[] arr, int low, int high) {
        int mid = low + (high - low) / 2;
        if (arr[low] > arr[mid]) swap(arr, low, mid);
        if (arr[low] > arr[high]) swap(arr, low, high);
        if (arr[mid] > arr[high]) swap(arr, mid, high);
        swap(arr, mid, high);
        return high;
    }

    // swap 方法与上题相同
    // main 方法与上题相同
}

题目 3:快速排序优化 - 尾递归优化

描述

在快速排序中,对较小的子数组使用尾递归优化,以减少递归深度。

示例

输入: [3, 6, 8, 10, 1, 2, 1]
输出: 经过排序后的数组

Java 源码

java 复制代码
public class QuickSortTailRecursion {
    // quickSort 方法与上题相同

    private int partition(int[] arr, int low, int high) {
        // ... 与上题相同
    }

    private void swap(int[] arr, int i, int j) {
        // ... 与上题相同
    }

    public static void main(String[] args) {
        QuickSortTailRecursion solution = new QuickSortTailRecursion();
        int[] arr = {3, 6, 8, 10, 1, 2, 1};
        solution.quickSort(arr, 0, arr.length - 1);
        System.out.println("Sorted array: " + Arrays.toString(arr));
    }
    
    // 添加 tailRecursiveQuickSort 方法进行尾递归优化
    public void tailRecursiveQuickSort(int[] arr, int low, int high) {
        while (low < high) {
            int pivotIndex = partition(arr, low, high);
            if (pivotIndex - low < high - pivotIndex) {
                tailRecursiveQuickSort(arr, low, pivotIndex - 1);
                low = pivotIndex + 1;
            } else {
                tailRecursiveQuickSort(arr, pivotIndex + 1, high);
                high = pivotIndex - 1;
            }
        }
    }
}

这些题目和源码展示了快速排序的不同应用和优化技巧。在面试中,能够根据问题的特点选择合适的算法并实现其解决方案是非常重要的。希望这些示例能够帮助你更好地准备面试!

相关推荐
一只爱打拳的程序猿3 分钟前
【Spring】更加简单的将对象存入Spring中并使用
java·后端·spring
杨荧4 分钟前
【JAVA毕业设计】基于Vue和SpringBoot的服装商城系统学科竞赛管理系统
java·开发语言·vue.js·spring boot·spring cloud·java-ee·kafka
minDuck6 分钟前
ruoyi-vue集成tianai-captcha验证码
java·前端·vue.js
为将者,自当识天晓地。25 分钟前
c++多线程
java·开发语言
daqinzl33 分钟前
java获取机器ip、mac
java·mac·ip
激流丶1 小时前
【Kafka 实战】如何解决Kafka Topic数量过多带来的性能问题?
java·大数据·kafka·topic
Themberfue1 小时前
Java多线程详解⑤(全程干货!!!)线程安全问题 || 锁 || synchronized
java·开发语言·线程·多线程·synchronized·
时差9531 小时前
【面试题】Hive 查询:如何查找用户连续三天登录的记录
大数据·数据库·hive·sql·面试·database
让学习成为一种生活方式1 小时前
R包下载太慢安装中止的解决策略-R语言003
java·数据库·r语言
晨曦_子画1 小时前
编程语言之战:AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin