探究排序算法：比较与非比较排序算法及性能分析

最新推荐文章于 2024-09-22 11:42:19 发布
最新推荐文章于 2024-09-22 11:42:19 发布
阅读量265 收藏
点赞数
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laterstage/article/details/132488373
版权

探究排序算法：比较与非比较排序算法及性能分析

排序算法是计算机科学中的基本问题，它涉及将一组元素按照特定的顺序排列。本文将深入介绍比较排序算法和非比较排序算法，包括每个算法的原理、Java代码示例以及它们的性能分析和比较。

比较排序算法

1. 冒泡排序（Bubble Sort）

原理：冒泡排序通过多次遍历数组，比较相邻元素并交换，使较大的元素逐渐“冒泡”到数组的尾部。

代码示例：

public class BubbleSort {

    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] array = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(array);
        System.out.println("冒泡排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

2. 插入排序（Insertion Sort）

原理：插入排序将数组分为已排序和未排序两部分，逐个将未排序元素插入到已排序部分的正确位置。

代码示例：

public class InsertionSort {

    public static void insertionSort(int[] array) {
        int n = array.length;
        for (int i = 1; i < n; i++) {
            int key = array[i];
            int j = i - 1;
            while (j >= 0 && array[j] > key) {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
    }

    public static void main(String[] args) {
        int[] array = {12, 11, 13, 5, 6};
        insertionSort(array);
        System.out.println("插入排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

3. 选择排序（Selection Sort）

原理：选择排序在未排序部分找到最小元素，然后与已排序部分的末尾元素交换，逐步构建有序序列。

代码示例：

public class SelectionSort {

    public static void selectionSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
    }

    public static void main(String[] args) {
        int[] array = {64, 25, 12, 22, 11};
        selectionSort(array);
        System.out.println("选择排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

4. 希尔排序（Shell Sort）

原理：希尔排序是插入排序的改进，通过将数组分为多个子序列来进行排序，逐渐减小步长，最终使整个数组基本有序。

代码示例：

public class ShellSort {

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

    public static void main(String[] args) {
        int[] array = {12, 34, 54, 2, 3};
        shellSort(array);
        System.out.println("希尔排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

5. 快速排序（Quick Sort）

原理：快速排序使用分治法，选择一个基准元素，将数组分成左右两部分，左边的元素小于基准，右边的元素大于基准，然后对左右子数组递归地应用快速排序。

代码示例：

public class QuickSort {

    public static void quickSort(int[] array, int low, int high) {
        if (low < high) {
            int pivotIndex = partition(array, low, high);
            quickSort(array, low, pivotIndex - 

1);
            quickSort(array, pivotIndex + 1, high);
        }
    }

    public static int partition(int[] array, int low, int high) {
        int pivot = array[high];
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (array[j] < pivot) {
                i++;
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        int temp = array[i + 1];
        array[i + 1] = array[high];
        array[high] = temp;
        return i + 1;
    }

    public static void main(String[] args) {
        int[] array = {10, 7, 8, 9, 1, 5};
        int n = array.length;
        quickSort(array, 0, n - 1);
        System.out.println("快速排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

6. 归并排序（Merge Sort）

原理：归并排序是一种分治算法，将数组逐步分成两个子数组，分别排序后再合并成一个有序数组。

代码示例：

public class MergeSort {

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

    public static void merge(int[] array, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;

        int[] leftArray = new int[n1];
        int[] rightArray = new int[n2];

        for (int i = 0; i < n1; i++) {
            leftArray[i] = array[left + i];
        }
        for (int j = 0; j < n2; j++) {
            rightArray[j] = array[mid + 1 + j];
        }

        int i = 0, j = 0, k = left;
        while (i < n1 && j < n2) {
            if (leftArray[i] <= rightArray[j]) {
                array[k] = leftArray[i];
                i++;
            } else {
                array[k] = rightArray[j];
                j++;
            }
            k++;
        }

        while (i < n1) {
            array[k] = leftArray[i];
            i++;
            k++;
        }

        while (j < n2) {
            array[k] = rightArray[j];
            j++;
            k++;
        }
    }

    public static void main(String[] args) {
        int[] array = {12, 11, 13, 5, 6, 7};
        int n = array.length;
        mergeSort(array, 0, n - 1);
        System.out.println("归并排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

非比较排序算法

1. 计数排序（Counting Sort）

原理：计数排序适用于元素范围较小的情况，它统计每个元素出现的次数，然后根据统计信息重新构建有序序列。

代码示例：

public class CountingSort {

    public static void countingSort(int[] array) {
        int n = array.length;
        int max = Arrays.stream(array).max().getAsInt();
        int min = Arrays.stream(array).min().getAsInt();

        int range = max - min + 1;
        int[] count = new int[range];
        int[] output = new int[n];

        for (int num : array) {
            count[num - min]++;
        }

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

        for (int i = n - 1; i >= 0; i--) {
            output[count[array[i] - min] - 1] = array[i];
            count[array[i] - min]--;
        }

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

    public static void main(String[] args) {
        int[] array = {4, 2, 2, 8, 3, 3, 1};
        countingSort(array);
        System.out.println("计数排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

2. 桶排序（Bucket Sort）

原理：桶排序将数据分成多个桶，每个桶内部使用其他排序算法（通常是插入排序），然后将桶内有序的数据合并起来。

代码示例：

public class BucketSort {

    public static void bucketSort(double[] array) {
        int n = array.length;
        List<Double>[] buckets = new List[n];

        for (int i = 0; i < n; i++) {
            buckets[i] = new ArrayList<>();
        }

        for (int i = 0; i < n; i++) {
            int bucketIndex = (int) (n * array[i]);
            buckets[bucketIndex].add(array[i]);
        }

        for (int i = 0; i < n; i++) {
            Collections.sort(buckets[i]);
        }

        int index = 0;
        for (int i = 0; i < n; i++) {
            for (double num : buckets[i]) {
                array[index++] = num;
            }
        }
    }

    public static void main(String[] args) {
        double[] array = {0.42, 0.32, 0.33, 0.52, 0.37, 0.47, 0.51};
        bucketSort(array);
        System.out.println("桶排序结果：");
        for (double num : array) {
            System.out.print(num + " ");
        }
    }
}

3. 基数排序（Radix Sort）

原理：基数排序逐位对元素进行排序，先按最低位排序，再按次低位排序，直到最高位。

代码示例：

public class RadixSort {

    public static void radixSort(int[] array) {
        int n = array.length;
        int max = Arrays.stream(array).max().getAsInt();
        for (int exp = 1; max / exp > 0;

 exp *= 10) {
            countingSortByDigit(array, n, exp);
        }
    }

    public static void countingSortByDigit(int[] array, int n, int exp) {
        int[] output = new int[n];
        int[] count = new int[10];

        for (int i = 0; i < n; i++) {
            count[(array[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[(array[i] / exp) % 10] - 1] = array[i];
            count[(array[i] / exp) % 10]--;
        }

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

    public static void main(String[] args) {
        int[] array = {170, 45, 75, 90, 802, 24, 2, 66};
        radixSort(array);
        System.out.println("基数排序结果：");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }
}

排序算法的性能分析和比较

排序算法的性能在不同场景下会有所不同。比较排序算法的平均时间复杂度如下：

  • 冒泡排序：O(n^2)
  • 插入排序：O(n^2)
  • 选择排序：O(n^2)
  • 希尔排序：取决于步长序列，一般在 O(n log n) 到 O(n^2) 之间
  • 快速排序：O(n log n) 平均，最坏情况为 O(n^2)
  • 归并排序：O(n log n)
  • 堆排序：O(n log n)

非比较排序算法的时间复杂度如下：

  • 计数排序：O(n + k)，其中 k 是数据范围
  • 桶排序：O(n^2) 最坏情况，平均情况较好
  • 基数排序：O(n * k)，其中 k 是数字的位数

综合来看，在大多数情况下，快速排序和归并排序是较优的选择，具有较快的平均性能。计数排序和基数排序在特定情况下也能表现优异。

排序算法的选择还应考虑到稳定性、空间复杂度、是否原地排序等因素。根据具体场景和需求，选择合适的排序算法可以有效提高程序的性能。

不一样的老墨
关注
归并排序算法：掌握计算机科学中的黄金分割术
沛沛霖的博客
03-14 407
归并排序（Merge Sort）是一种分而治之（Divide and Conquer）的算法。它将原始数组分成更小的数组，直到每个小数组只有一个位置，然后将它们合并起来，期间进行排序。这一过程在合并时完成，使得最终的数组成为排序后的数组。通过本文的学习，你不仅深入了解了归并排序算法的原理和应用，还掌握了如何在实际编程和技术面试中灵活运用它。记住，掌握任何算法的关键不仅在于理论知识，更在于通过不断的练习和应用来深化理解。我期待在你的算法学习和职业旅程中，归并排序能成为你强大的工具之一。
深入探究TimSort对归并排序算法的优化及Java实现
09-02
**深入探究TimSort对归并排序算法的优化及Java实现** **一、TimSort简介** TimSort是由Tim Peters在Python语言中设计的一种排序算法，它基于归并排序，并且进行了大量的优化，尤其针对已部分有序的数据。TimSort的...
算法设计与分析 实验一 排序算法性能分析
上山打老虎的博客
06-01 9864
实验一 排序算法性能分析一、实验目的与要求1、实验基本要求2、实验亮点二、实验内容与方法三、实验步骤与过程（一）独立算法性能分析1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 合并排序6. 基数排序 一、实验目的与要求 1、实验基本要求 ①掌握选择排序、冒泡排序、合并排序、快速排序、插入排序算法原理 ②掌握不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。 2、实验亮点 ①除了基本五种排序算法，额外选择了基数排序，希尔排序和堆排序三种排序算法进行性能分析并对一些算法提出优化方
九大排序算法汇总+性能分析实验报告（插入排序、希尔排序、折半插入排序、冒泡排序、归并排序、快速排序、基数排序、堆排序、选择排序）
gao20041015的博客
12-19 1989
在处理小规模数据排序问题时，插入排序和选择排序是较好的选择，冒泡排序也是可选的算法。在数据规模较大时，应该选择希尔排序、堆排序、归并排序、快速排序、基数排序或基数排序。并且，数据规模大时，若采用归并排序、快速排序、基数排序或计数排序，需要考虑空间复杂度的问题。
【ShuQiHere】从插入排序到归并排序：探究经典排序算法的魅力与实战应用
ShuQIHere的博客
09-14 1074
在计算机科学领域，排序算法是我们日常编程中经常会遇到的基本问题。无论是对数据进行排序、查找，还是优化复杂系统，排序算法都起着至关重要的作用。在这篇文章中，我们将详细探讨两种经典排序算法：**插入排序** 和 **归并排序**，通过对它们的原理、时间复杂度和实际应用场景的分析，帮你更好地理解并灵活应用这些算法。
【数据结构与算法】选择排序：原理、实现、优化与分析
2302_78391795的博客
07-23 1217
选择排序（Selection Sort）是一种简单直观的排序算法。 它的工作原理是： 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
数据结构 | 排序算法——选择排序与堆排序
做技术人 · 产优质博客 · 找好工作
10-07 1011
本文讲解了常见排序算法中的选择排序与堆排序，内附详细算法图解，复杂度分析公式
几个排序算法性能分析及其实现代码
weixin_42552752的博客
06-17 553
排序算法性能分析 一、实验题目 排序问题探究 实现几种经典的排序算法（冒泡排序、快速排序、插入排序、选择排序、归并排 序等）分别对 5000,10000,50000,100000,500000,1000000, 2000000 的数据量进行排序，测试排序的时间，分析各自的适用场景，并给出详 细的性能分析。 二、实验方法及分析 1、冒泡排序 （1）原理： 　　1、从第一个数据开始，...
算法设计与分析 实验1 算法性能分析
m0_74175922的博客
06-14 1160
深圳大学算法满分实验
【算法与数据结构】关于排序的问题思考
一个程序员
04-09 598
突然想写一个关于排序问题的文章。一方面，我已经知道了冒泡排序的原理， 能写出一个简单的排序算法，差不多就行啦，对于快速排序，又有点复杂， 就算时间复杂度低一点，对我的作用也不是太大，因此总是不把排序算法放在心上。因为我们在比较的时候，只会遇到这两种情况， 要么小于，执行交换，要么就大于等于，不执行交换。有的时候，我们在解决问题的时候，不一定需要直接排序后的结果，而是想求得排序之后对应的索引， 这里我们集中讨论下。什么是排序的稳定性， 其实就是说，在待排序的数组中， 值相同的元素在排序之后的相对位置不变。
大数据-算法-改进的基于历史信息分析的网页排序算法.pdf
04-19
网页排序算法是搜索引擎技术的核心，其目标是通过对互联网上的大量网页进行分析，确定它们的相关性和重要性，以便为用户提供最相关的搜索结果。传统的网页排序算法，如Google的PageRank，主要考虑的是网页之间的链接...
算法分析与设计 排序算法比较
01-01
算法分析与设计排序算法比较 通过对各种排序算法的思想、算法的分析，探究它的使用范围以及时间复杂度和空间复杂度。 冒泡排序算法 冒泡排序算法思想简单描述：在要排序的一组数中，对当前还未排好序的范围内的...
【数据结构】排序算法---桶排序
2301_80191662的博客
09-20 1453
桶排序算法的详细讲解，并且还含有动态演示
atcoder abc372 启发式合并， dp
最新发布
2201_75845839的博客
09-22 265
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
C++初阶：STL详解（四）——vector迭代器失效问题
Zhihuiguoz的博客
09-19 806
STL详解（四）——引起迭代器失效的场景及其解决方案（浅显易懂，轻松上手；一键拿捏，小白也能看懂）
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 429
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
代码随想录算法训练营Day7
lynyzy的博客
09-18 497
双指针
算法设计与分析：排序算法性能深度探究
"这篇实验报告主要探讨了五种常见的排序算法——选择排序、冒泡排序、合并排序、快速排序和插入...这份实验报告为理解和比较不同排序算法提供了实践基础，对于学习算法设计与分析的学生来说，是一份有价值的参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不一样的老墨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值