帮我写一个快速排序 用 java

### 回答1：

我可以给你一个快速排序的 Java 代码示例：
public class QuickSort {
public static void main(String[] args) {
int[] array = {12,20,25,17,3,15};
quickSort(array,0,array.length-1);
for(int i:array){
System.out.print(i+" ");
}
} public static void quickSort(int[] array,int start,int end) {
if(start<end) {
int baseNum = array[start];
int midNum;
int i=start;
int j=end;
do{
while((array[i]<baseNum)&&i<end){
i++;
}
while((array[j]>baseNum)&&j>start){
j--;
}
if(i<=j){
midNum=array[i];
array[i]=array[j];
array[j]=midNum;
i++;
j--;
}
}while(i<=j);
if(start<j){
quickSort(array,start,j);
}
if(end>i){
quickSort(array,i,end);
}
}
}
}

### 回答2：
快速排序是一种常用的排序算法，基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分所有元素都比另一部分小，然后再按此方法对两部分数据分别进行快速排序，整个排序过程可以递归进行，以达到排序的目的。

以下是一个用Java实现的快速排序算法：

public class QuickSort {
    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int pivotIndex = partition(arr, left, right); // 获取基准元素的索引
            quickSort(arr, left, pivotIndex - 1); // 对基准元素的左边子数组进行快速排序
            quickSort(arr, pivotIndex + 1, right); // 对基准元素的右边子数组进行快速排序
        }
    }

    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[left]; // 将最左边的元素作为基准元素
        int i = left, 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;
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 3, 6, 8, 7, 4};
        System.out.println("排序前：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();

        quickSort(arr, 0, arr.length - 1);

        System.out.println("排序后：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

以上代码实现了快速排序算法。在 `quickSort` 方法中，首先通过 `partition` 方法获取基准元素的索引，然后递归调用 `quickSort` 方法对基准元素左边的子数组和右边的子数组进行快速排序。`partition` 方法中使用双指针的方式，将小于基准元素的数移到左边，大于基准元素的数移到右边。

运行以上代码，输出结果为：

排序前：
5 2 9 1 3 6 8 7 4 
排序后：
1 2 3 4 5 6 7 8 9

可以看到，经过快速排序算法的排序，数组被正确地从小到大排序了。

### 回答3：
以下是使用Java编写的快速排序算法：

public class QuickSort {
    
    public static void main(String[] args) {
        int[] array = {5, 9, 1, 3, 6, 8, 2, 4, 7};
        
        System.out.println("排序前：");
        for (int num : array) {
            System.out.print(num + " ");
        }
        
        quickSort(array, 0, array.length - 1);
        
        System.out.println("\n排序后：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
    
    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int partitionIndex = partition(array, low, high);
            
            quickSort(array, low, partitionIndex - 1);
            quickSort(array, partitionIndex + 1, high);
        }
    }
    
    public static int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = (low - 1);
        
        for (int j = low; j < high; 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[high];
        array[high] = temp;
        
        return i + 1;
    }
}

这段代码定义了一个QuickSort类，在main方法中定义了一个待排序的数组array。先打印出未排序的数组，然后调用quickSort方法对该数组进行排序，再打印排序后的数组。

使用quickSort方法对数组进行快速排序。partition方法用于选取数组的最后一个元素作为基准值，并将数组分成小于基准值的左侧部分和大于基准值的右侧部分。然后对左右两部分递归调用quickSort方法，直到分割的子数组长度为1。快速排序的核心思想是通过每次选取一个基准值，将数组分割成两部分，一部分小于基准值，一部分大于基准值。在每次递归时，选择合适的基准值，不断缩小问题规模，最终达到排序的目的。