java的快速排序怎么写?

### 回答1：
Java语言中实现快速排序的代码如下:

public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (arr == null || arr.length == 0)
            return;
 
        if (low >= high)
            return;
 
        // 选定分界点
        int middle = low + (high - low) / 2;
        int pivot = arr[middle];
 
        // 将小于等于pivot的数放在左边，大于pivot的数放在右边
        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)
            quickSort(arr, low, j);
 
        if (high > i)
            quickSort(arr, i, high);
    }
}

使用时可以这样调用:

int[] arr = {10, 7, 8, 9, 1, 5};
QuickSort.quickSort(arr, 0, arr.length - 1);

上面的代码是基于分治法的快速排序的实现。其原理是：选定一个分界点，把数组分成两个部分，一部分的所有数字都比分界点小，另一部分的所有数字都比分界点大，然后对两个部分递归地进行快速排序。

### 回答2：
快速排序是一种常用的排序算法，它通过分治的思想将一个待排序数组分成两个子数组，递归地对子数组进行排序，最终得到有序数组。下面是Java实现快速排序的伪代码：

public class QuickSort {
    
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);
            
            quickSort(arr, low, pivot - 1);
            quickSort(arr, pivot + 1, high);
        }
    }
    
    public static 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;
    }
    
    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 = {9, 4, 7, 2, 1, 5, 8, 3, 6};
        
        quickSort(arr, 0, arr.length - 1);
        
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

快速排序的思想是选取一个基准元素（pivot），将数组分为两部分：小于基准元素的部分和大于基准元素的部分。然后对这两部分分别递归地进行快速排序，直到每个子数组都只有一个元素为止。最后通过递归回溯，将各个子数组合并，得到最终的有序数组。

以上是一个简单的快速排序实现的代码，通过调用quickSort方法可以对一个整型数组进行快速排序。