Java快速排序代码怎么写

### 回答1：

Java 快速排序的代码可以使用以下方式来实现： public static void quickSort(int[] arr, int left, int right) {
int i = left, j = right;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot) {
i++;
}
while (arr[j] > pivot) {
j--;
}
if (i <= j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
}
if (left < j)
quickSort(arr, left, j);
if (i < right)
quickSort(arr, i, right);
}

### 回答2：
java中的快速排序算法可以通过递归来实现。以下是一个简单的快速排序代码示例：

public class QuickSort {

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

    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivot = partition(array, low, high);
            quickSort(array, low, pivot - 1);
            quickSort(array, pivot + 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++;
                swap(array, i, j);
            }
        }

        swap(array, i + 1, high);
        return i + 1;
    }

    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

上述代码中，我们首先定义了一个用于快速排序的`quickSort`方法。在这个方法中，我们通过选择一个基准元素（通常是数组中的最后一个元素）来进行分区。在分区过程中，我们将小于基准元素的元素移到左边，大于基准元素的元素移到右边。然后，我们递归地对左右两个分区进行快速排序。

`partition`方法用于实现分区过程。它选择基准元素，并通过遍历数组来将小于基准元素的元素移到左边。最后，我们将基准元素放在分区的正确位置上，并返回分区的索引。

`swap`方法用于交换数组中两个元素的位置。

在`main`方法中，我们可以看到我们如何调用`quickSort`方法，并打印排序后的数组。对于输入数组`{5, 2, 9, 1, 3, 6}`，输出将是`1 2 3 5 6 9`。

### 回答3：
快速排序是一种常用的排序算法，其基本思想是选取一个基准元素，将数组分为两个子数组，比基准元素小的放在左边，比基准元素大的放在右边，然后递归对子数组进行排序，直到整个数组有序。

下面是用Java实现快速排序的代码示例：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 9, 3, 1, 8, 6, 2, 4, 7};

        System.out.println("Before sorting:");
        printArray(arr);

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

        System.out.println("After sorting:");
        printArray(arr);
    }

    public static 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);
        }
    }

    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++;

                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

以上代码中，`quickSort`方法是快速排序的主方法，其中调用`partition`方法来获取基准元素的位置，然后递归调用`quickSort`方法对左右子数组进行排序。

`partition`方法用于将数组根据基准元素分为两个子数组，左边的数组小于基准元素，右边的数组大于基准元素，并返回基准元素的位置。在`partition`方法中使用双指针的方式，从左到右扫描数组，找到小于基准元素的元素后与指针`i`指向的元素交换位置。

最后，输出排序后的数组。

运行上述代码，输出结果为:

Before sorting:
5 9 3 1 8 6 2 4 7 
After sorting:
1 2 3 4 5 6 7 8 9

以上是一个简单的快速排序实现，对于大规模数据或者特定场景下，可能需要对其进行优化，例如随机选择基准元素、三数取中法选择基准元素等。