十大经典排序算法的 Java 实现

Android

2023-11-15 14:23:29

排序算法：对数据进行分类和组织的工具

在计算机科学中，排序算法是至关重要的工具，用于对大量数据进行分类和组织，以提高效率和性能。本文将探讨十大经典排序算法的 Java 实现，深入分析其特性、优点和局限性。

排序算法的特性

排序算法有几个关键特性，包括：

稳定性： 指算法是否保持数据集中具有相同值的元素的相对顺序。
时间复杂度： 表示算法所需的操作次数。
空间复杂度： 表示算法需要的内存量。

十大经典排序算法

十大经典排序算法按照时间复杂度从低到高的顺序排列：

冒泡排序 ：简单但效率低下，时间复杂度为 O(n^2)。
选择排序 ：找到最小元素并将其移到最前面，时间复杂度为 O(n^2)。
插入排序 ：适用于小数据集，时间复杂度为 O(n^2)。
快速排序 ：高效的递归算法，时间复杂度为 O(n log n)。
归并排序 ：依赖递归和合并操作，时间复杂度为 O(n log n)。
堆排序 ：基于堆数据结构，时间复杂度为 O(n log n)。
计数排序 ：适用于值范围有限的数据集，时间复杂度为 O(n + k)。
桶排序 ：将数据划分为较小组，时间复杂度为 O(n + k)。
基数排序 ：适用于具有相同长度密钥的数据集，时间复杂度为 O(nk)。
桶排序 ：适用于整数或可哈希的数据，时间复杂度为 O(n)。

Java 实现示例

每个算法的 Java 实现如下：

// 冒泡排序
public static int[] bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 1; j < arr.length; j++) {
            if (arr[j - 1] > arr[j]) {
                swap(arr, j - 1, j);
            }
        }
    }
    return arr;
}

// 选择排序
public static int[] selectionSort(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        int min = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        swap(arr, i, min);
    }
    return arr;
}

// 插入排序
public static int[] 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;
    }
    return arr;
}

// 快速排序
public static int[] quickSort(int[] arr) {
    if (arr == null || arr.length <= 1) {
        return arr;
    }
    int pivot = arr[arr.length - 1];
    int[] left = new int[0];
    int[] right = new int[0];
    for (int i = 0; i < arr.length - 1; i++) {
        if (arr[i] < pivot) {
            left = append(left, arr[i]);
        } else {
            right = append(right, arr[i]);
        }
    }
    return append(append(quickSort(left), pivot), quickSort(right));
}

// 归并排序
public static int[] mergeSort(int[] arr) {
    if (arr == null || arr.length <= 1) {
        return arr;
    }
    int mid = arr.length / 2;
    int[] left = new int[mid];
    int[] right = new int[arr.length - mid];
    System.arraycopy(arr, 0, left, 0, mid);
    System.arraycopy(arr, mid, right, 0, arr.length - mid);
    left = mergeSort(left);
    right = mergeSort(right);
    return merge(left, right);
}

// 堆排序
public static int[] 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);
    }
    return arr;
}

// 计数排序
public static int[] countingSort(int[] arr) {
    int max = findMax(arr);
    int[] counts = new int[max + 1];
    for (int i : arr) {
        counts[i]++;
    }
    int[] output = new int[arr.length];
    int j = 0;
    for (int i = 0; i <= max; i++) {
        while (counts[i] > 0) {
            output[j++] = i;
            counts[i]--;
        }
    }
    return output;
}

// 桶排序
public static int[] bucketSort(int[] arr, int n) {
    int max = findMax(arr);
    int[] buckets = new int[n];
    for (int i = 0; i < n; i++) {
        buckets[i] = 0;
    }
    for (int i = 0; i < arr.length; i++) {
        int bucketIndex = (int) Math.floor(arr[i] / max * (n - 1));
        buckets[bucketIndex]++;
    }
    int[] sortedArr = new int[arr.length];
    int k = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < buckets[i]; j++) {
            sortedArr[k++] = i * max / (n - 1);
        }
    }
    return sortedArr;
}

// 基数排序
public static int[] radixSort(int[] arr) {
    int max = findMax(arr);
    int exp = 1;
    int[] sortedArr = arr;
    while (max / exp > 0) {
        sortedArr = countingSort(sortedArr, exp);
        exp *= 10;
    }
    return sortedArr;
}