java快速排序算法代码

### 回答1：

Java快速排序算法的代码如下：
public class QuickSort {
public static void sort(int[] arr, int low, int high) {
if (arr == null || arr.length == 0)
return;

if (low >= high)
return;

// pick the pivot
int middle = low + (high - low) / 2;
int pivot = arr[middle];

// make left < pivot and right > 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--;
}
}

// recursively sort two sub parts
if (low < j)
sort(arr, low, j);

if (high > i)
sort(arr, i, high);
}
}

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

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

    public static void quickSort(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivotIndex = partition(array, left, right);
        quickSort(array, left, pivotIndex - 1);
        quickSort(array, pivotIndex + 1, right);
    }

    public static int partition(int[] array, int left, int right) {
        int pivot = array[right];
        int i = left - 1;
        for (int j = left; j < right; j++) {
            if (array[j] < pivot) {
                i++;
                swap(array, i, j);
            }
        }
        swap(array, i + 1, right);
        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()`方法来确定基准元素的位置并进行划分。然后，对基准元素的左边和右边的子数组调用`quickSort()`方法进行递归排序。`swap()`方法用于交换两个元素的位置。

在代码的主函数中，我们初始化一个整型数组，并通过调用`quickSort()`方法对它进行排序。最后，输出排序后的数组。运行程序后，输出结果为：1 2 3 4 5 6，表示排序成功。

### 回答3：
Java快速排序算法是一种高效的排序算法，其基本思想是通过选择一个元素作为基准值，将数组分成两部分，一部分小于基准值，一部分大于基准值。然后递归地对两部分进行排序，最终得到有序数组。

下面是Java实现快速排序算法的代码：

public class QuickSort {

    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);

            // 递归地对基准值左侧和右侧进行排序
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 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 main(String[] args) {
        int[] arr = {6, 5, 3, 8, 1, 9, 2, 4, 7};
        int n = arr.length;

        quickSort(arr, 0, n - 1);

        System.out.println("排序后的数组：");
        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

以上代码实现了快速排序算法。首先定义了`quickSort()`方法用于递归地对数组进行排序。在`partition()`方法中，选择最后一个元素作为基准值，通过比较和交换将较小的元素移动到基准值的左侧，较大的元素移动到右侧。然后递归地对左侧和右侧进行排序，直到数组完全有序。最后在`main()`方法中调用`quickSort()`方法并输出排序后的数组。