1. 冒泡排序（Bubble Sort）
public class BubbleSort {
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换 arr[j] 和 arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
bubbleSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
2. 选择排序（Selection Sort）
public class SelectionSort {
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
// 交换 arr[i] 和 arr[minIndex]
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
selectionSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
3. 插入排序（Insertion Sort）
public class InsertionSort {
public static void insertionSort(int[] arr) {
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
/* 将大于 key 的元素向后移动 */
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
insertionSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
4. 希尔排序（Shell Sort）
public class ShellSort {
public static void shellSort(int[] arr) {
int n = arr.length;
int gap = n / 2;
// 初始gap为数组长度的一半，之后每次减半
while (gap > 0) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
// 类似插入排序，但间隔为gap
int j;
for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
arr[j] = arr[j - gap];
}
arr[j] = temp;
}
gap /= 2;
}
}
```java
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
shellSort(arr);
for (int num : arr) { // 这里是Java的增强型for循环（也称为for-each循环）
System.out.print(num + " "); // 打印排序后的数组元素
}
}
这段代码首先定义了一个整数数组arr，然后通过调用shellSort方法对这个数组进行排序。接着，使用增强型for循环（也称为"for-each"循环）遍历排序后的数组，并将每个元素打印到控制台上。在每次迭代中，num会被设置为数组中的下一个元素，然后这个元素被打印出来，后面跟着一个空格。这样，你就可以在控制台上看到排序后的数组元素了。
5. 归并排序（Merge Sort）
归并排序是一种分治策略的排序算法。它首先将数组分成两半，对每半进行排序，然后将两个已排序的半部分合并成一个完整的已排序数组。
public class MergeSort {
// 合并两个已排序的数组
public static void merge(int[] arr, int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int[] L = new int[n1];
int[] R = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[mid + 1 + j];
int i = 0, j = 0;
int k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
// 拷贝L[]的剩余元素
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// 拷贝R[]的剩余元素
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
// 分治法，递归调用
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
// 对左半部分递归排序
mergeSort(arr, left, mid);
// 对右半部分递归排序
mergeSort(arr, mid + 1, right);
// 合并左右两部分
merge(arr, left, mid, right);
}
}
// 测试函数
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
int arr_size = arr.length;
mergeSort(arr, 0, arr_size - 1);
for (int i = 0; i < arr_size; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
}
6. 快速排序（Quick Sort）
快速排序也是一种分治策略的排序算法。它选择一个元素作为基准（通常选择第一个或最后一个），然后将数组分成两部分：小于基准的元素和大于基准的元素。然后递归地对这两部分进行排序。
public class QuickSort {
// 快速排序的分区函数
public static int partition(int[] arr, int low, int high) {
int pivot = arr[high]; // 选择最右边的元素作为基准
int i = (low - 1); // 最小元素的索引，i在比它大的元素之前
for (int j = low; j <= high - 1; j++) {
// 如果当前元素小于或等于基准
if (arr[j] <= pivot) {
i++; // 递增索引i
// 交换arr[i]和arr[j]
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 quickSort(int[] arr, int low, int high) {
if (low < high) {
// pi 是分区后基准元素的索引
int pi = partition(arr, low, high);
// 分别对基准元素左右两侧的子数组进行排序
quickSort(arr, low, pi - 1);
// 刚才没写完的部分继续如下：
// 递归地对基准元素右边的子数组进行排序
quickSort(arr, pi + 1, high);
}
}
// 测试函数
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
int arr_size = arr.length;
quickSort(arr, 0, arr_size - 1);
for (int i = 0; i < arr_size; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
}
在上面的代码中，quickSort 函数是一个递归函数，它调用 partition 函数来选择一个基准（这里我们选择的是数组最后一个元素），然后将数组分成两部分：小于基准的元素和大于基准的元素。然后，它递归地对这两部分进行排序。注意，partition 函数返回的索引 pi 是基准元素在排序后数组中的位置，因此我们在递归调用时需要对基准元素的左边（low 到 pi - 1）和右边（pi + 1 到 high）分别进行排序。最后，main 函数中对测试数组 arr 进行排序并打印结果。
7. 堆排序（Heap Sort）
堆排序（Heap Sort）是一种基于二叉堆的排序算法。它首先将待排序的序列构造成一个大顶堆（或小顶堆），此时整个序列的最大值（或最小值）就是堆顶的根节点。然后将其与末尾元素进行交换，此时末尾就为最大值（或最小值）。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
以下是Java实现堆排序的代码：
public class HeapSort {
public static void heapSort(int[] arr) {
int n = arr.length;
// 构造大顶堆
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
// 一个个从堆顶取出元素
for (int i = n - 1; i >= 0; i--) {
// 将当前最大的元素arr[0]和arr[i]交换
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
// 重新对剩余的元素进行堆化
heapify(arr, i, 0);
}
}
// 将以i为根节点的子树调整为最大堆
private static void heapify(int[] arr, int n, int i) {
int largest = i; // 初始化最大值为根节点
int left = 2 * i + 1; // 左子节点
int right = 2 * i + 2; // 右子节点
// 如果左子节点比根节点大
if (left < n && arr[left] > arr[largest]) {
largest = left;
}
// 如果右子节点比当前最大的还大
if (right < n && arr[right] > arr[largest]) {
largest = right;
}
// 如果最大节点不是根节点
if (largest != i) {
// 交换根节点和最大值节点
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
// 递归地调整受影响的子树
heapify(arr, n, largest);
}
}
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6, 7};
heapSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
运行上面的代码，你会得到排序后的数组：5 6 7 11 12 13。
58万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
