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]) {
// 交换
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
✅ 2. 选择排序（Selection Sort）
原理：每次找最小元素，放到已排序部分末尾。
时间复杂度：O(n²)
稳定性：❌ 不稳定
java复制代码
public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx]) {
minIdx = j;
}
}
swap(arr, i, minIdx);
}
}
✅ 3. 插入排序（Insertion Sort）
原理：像打扑克牌，每次将新元素插入到已排序部分的正确位置。
时间复杂度 ：O(n²)，但对小数组或部分有序数组很快
稳定性：✅ 稳定
java复制代码
public static void insertionSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
✅ 4. 快速排序（Quick Sort）
原理：分治法，选一个"基准"，小的放左，大的放右，递归排序。
时间复杂度：平均 O(n log n)，最坏 O(n²)
稳定性：❌ 不稳定（但可改造为稳定）
java复制代码
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);
}
}
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;
}
✅ 5. 归并排序（Merge Sort）
原理：分治 + 合并，递归拆分，再合并有序数组。
时间复杂度：O(n log n)（始终稳定）
稳定性：✅ 稳定
Java 内部 TimSort 的基础
java复制代码
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
private static void merge(int[] arr, int l, int m, int r) {
// 合并两个有序子数组
int[] temp = new int[r - l + 1];
int i = l, j = m + 1, k = 0;
while (i <= m && j <= r) {
temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
}
while (i <= m) temp[k++] = arr[i++];
while (j <= r) temp[k++] = arr[j++];
System.arraycopy(temp, 0, arr, l, temp.length);
}
✅ 6. 堆排序（Heap Sort）
原理：利用大顶堆，每次取最大值放到末尾。
时间复杂度：O(n log n)
稳定性：❌ 不稳定
java复制代码
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--) {
swap(arr, 0, i);
heapify(arr, i, 0);
}
}
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) {
swap(arr, i, largest);
heapify(arr, n, largest);
}
}