十种经典排序算法——Java实现

最新推荐文章于 2024-06-13 17:08:44 发布

良月柒

最新推荐文章于 2024-06-13 17:08:44 发布

阅读量626

点赞数 11

分类专栏： Java 文章标签：排序算法 java 算法

本文链接：https://blog.csdn.net/lkp1603645756/article/details/139605485

版权

Java 专栏收录该内容

62 篇文章 2 订阅

订阅专栏

效率工具

推荐一个程序员在线工具站：程序员常用工具（http://cxytools.com），有时间戳、JSON格式化、文本对比、HASH生成、UUID生成等常用工具，效率加倍嘎嘎好用。

小报童专栏精选Top100

推荐一个小报童专栏导航站：小报童精选Top100（http://xbt100.top），收录了生财有术项目精选、AI海外赚钱、纯银的产品分析等专栏，陆续会收录更多的专栏，欢迎体验～

云服务器

云服务器限时免费领：轻量服务器2核4G
腾讯云：2核2G4M云服务器新老同享99元/年，续费同价
阿里云：2核2G3M的ECS服务器只需99元/年，续费同价

排序是计算机科学中的基础操作之一，几乎所有的软件系统都需要对数据进行排序。

本文将介绍十种经典排序算法，并提供Java实现代码。

这些算法包括：冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序、计数排序、桶排序和基数排序。

1. 冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地遍历要排序的列表，比较相邻的元素并交换它们，如果它们的顺序错误。

实现

public 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）

选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

实现

public 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[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

3. 插入排序（Insertion Sort）

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

实现

public 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;
    }
}

4. 归并排序（Merge Sort）

归并排序是采用分治法的一个非常典型的应用。归并排序的思想是将数组分成两部分，分别排序，然后将排序好的部分合并在一起。

实现

public void mergeSort(int[] arr, int left, int right) {
    if (left < right) {
        int middle = (left + right) / 2;
        mergeSort(arr, left, middle);
        mergeSort(arr, middle + 1, right);
        merge(arr, left, middle, right);
    }
}

private 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];
    System.arraycopy(arr, left, L, 0, n1);
    System.arraycopy(arr, middle + 1, R, 0, n2);
    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++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

5. 快速排序（Quick Sort）

快速排序的基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。

实现

public 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 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;
}

6. 堆排序（Heap Sort）

堆排序是一种树形选择排序，是对直接选择排序的有效改进。堆的定义是：具有n个元素的序列（k1, k2, …, kn）称为堆，当且仅当该序列满足如下性质之一：ki <= k2i且ki <= k2i+1（小根堆）。

实现

public 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 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. 希尔排序（Shell Sort）

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

实现

public void shellSort(int[] arr) {
    int n = arr.length;
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
                arr[j] = arr[j - gap];
            }
            arr[j] = temp;
        }
    }
}

8. 计数排序（Counting Sort）

计数排序是一种非比较排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。

实现

public void countingSort(int[] arr) {
    int max = Arrays.stream(arr).max().getAsInt();
    int[] count = new int[max + 1];
    for (int i : arr) {
        count[i]++;
    }
    int index = 0;
    for (int i = 0; i < count.length; i++) {
        while (count[i]-- > 0) {
            arr[index++] = i;
        }
    }
}

9. 桶排序（Bucket Sort）

桶排序是将数组元素分布到有限数量的桶中，然后对每个桶内的元素进行排序，最后将桶中的元素合并得到有序序列。

实现

public void bucketSort(int[] arr) {
    if (arr.length <= 1) return;
    int max = Arrays.stream(arr).max().getAsInt();
    int min = Arrays.stream(arr).min().getAsInt();
    int bucketCount = (max - min) / arr.length + 1;
    List<List<Integer>> buckets = new ArrayList<>(bucketCount);
    for (int i = 0; i < bucketCount; i++) {
        buckets.add(new ArrayList<>());
    }
    for (int i : arr) {
        buckets.get((i - min) / arr.length).add(i);
    }
    int index =

 0;
    for (List<Integer> bucket : buckets) {
        Collections.sort(bucket);
        for (int i : bucket) {
            arr[index++] = i;
        }
    }
}

10. 基数排序（Radix Sort）

基数排序是通过将整数按位分配到桶中进行多次排序，最终实现排序的一种非比较排序算法。

实现

public void radixSort(int[] arr) {
    if (arr.length == 0) return;
    int max = Arrays.stream(arr).max().getAsInt();
    int exp = 1;
    while (max / exp > 0) {
        countingSortByDigit(arr, exp);
        exp *= 10;
    }
}

private void countingSortByDigit(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]--;
    }
    System.arraycopy(output, 0, arr, 0, n);
}

结论

在本篇文章中，我们探讨了十种经典的排序算法，并且提供了每种算法在Java中的实现代码。

不同的排序算法有各自的优缺点，选择合适的排序算法取决于具体的应用场景和数据特性。

良月柒

关注

11
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
十种经典排序算法——Java实现

快速排序的基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。桶排序是将数组元素分布到有限数量的桶中，然后对每个桶内的元素进行排序，最后将桶中的元素合并得到有序序列。不同的排序算法有各自的优缺点，选择合适的排序算法取决于具体的应用场景和数据特性。
复制链接

扫一扫