java的快速排序demo

### 回答1：

答：下面是Java语言实现的快速排序demo：
public class QuickSort {
public static void main(String[] args) {
int[] array = {5,2,4,3,1};
quickSort(array, 0, array.length-1);
for (int i : array) {
System.out.print(i + " ");
}
} private static void quickSort(int[] array, int low, int high) {
if (low < high) {
int pi = partition(array, low, high);
quickSort(array, low, pi-1);
quickSort(array, pi+1, high);
}
} private 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;
}
}

### 回答2：
快速排序（Quicksort）是一种常用的排序算法，它的思想是通过分治的方式将一个大问题逐渐分解为小问题，然后将小问题的解合并起来得到整体的解。

下面是一个Java的快速排序的示例代码：

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

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

    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`方法，通过递归的方式将数组不断划分并排序。在`quickSort`方法中，首先找到基准元素，然后根据基准元素将数组划分为两部分，并分别对这两部分递归调用`quickSort`方法。

在`partition`方法中，首先选择第一个元素作为基准元素，然后通过两个指针`low`和`high`从数组的两端向中间移动。当`low`和`high`未相遇时，分别找到小于基准元素和大于基准元素的元素，并将它们交换位置。最后，将基准元素放到最终位置，完成一次划分。

以上就是一个简单的Java快速排序的示例代码。快速排序的时间复杂度为O(nlogn)，在实际应用中具有较好的性能表现。

### 回答3：
以下是一个简单的Java快速排序的演示代码：

import java.util.Arrays;

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

        System.out.println("排序前：" + Arrays.toString(arr));

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

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            // 将数组分区，获取分区点的索引
            int partitionIndex = partition(arr, start, end);

            // 对分区点左边的子数组进行递归排序
            quickSort(arr, start, partitionIndex - 1);

            // 对分区点右边的子数组进行递归排序
            quickSort(arr, partitionIndex + 1, end);
        }
    }

    public static int partition(int[] arr, int start, int end) {
        // 选择最后一个元素作为基准值
        int pivot = arr[end];
        int i = start - 1;

        // 将小于基准值的元素移到左边，大于基准值的元素移到右边
        for (int j = start; j < end; 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[end];
        arr[end] = temp;

        return i + 1;
    }
}

这个示例演示了如何使用快速排序算法对一个整数数组进行排序。首先，定义了一个`quickSort`方法，用于递归地对数组进行排序。在快排递归的过程中，我们选择一个基准值，将小于基准值的元素移到其左边，大于基准值的元素移到其右边，并将基准值放置在合适的位置。然后，对分区点的左右子数组进行递归调用，直到整个数组排序完成。

在`main`方法中，我们创建一个包含一些无序整数的数组，并打印出排序前的数组。然后调用`quickSort`方法对数组进行快速排序。最后，我们再次打印出排序后的数组，结果将会是一个升序的数组。

值得注意的是，快速排序是一种高效的排序算法，具有平均时间复杂度为O(nlogn)，但在最坏情况下，时间复杂度为O(n^2)。因此，在实际应用中，我们可能会使用其他更优化的排序算法，如归并排序或堆排序。