记录下三种排序，冒泡，选择，和快速。
================================快速排序
public static void main(String[] args) {
int[] array = {5, 3, 8, 4, 2};
quickSort(array, 0, array.length - 1);
System.out.println("排序结果：");
for (int num : array) {
System.out.print(num + " ");
}
}
public static void quickSort(int[] array, int low, int high) {
if (low < high) {
int pivotIndex = partition(array, low, high); // 获取分区点的索引
quickSort(array, low, pivotIndex - 1); // 对分区点左侧进行快速排序
quickSort(array, pivotIndex + 1, high); // 对分区点右侧进行快速排序
}
}
public static int partition(int[] array, int low, int high) {
int pivot = array[high]; // 将最后一个元素作为分区点
int i = low - 1; // i为分区点的位置
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的方法，接受一个整数数组、低索引和高索引作为参数。在quickSort方法中，我们首先选择一个分区点（一般选取最后一个元素），然后使用partition方法将数组分成两个子数组，左侧子数组中的元素小于分区点，右侧子数组中的元素大于分区点。接着，我们再对子数组递归地应用快速排序算法。
在partition方法中，我们使用两个指针i和j，从低索引开始遍历数组。如果当前元素小于分区点，我们将i增加1，并将当前元素与i位置的元素交换。最后，将分区点放到正确的位置上，并返回该位置的索引。
在main方法中，我们创建了一个整数数组array，并调用quickSort方法对数组进行排序。最后，我们使用循环打印出排序后的数组。
==================================冒泡排序
public static void main(String[] args) {
int[] array = {5, 3, 8, 4, 2};
bubbleSort(array);
System.out.println("排序结果：");
for (int num : array) {
System.out.print(num + " ");
}
}
public static void bubbleSort(int[] array) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (array[j] > array[j + 1]) {
// 交换array[j]和array[j+1]
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
这个示例中，我们定义了一个名为bubbleSort的方法，接受一个整数数组作为参数。在bubbleSort方法中，我们使用两个嵌套的循环来遍历数组，比较相邻的元素，如果它们的顺序不正确，则交换它们。重复这个过程，直到整个数组排好序为止。
在main方法中，我们创建了一个整数数组array，并调用bubbleSort方法对数组进行排序。最后，我们使用循环打印出排序后的数组。
================================选择排序
public static void main(String[] args) {
int[] array = {5, 3, 8, 4, 2};
selectionSort(array);
System.out.println("排序结果：");
for (int num : array) {
System.out.print(num + " ");
}
}
public static void selectionSort(int[] array) {
int n = array.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
// 将最小元素与第i个元素交换
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
}
这个示例中，我们定义了一个名为selectionSort的方法，接受一个整数数组作为参数。在selectionSort方法中，我们使用两个嵌套的循环来遍历数组，找到未排序部分中的最小元素，并将其与当前位置的元素交换。重复这个过程，直到整个数组排好序为止。
在main方法中，我们创建了一个整数数组array，并调用selectionSort方法对数组进行排序。最后，我们使用循环打印出排序后的数组。
===================================
package test; import java.util.Arrays; public class T1 { public static void main(String[] args) { int[] a = { 5, 5, 3, 9, 4, 0, 6, 1, 8, 7 }; sort1(a); sort2(a); sort3(a); System.out.println(Arrays.toString(a)); } // 冒泡排序 public static void sort1(int[] a) { for (int i = 0; i < a.length; i++) { for (int j = 0; j < a.length - 1 - i; j++) { if (a[j] > a[j + 1]) { int tmp = a[j + 1]; a[j + 1] = a[j]; a[j] = tmp; } } } } // 选择排序 public static void sort2(int[] a) { for (int i = 0; i < a.length; i++) { for (int j = i + 1; j < a.length; j++) { if (a[i] > a[j]) { int tmp = a[j]; a[j] = a[i]; a[i] = tmp; } } } } // 快速排序 public static void sort3(int[] a) { quick(a, 0, a.length - 1); } public static void quick(int[] a, int i, int j) { int s = i, e = j; if (s >= e) { return; } int m = a[i]; while (i < j) { while (i < j && m < a[j]) { j--; } a[i] = a[j]; while (i < j && m >= a[i]) { i++; } a[j] = a[i]; } a[i] = m; quick(a, s, i - 1); quick(a, i + 1, e); } }
快速排序
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
(1)首先设定一个分界值，通过该分界值将数组分成左右两部
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值
(3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理
(4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了
冒泡排序
选择排序
