JAVA七种常见排序算法

前言: 排序算法在计算机科学中扮演着至关重要的角色,它们用于将无序数据变为有序数据,以便更有效地检索和处理信息。不同的排序算法适用于不同的情况,因此了解它们的工作原理和性能特点对于选择正确的算法至关重要。本文提供的Java示例代码有助于理解这些排序算法的基本原理和实现方式,以便在实际应用中选择合适的排序算法来提高效率。无论是面试准备还是实际开发中,对排序算法的理解都是非常有价值的知识。
1、冒泡排序(Bubble Sort): 冒泡排序是一种简单的比较排序算法,它重复地遍历待排序数组,比较相邻元素,并交换它们,直到整个数组有序为止。它的时间复杂度为O(n^2),不适用于大规模数据集。

java 复制代码
public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; 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^2),不适用于大规模数据集。

java 复制代码
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;
            }
        }
        int temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
}

3、插入排序(Insertion Sort): 插入排序是一种简单的比较排序算法,它将数组分为已排序和未排序两部分,每次从未排序部分选择一个元素插入已排序部分的适当位置。它的时间复杂度为O(n^2),对于小型数据集和基本有序的数组性能较好。

java 复制代码
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--;
        }
        arr[j + 1] = key;
    }
}

4、快速排序(Quick Sort): 快速排序是一种分而治之的比较排序算法,它选择一个基准元素,将数组分成两部分,左边的元素小于基准,右边的元素大于基准,然后递归地对这两部

分进行排序。它的平均时间复杂度为O(n log n),性能较好。

java 复制代码
public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 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++;
            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;
}

5、归并排序(Merge Sort): 归并排序也是一种分而治之的比较排序算法,它将数组分成两部分,分别对这两部分进行排序,然后将它们合并为一个有序数组。它的时间复杂度为O(n log n),性能稳定。

java 复制代码
public static void mergeSort(int[] arr) {
    if (arr.length > 1) {
        int mid = arr.length / 2;
        int[] left = Arrays.copyOfRange(arr, 0, mid);
        int[] right = Arrays.copyOfRange(arr, mid, arr.length);

        mergeSort(left);
        mergeSort(right);

        merge(arr, left, right);
    }
}

private static void merge(int[] arr, int[] left, int[] right) {
    int i = 0, j = 0, k = 0;
    while (i < left.length && j < right.length) {
        if (left[i] < right[j]) {
            arr[k] = left[i];
            i++;
        } else {
            arr[k] = right[j];
            j++;
        }
        k++;
    }
    while (i < left.length) {
        arr[k] = left[i];
        i++;
        k++;
    }
    while (j < right.length) {
        arr[k] = right[j];
        j++;
        k++;
    }
}

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--) {
        int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;

        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) {
        int swap = arr[i];
        arr[i] = arr[largest];
        arr[largest] = swap;

        heapify(arr, n, largest);
    }
}

7、基数排序(Radix Sort): 基数排序是一种非比较排序算法,它根据元素的位数进行排序。它将待排序的元素分成多个桶,然后按照位数的顺序依次对每个桶进行排序。它可以用于整数或字符串的排序。基数排序的时间复杂度取决于元素的位数和桶的数量,通常为O(n * k),其中n是元素数量,k是位数。

java 复制代码
public static void radixSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int exp = 1;

    while (max / exp > 0) {
        countingSort(arr, exp);
        exp *= 10;
    }
}

private static void countingSort(int[] arr, int exp) {
    int n = arr.length;
    int[] output = new int[n];
    int[] count = new int[10];

    for (int i = 0; i < n; i++) {
        count[(arr[i] / exp) % 10]++;
    }

    for (int i = 1; i < 10; i++) {
        count[i] += count[i - 1];
    }

    for (int i = n - 1; i >= 0; i--) {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10]--;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = output[i];
    }
}

总结:冒泡排序、选择排序和插入排序是最基本的排序算法,适用于小型数据集或作为排序算法的基础。快速排序和归并排序是分而治之的排序算法,适用于中等规模数据集,性能良好。堆排序是一种选择排序,适用于大规模数据集,性能稳定。基数排序是非比较排序算法,适用于整数或字符串排序。

相关推荐
.格子衫.2 小时前
Spring Boot 原理篇
java·spring boot·后端
多云几多2 小时前
Yudao单体项目 springboot Admin安全验证开启
java·spring boot·spring·springbootadmin
Swift社区3 小时前
LeetCode 394. 字符串解码(Decode String)
算法·leetcode·职场和发展
tt5555555555553 小时前
LeetCode进阶算法题解详解
算法·leetcode·职场和发展
让我们一起加油好吗3 小时前
【基础算法】DFS中的剪枝与优化
算法·深度优先·剪枝
Jabes.yang4 小时前
Java求职面试实战:从Spring Boot到微服务架构的技术探讨
java·数据库·spring boot·微服务·面试·消息队列·互联网大厂
聪明的笨猪猪4 小时前
Java Redis “高可用 — 主从复制”面试清单(含超通俗生活案例与深度理解)
java·经验分享·笔记·面试
Q741_1474 小时前
C++ 模拟题 力扣495. 提莫攻击 题解 每日一题
c++·算法·leetcode·模拟
兮动人4 小时前
Spring Bean耗时分析工具
java·后端·spring·bean耗时分析工具
MESSIR224 小时前
Spring IOC(控制反转)中常用注解
java·spring