用Java写一个快排的算法

这是一个简单的快速排序算法：

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

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

public static void swap(int[] arr, int left, int right) {
int temp = arr[left];
arr[left] = arr[right];
arr[right] = temp;
}

相关问题

用java写一个快排算法

这是一个 Java 实现的快速排序算法：

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

private 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;
}

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

在上面的代码中，`quickSort` 方法是递归方法，它接收三个参数：要排序的数组、要排序的数组的左端点和右端点。该方法将数组分成两部分，然后递归地对两部分进行排序。

`partition` 方法用于将数组分成两部分。它接收三个参数：要排序的数组、要排序的数组的左端点和右端点。它通过遍历数组中的元素，将小于右端点的元素移动到左侧，然后返回分界点的索引。

`swap` 方法用于交换数组中两个元素的值。它接收三个参数：要排序的数组、要交换的元素的索引和目标元素的索引。

希望这些信息能帮到你！

你能用java写个快排算法吗

当然可以！下面是一个使用Java实现快速排序算法的例子：

public class QuickSort {
    public static void sort(int[] arr, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(arr, low, high);
            sort(arr, low, pivotIndex - 1);
            sort(arr, pivotIndex + 1, high);
        }
    }

    private 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;
    }

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

你可以使用这个类来对数组进行排序，例如：

int[] arr = {4, 2, 5, 1, 3};
QuickSort.sort(arr, 0, arr.length - 1);

这将使得数组`arr`按照升序排列。