JAVA经典百题之排序算法
题目：排序算法
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]) {
// Swap arr[j] and arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
优缺点:
- 优点:
- 实现简单，代码短小。
- 缺点:
- 效率较低，时间复杂度为O(n^2)。
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 minIdx = i;
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIdx])
minIdx = j;
}
int temp = arr[minIdx];
arr[minIdx] = arr[i];
arr[i] = temp;
}
}
}
优缺点:
- 优点:
- 实现简单，不占用额外空间。
- 缺点:
- 效率较低，时间复杂度为O(n^2)。
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;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
}
优缺点:
- 优点:
- 实现简单，对小规模数据或接近有序的数据排序效率高。
- 缺点:
- 效率较低，时间复杂度为O(n^2)。
4. 归并排序 (Merge Sort)
解题思路:
- 将数组递归分成子数组，然后合并这些子数组，合并过程中保持有序。
实现代码:
public class MergeSort {
public static void merge(int[] arr, int left, int middle, int right) {
int n1 = middle - left + 1;
int n2 = right - middle;
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[middle + 1 + j];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
public static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int middle = left + (right - left) / 2;
mergeSort(arr, left, middle);
mergeSort(arr, middle + 1, right);
merge(arr, left, middle, right);
}
}
}
优缺点:
- 优点:
- 稳定，时间复杂度为O(n log n)。
- 缺点:
- 需要额外的内存空间。
5. 快速排序 (Quick Sort)
解题思路:
- 选择一个基准元素，将数组分为小于基准和大于基准的两部分，然后递归地对这两部分进行排序。
实现代码:
public class QuickSort {
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public 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;
}
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);
}
}
}
优缺点:
- 优点:
- 效率高，时间复杂度平均情况下为O(n log n)。
- 缺点:
- 不稳定。
6. 堆排序 (Heap Sort)
解题思路:
- 构建最大堆（或最小堆），将堆顶元素与最后一个元素交换，然后将堆的大小减一并重新维护堆的性质。
实现代码:
public class HeapSort {
public 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 temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
heapify(arr, n, largest);
}
}
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--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}
}
优缺点:
- 优点:
- 高效的原地排序算法，时间复杂度为O(n log n)。
- 缺点:
- 不稳定。
7. 计数排序 (Counting Sort)
解题思路:
- 统计数组中每个元素的出现次数，然后根据元素值和出现次数重新构建数组。
实现代码:
public class CountingSort {
public static void countingSort(int[] arr) {
int n = arr.length;
int max = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max)
max = arr[i];
}
int[] count = new int[max + 1];
for (int i = 0; i <= max; i++)
count[i] = 0;
for (int i = 0; i < n; i++)
count[arr[i]]++;
for (int i = 1; i <= max; i++)
count[i] += count[i - 1];
int[] output = new int[n];
for (int i = n - 1; i >= 0; i--) {
output[count[arr[i]] - 1] = arr[i];
count[arr[i]]--;
}
for (int i = 0; i < n; i++)
arr[i] = output[i];
}
}
优缺点:
- 优点:
- 适用于元素范围不大的情况，时间复杂度为O(n + k)，k为最大元素值。
- 缺点:
- 对于元素范围很大的数据效率较低。
8. 桶排序 (Bucket Sort)
解题思路:
- 将元素分配到不同的桶中，对每个桶中的元素进行排序，然后合并所有桶。
实现代码:
import java.util.ArrayList;
import java.util.Collections;
public class BucketSort {
public static void bucketSort(int[] arr) {
int n = arr.length;
int max = arr[0];
int min = arr[0];
for (int i = 1; i < n; i++) {
if (arr[i] > max)
max = arr[i];
if (arr[i] < min)
min = arr[i];
}
int bucketCount = max - min + 1;
ArrayList<ArrayList<Integer>> buckets = new ArrayList<>(bucketCount);
for (int i = 0; i < bucketCount; i++)
buckets.add(new ArrayList<>());
for (int i = 0; i < n; i++) {
int bucketIndex = (arr[i] - min) * (bucketCount - 1) / (max - min);
buckets.get(bucketIndex).add(arr[i]);
}
int index = 0;
for (int i = 0; i < bucketCount; i++) {
Collections.sort(buckets.get(i));
for (int j = 0; j < buckets.get(i).size(); j++)
arr[index++] = buckets.get(i).get(j);
}
}
}
优缺点:
- 优点:
- 适用于元素分布均匀的情况，时间复杂度为O(n + k)，k为桶的个数。
- 缺点:
- 占用较多内存。
总结和推荐
- 推荐的排序算法: 归并排序和快速排序
- 归并排序和快速排序都是高效的排序算法，时间复杂度为O(n log n)，适用于各种规模的数据集。
- 归并排序是稳定的，但需要额外的内存空间，适用于所有数据类型。
- 快速排序是不稳定的，但在实践中通常比归并排序更快，适用于大规模数据集。
这里推荐归并排序作为首选，因为它是稳定的且不会对原始数据造成修改。如果在内存受限的情况下考虑，可以选择快速排序。Bubble Sort、Selection Sort 和 Insertion Sort 适用于小规模数据集或教学目的，不推荐用于实际应用。