java的快速排序怎么写

### 回答1：
快速排序是一种分治算法，其核心思想是通过选定一个基准数，将整个序列划分为比基准数小的数和比基准数大的数两个部分，再递归地对这两个部分进行快速排序。下面是一份 Java 代码实现的快速排序：

public class QuickSort {
    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int pivot = partition(arr, left, right);
            quickSort(arr, left, pivot - 1);
            quickSort(arr, pivot + 1, right);
        }
    }
 
    private static int partition(int[] arr, int left, int right) {
        int pivot = arr[right];
        int i = left - 1;
        for (int j = left; j < right; j++) {
            if (arr[j] <= pivot) {
                i++;
                swap(arr, i, j);
            }
        }
        swap(arr, i + 1, right);
        return i + 1;
    }
 
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

使用方法：

int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
QuickSort.quickSort(arr, 0, arr.length - 1);

### 回答2：
快速排序是一种常用的排序算法，它采用分治的思想。下面给出一个用Java实现快速排序的示例代码：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 3, 7, 6, 1, 8, 4};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    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[low];
        while (low < high) {
            // 从右往左找到第一个小于基准元素的位置
            while (low < high && arr[high] >= pivot) {
                high--;
            }
            // 交换元素
            arr[low] = arr[high];
            // 从左往右找到第一个大于基准元素的位置
            while (low < high && arr[low] <= pivot) {
                low++;
            }
            // 交换元素
            arr[high] = arr[low];
        }
        // 将基准元素放到最终位置
        arr[low] = pivot;
        // 返回基准元素的位置
        return low;
    }
}

以上给出了一个简单的快速排序算法实现。首先定义了一个`quickSort`方法，该方法实现了递归分治的思想，每次将数组划分为两个部分，再对左右两部分进行递归排序。划分过程通过`partition`方法实现，该方法选择一个基准元素，将小于基准的元素放在基准的左边，大于基准的元素放在基准的右边，最后返回基准元素的位置。通过递归调用`quickSort`方法，不断对左右两部分进行排序，最终得到有序的数组。最后，在`main`方法中进行测试并输出排序后的结果。

### 回答3：
快速排序是一种常用的排序算法，它的基本思想是通过确定一个基准元素，将待排序数组划分为两个子数组，其中一个子数组中的元素都小于基准元素，另一个子数组中的元素都大于基准元素。然后递归地对两个子数组进行排序，最终得到排序好的数组。

Java中的快速排序可以通过递归实现。具体步骤如下：

1. 首先，选择一个基准元素pivot。可以选择数组中的第一个元素作为基准。

2. 定义两个指针，一个指向数组的起始位置，即left，另一个指向数组的结束位置，即right。

3. 使用while循环，循环遍历数组，直到left大于等于right。

4. 在循环中，首先移动right指针，直到找到一个小于等于pivot的元素。

5. 然后移动left指针，直到找到一个大于等于pivot的元素。

6. 如果此时left仍然小于等于right，交换left和right指针所指向的元素。

7. 重复步骤4-6，直到left大于等于right。

8. 将pivot与left指针所指向的元素进行交换。

9. 递归地对基准元素左边的子数组和右边的子数组进行快速排序。

以下为Java代码示例：

public class QuickSort {
    public static void quickSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        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];
        while (left < right) {
            while (left < right && arr[right] >= pivot) {
                right--;
            }
            arr[left] = arr[right];
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            arr[right] = arr[left];
        }
        arr[left] = pivot;
        return left;
    }

    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 1, 9, 3};
        quickSort(arr, 0, arr.length - 1);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

运行以上代码，输出结果为：1 2 3 5 8 9，表示数组已经按升序排序。