你好，请给出 java版本 的快速排序 示例代码，代码部分请用markdown格式

### 回答1：

public static void quickSort(int[] array, int start, int end) {
    if (start < end) {
        int pivotIndex = partition(array, start, end);
        quickSort(array, start, pivotIndex - 1);
        quickSort(array, pivotIndex + 1, end);
    }
}public static int partition(int[] array, int start, int end) {
    int pivot = array[end];
    int i = start - 1;
    for (int j = start; j <= end - 1; j++) {
        if (array[j] <= pivot) {
            i++;
            int temp = array[i];
            array[i] = array[j];
            array[j] = temp;
        }
    }
    int temp = array[i + 1];
    array[i + 1] = array[end];
    array[end] = temp;
    return i + 1;
}

### 回答2：

// 快速排序示例代码
public class QuickSort {
    
    public static void main(String[] args) {
        int[] nums = {5, 9, 3, 1, 8, 6, 2, 7, 4};
        quickSort(nums, 0, nums.length - 1);
        System.out.println("排序后的结果：");
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
    
    public static void quickSort(int[] nums, int left, int right) {
        if (left < right) {
            // 将数组划分为基准元素左右两个子数组
            int partitionIndex = partition(nums, left, right);
            // 递归地对子数组进行排序
            quickSort(nums, left, partitionIndex - 1);
            quickSort(nums, partitionIndex + 1, right);
        }
    }
    
    public static int partition(int[] nums, int left, int right) {
        // 选择数组的最后一个元素作为基准元素
        int pivot = nums[right];
        // 初始化划分索引为左边界
        int partitionIndex = left;
        
        // 遍历数组并将比基准元素小的元素移动到左侧
        for (int i = left; i < right; i++) {
            if (nums[i] < pivot) {
                swap(nums, i, partitionIndex);
                partitionIndex++;
            }
        }
        
        // 将基准元素放置到正确的位置
        swap(nums, partitionIndex, right);
        
        return partitionIndex;
    }
    
    public static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

这段代码实现了快速排序算法，通过递归地对子数组进行排序来实现整个数组的排序。在排序过程中，选择数组的最后一个元素作为基准元素，然后通过遍历数组将比基准元素小的元素移动到左侧，最后将基准元素放置到正确的位置。通过不断划分和排序子数组，最终完成整个数组的排序。

### 回答3：

public class QuickSort {
    public static void main(String[] args) {
        int[] nums = {7, 2, 4, 1, 5, 3};
        quickSort(nums, 0, nums.length - 1);
        System.out.println("排序结果：");
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
    
    public static void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int pivot = partition(nums, low, high);
            quickSort(nums, low, pivot - 1);
            quickSort(nums, pivot + 1, high);
        }
    }
    
    public static int partition(int[] nums, int low, int high) {
        int pivot = nums[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (nums[j] < pivot) {
                i++;
                swap(nums, i, j);
            }
        }
        swap(nums, i + 1, high);
        return i + 1;
    }
    
    public static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

快速排序是一种基于分治的排序算法，基本思想是通过一趟排序将待排序的数据分成两部分，一部分比基准元素小，一部分比基准元素大。然后递归地对两部分进行快速排序，直到整个序列有序。

上述代码中，main方法为入口方法，定义了一个待排序的整型数组nums。使用quickSort方法对nums进行快速排序，在递归的过程中不断选择基准元素并将数组分成两部分。partition方法用于选取基准元素并完成一趟排序，采用的是“挖坑填数”的方式。swap方法用于交换两个元素的位置。最后打印排序结果。