十大排序算法详解

最新推荐文章于 2024-10-04 13:44:27 发布
最新推荐文章于 2024-10-04 13:44:27 发布
阅读量1.4k 收藏 21
点赞数 39
文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56718551/article/details/139476862
版权

1. 冒泡排序

核心思想

每轮冒泡不断地比较相邻的两个元素，如果逆序，则交换它们的位置。

时间复杂度

最好情况：O(n) --> 数组有序

最坏情况：O(n2) ---> 数组完全逆序

平均：O(n2)

空间复杂度

O(1)

代码实现

public class BubbleSort {

    private static void bubble(int[] nums){
        int j = nums.length - 1;
        do {
            int x = 0;
            for (int i = 0; i < j; i++) {
                if (nums[i] > nums[i + 1]) {
                    int temp = nums[i];
                    nums[i] = nums[i + 1];
                    nums[i + 1] = temp;
                    x = i;
                }
            }
            j = x;
        } while (j != 0);
    }

    public static void main(String[] args) {
        int[] a = new int[]{7,6,5,4,3,2,1};
        bubble(a);
        Arrays.stream(a).forEach(System.out::print);
    }
}

2. 选择排序

核心思想

每一轮选择，找出最大(最小)的元素，并把它交换到合适的位置。

时间复杂度

最好情况：O(n2)

最坏情况：O(n2)

平均：O(n2)

空间复杂度

O(1)

代码实现

public class SelectionSort {
    private static void selection(int[] nums){
        // 1.选择轮数:nums.length - 1
        // 2.交换的索引位置(right)，初始为nums.length - 1,每次递减
        for (int right = nums.length - 1; right > 0; right--) {
            int max = right;
            for (int i = 0; i < right; i++) {
                if (nums[i] > nums[max]){
                    max = i;
                }
            }
            if (max != right){
                swap(nums, max, right);
            }
        }
    }
    private static void swap(int[] a, int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void main(String[] args) {
        int[] nums = {7, 6, 5, 4, 3, 2, 1};
        selection(nums);
        Arrays.stream(nums).forEach(System.out::print);
    }
}

3. 堆排序

核心思想

建立大顶堆

每次将堆顶元素(最大值)交换到末尾，调整堆顶元素，让它重新符合大顶堆特性

时间复杂度

最好情况：O(nlogn)

最坏情况：O(nlogn)

平均：O(nlogn)

空间复杂度

O(1)

代码实现

public class HeapSort {
    public static void sort(int[] nums){
        beautify(nums,nums.length);
        for (int right = nums.length -1; right > 0; right--) {
            swap(nums,right,0);
            down(nums,0,right);
        }
    }
    //Floyd建堆 O(n)
    public static void beautify(int[] a, int size){
        for (int i = size / 2 - 1; i >= 0; i--) {
            down(a, i, size);
        }
    }
    //下潜
    public static void down(int[] a, int parent, int size){
        while(true){
            int left = parent * 2 + 1;
            int right = left + 1;
            int max = parent;
            if (left < size && a[left] > a[max]){
                max = left;
            }
            if (right < size && a[right] > a[max]){
                max = right;
            }
            if (max == parent){
                break;
            }
            swap(a,max,parent);
            parent = max;
        }
    }
    //交换
    private static void swap(int[] a, int max, int parent) {
        int temp = a[max];
        a[max] = a[parent];
        a[parent] = temp;
    }

    public static void main(String[] args) {
        int[] a = new int[]{2,3,1,7,6,4,5};
        sort(a);
        Arrays.stream(a).forEach(System.out::print);
    }
}

4. 插入排序

核心思想

将数组a分为两部分[0, low-1], [low, a.length-1]，左边是已排序部分，右边是未排序部分

每次从未排序区域取出low位置元素，插入到已排序区域

时间复杂度

最好情况：O(n)

最坏情况：O(n2)

平均：O(n2)

空间复杂度

O(1)

代码实现

public class InsertionSort {
    public static void sort(int[] nums){
        for (int low = 1; low < nums.length - 1; low++) {
            int t = nums[low];
            int i = low - 1;
            // 自右向左找插入位置，如果比待插入元素大，则不断右移，空出插入位置
            while (i >= 0 && nums[i] > t){
                nums[i+1] = nums[i];
                i--;
            }
            // 找到插入位置
            if (i != low - 1){
                nums[i+1] = t;
            }
        }
    }

    public static void main(String[] args) {
        int[] a = new int[]{2,4,5,6,3,1,7};
        sort(a);
        Arrays.stream(a).forEach(System.out::print);
    }
}

5. 希尔排序

核心思想

分组实现插入，每组元素间隙称为gap

每轮排序后gap逐渐变小，直到gap为1完成排序

时间复杂度

最好情况：O(nlogn)

最坏情况：O(n2)

平均：O(nlogn)

空间复杂度

O(1)

代码实现

public class ShellSort {
    public static void sort(int[] nums){
        for (int gap = nums.length >> 1; gap >= 1; gap /= 2) {
            for (int low = gap; low < nums.length; low++) {
                int t = nums[low];
                int i = low - gap;
                while (i >= 0 && nums[i] > t){
                    nums[i+gap] = nums[i];
                    i -= gap;
                }
                if (i + gap != low){
                    nums[i+gap] = t;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] a = new int[]{3,2,1,5,6,7,9};
        sort(a);
        Arrays.stream(a).forEach(System.out::print);
    }
}

6. 归并排序

核心思想

分-每次从中间切一刀，处理的数据少一半

治-当数据仅剩一个时，可以认为有序

合-两个有序的结果，可以进行合并排序

时间复杂度

最好情况：O(nlogn)

最坏情况：O(nlogn)

平均：O(nlogn)

空间复杂度

O(n)

代码实现

public class MergeSort {
    public static void sort(int[] a1){
        int[] a2 = new int[a1.length];
        split(a1,0,a1.length - 1,a2);
    }
    public static void split(int[] a1, int left, int right, int[] a2){
        // 治
        if (left == right){
            return;
        }
        // 分
        int m = (left + right) >>> 1;
        split(a1,left,m,a2);
        split(a1,m+1,right,a2);
        // 合
        merge(a1,left,m,m+1,right,a2);
        System.arraycopy(a2, left, a1, left,right - left + 1);
    }
    // 合并两个有序数组
    public static void merge(int[]a1, int i, int iEnd, int j, int jEnd, int []a2){
        int k = i;
        while(i <= iEnd && j <= jEnd){
            if (a1[i] < a1[j]){
                a2[k] = a1[i];
                i++;
            }else {
                a2[k] = a1[j];
                j++;
            }
            k++;
        }
        if (i > iEnd){
            System.arraycopy(a1, j, a2, k,jEnd - j + 1);
        }
        if (j > jEnd){
            System.arraycopy(a1, i, a2, k,iEnd - i + 1);
        }
    }
    public static void main(String[] args) {
        int[] a1 = new int[]{9,3,7,2,8,5,1,4};
        sort(a1);
        Arrays.stream(a1).forEach(System.out::print);
    }
}
public static void sort(int[] a1){
    int n = a1.length;
    int[] a2 = new int[n];
    // width 代表有序区间的宽度，取值依次为 1 2 4 ...
    for (int width = 1; width < n; width *= 2) {
        // [left,right] 分别代表待合并区间的左右宽度
        for (int left = 0; left < n; left += 2 * width) {
            int right = left + 2 * width - 1;
            int m = left + width - 1;
            merge(a1,left,m,m+1,right,a2);
        }
        System.arraycopy(a2,0,a1,0,n);
    }
}
public static void main(String[] args) {
    int[] a1 = new int[]{9,3,7,2,8,5,1,4};
    sort(a1);
    Arrays.stream(a1).forEach(System.out::print);
}

7. 快速排序

核心思想

每轮找到一个基准点元素，把比它小的放到它左边，比它大的放到它右边，这称为分区。

  1. 选择最右元素作为基准点元素
  2. j 指针负责找比基准点小的元素，一旦找到则与 i 交换位置
  3. i 指针指向大于基准点元素的左边界，也是每次交换的目标索引
  4. 最后基准点与 i 交换，i 即为分区位置

时间复杂度

最好情况：O(nlogn)

最坏情况：O(nlogn)

平均：O(nlogn)

空间复杂度

O(1)

代码实现

public class QuickSort {
    public static void quick(int[] a, int left, int right){
        if (left >= right){
            return;
        }
        // p 代表基准点元素索引
        int p = partition(a, left, right);
        quick(a,left, p - 1);
        quick(a,p + 1, right);
    }
    public static int partition(int[] a, int left, int right){
        // pv 代表基准点元素值
        int pv = a[right];
        int i = left;
        int j = left;
        while(j < right){
            if (a[j] < pv){ // 找到比基准点小的元素
                if (i != j){
                    swap(a,i,j);
                }
                i++;
            }
            j++;
        }
        swap(a,i,right);
        return i;
    }
    public static void swap(int[] a, int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static void main(String[] args) {
        int[] a = new int[]{9,3,7,2,8,5,1,4};
        quick(a,0,a.length-1);
        Arrays.stream(a).forEach(System.out::print);
    }
}
public static int partition2(int[] a, int left, int right){
    // 随机元素作为基准点
    int idx = ThreadLocalRandom.current().nextInt(right - left + 1) + left;
    swap(a,left,idx);
    // i 从左到右找比基准点元素大的，j 从右到左找比基准点元素小的
    int pv = a[left];
    int i = left;
    int j = right;
    while(i < j){
        while (i < j && a[j] > pv){
            j--;
        }
        while (i < j && a[i] <= pv){
            i++;
        }
        swap(a, i, j);
    }
    swap(a, left, i);
    return i;
}

public static int partition3(int[] a, int left, int right){
    int idx = ThreadLocalRandom.current().nextInt(right - left + 1) + left;
    swap(a, left, idx);
    int pv = a[left];
    int i = left + 1;
    int j = right;
    while(i <= j){
        while(i <= j && a[i] < pv){
            i++;
        }
        while (i <= j && a[j] > pv){
            j--;
        }
        if (i <= j){
            swap(a, i, j);
            i++;
            j--;
        }
    }
    swap(a, j, left);
    return j;
}

8. 计数排序

核心思想

  1. 找到最大值，创建一个大小为 最大值 + 1 的 count 数组
  2. count 数组的索引对应原始数组的元素，用来统计该元素的出现次数
  3. 遍历 count 数组，根据 count 数组的索引(即原始数组的元素) 以及出现次数，生成排序后的内容

count 数组的索引是：已排序好的

前提：待排序 >= 0，且最大值不能太大

时间复杂度

最好情况：O(n)

最坏情况：O(n)

平均：O(n)

空间复杂度

O(n)

代码实现

public class CountingSort {
    // 前提：待排序 >= 0，且最大值不能太大
    public static int[] sort(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
        }
        int[] count = new int[max + 1];
        for (int num : arr) {
            count[num]++; // 原始数组元素 = count数组索引
        }
        int k = 0;
        for (int i = 0; i < count.length; i++) {
            while (count[i] > 0){
                arr[k++] = i; // i 代表原始数组元素  count[i] 代表元素出现次数
                count[i]--;
            }
        }
        return arr;
    }
    // 优化：处理元素 < 0 的情况
    public static int[] sortPositive(int[] arr){
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max){
                max = arr[i];
            }
            if (arr[i] < min){
                min = arr[i];
            }
        }
        int[] count = new int[max - min + 1];
        for (int num : arr) {
            count[num - min]++; // 原始数组元素 - 最小值 = count 索引
        }
        int k = 0;
        for (int i = 0; i < count.length; i++) {
            while(count[i] > 0){
                arr[k++] = i + min; // i + min 代表原始数组元素  count[i] 代表元素出现次数
                count[i]--;
            }
        }
        return arr;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{2,3,1,5,7,-3};
        sortPositive(arr);
        System.out.println(Arrays.toString(arr));
    }
}

9. 基数排序

核心思想

将待排序的数组，按照某个关键字的各位数字进行排序。基数排序可以说是一种桶排序的扩展，它利用了桶排序的思想，将待排序的数组分成多个桶，每个桶存放相同位数的数字。

时间复杂度

最好情况：O(kn)

最坏情况：O(kn)

平均：O(kn)

k是待排序数组中最大的数的位数

空间复杂度

O(n)

代码实现

public class RadixSort {
    public static void sort(int[] nums) {
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            max = Math.max(max, nums[i]);
        }
        int m = 1;
        ArrayList<Integer>[] buckets = new ArrayList[10];
        for (int i = 0; i < 10; i++) {
            buckets[i] = new ArrayList<>();
        }
        while (m <= max) {
            for (int num : nums) {
                buckets[num / m % 10].add(num);
            }
            int k = 0;
            for (ArrayList<Integer> bucket : buckets) {
                for (Integer i : bucket) {
                    nums[k++] = i;
                }
                bucket.clear();
            }
            m *= 10;
        }
    }

    public static void main(String[] args) {
        int[] nums = {1000, 2, 13, 5, 19};
        RadixSort.sort(nums);
        System.out.println(Arrays.toString(nums));
    }
}

10. 桶排序

核心思想

桶排序（Bucket Sort）是一种分布式排序算法，它将待排序的元素分到不同的桶中，对每个桶中的元素进行排序，然后依次将每个桶中的元素取出，即可得到有序的结果。桶排序的核心思想是将待排序的元素映射到不同的桶中，使得每个桶中的元素范围尽量小且有序。

时间复杂度

最好情况：O(n+k)

最坏情况：O(n+k)

平均：O(n+k)

k是桶的数量

空间复杂度

O(n+k)

代码实现

public class BucketSort {
    public static void sort(int[] nums,int bucketSize){
        if (nums.length == 0){
            return;
        }
        // 找到数组中的最大值和最小值
        int max = nums[0];
        int min = nums[0];
        for (int i = 1; i < nums.length; i++) {
            max = Math.max(max,nums[i]);
            min = Math.min(min,nums[i]);
        }
        // 初始化桶
        ArrayList<Integer>[] buckets = new ArrayList[(max - min)/bucketSize + 1];
        for (int i = 0; i < buckets.length; i++) {
            buckets[i] = new ArrayList<>();
        }
        // 将元素分配到桶中
        for (int num : nums) {
            buckets[(num-min)/bucketSize].add(num);
        }
        // 对每个桶中的元素进行排序，并将排序后的元素放回原数组
        int k = 0;
        for (ArrayList<Integer> bucket : buckets) {
            Collections.sort(bucket);
            for (Integer v : bucket) {
                nums[k++] = v;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {29, 10, 14, 37, 13};
        BucketSort.sort(arr, 2);
        System.out.println(Arrays.toString(arr));
    }
}

sxdy_
关注
十大排序算法
个人站点：javatv.net
08-20 2万+
冒泡排序 从数组头开始，比较相邻的元素。如果第一个比第二个大(小)，就交换它们两个 对每一对相邻元素作同样的工作，从开始第一对到尾部的最后一对，这样在最后的元素应该会是最大(小)的数 重复步骤1~2，重复次数等于数组的长度，直到排序完成 代码实现 对下面数组实现排序：{24, 7, 43, 78, 62, 98, 82, 18, 54, 37, 73, 9} 代码实现 public class BubbleSort { public static final int[] ARRAY = {2
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
热门推荐
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
十大经典排序算法详解
yunweigo的博客
05-26 1918
本文转自 《卢明冬的博客》 相关的同学可以关注一下 文章目录排序算法的分析和评价2.十大排序经典算法总览2.1 排序算法的分类 排序算法是《数据结构和算法》中非常基础的算法，但却占据着十分重要的位置，几乎可以说是我们在日常编程代码中使用最频繁的基础算法。本文对常见的十大经典排序算法进行了详细的知识点梳理，从排序思路、动图演示、代码实现、复杂度分析、算法优化等多个方面分别对不同的排序算法进行讲解，内容详实，一篇文章几乎囊括了排序算法所有必知必会的知识点，夸张点说，算得上是 “史上最全” 排序算法讲解。
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
十大排序算法 详解
weixin_42072280的博客
09-23 290
目录 归并排序 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 如何记忆稳定算法：冒插归稳 冒冒失失插到最前面面试，神气归来，稳了 归并排序 参考：https://blog.csdn.net/m0_38056893/article/details/79461901 参考：https://www.cnblogs.com/shudonghe/p/3302888.html ...
c++十大排序算法详解
yhblog的博客
09-23 319
参考： https://www.cnblogs.com/fnlingnzb-learner/p/9374732.html
十大排序算法详解（java实现）
weixin_64752717的博客
06-13 631
十大排序详解，附详细注释
数据结构中十大排序算法 详解
Hanshy123的博客
07-27 1406
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
C# 十大排序算法详解
ZJL_Hi的博客
06-15 629
1、算法总结 2、控制台输入 3、代码 4、输出
用javascript实现的十大排序算法详解
08-10
本篇文章将深入探讨如何使用JavaScript实现十大经典排序算法，帮助开发者更好地理解和运用这些算法。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序方法，通过重复遍历待排序的数组，比较相邻元素并交换...
十大排序算法详解python
08-20
以下是十大常见的排序算法及其详细解释，使用Python编写的示例代码： 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的交换排序算法。它重复地遍历要排序的列表，比较相邻的元素并交换它们，直到整个列表排序...
C++番外篇-------排序算法总结
lys20221113242的博客
09-29 795
1.冒泡排序1.冒泡排序冒泡排序是一种简单的排序算法，它通过重复遍历要排序的列表，依次比较每对相邻项，并在必要时交换它们，从而使较大的元素逐渐“浮”到列表的顶部，而较小的元素则“沉”到底部。以下是冒泡排序的基本步骤：1. 从列表的第一个元素开始，依次比较相邻的两个元素。2. 如果顺序不正确（例如，前一个元素大于后一个元素），则交换它们。3. 继续进行这样的遍历和比较，直到到达列表的末尾。4. 重复以上步骤，直到整个列表都被排序。2.选择排序。
排序算法——快速排序：普通快排与双路快排
最新发布
release_lonely的博客
10-04 600
很显然对于普通的快排来说只能处理大于base和小于base的情况，对于等于base的情况我们是做的模糊处理（哪边先碰到算哪边的），所以在待排序数组中元素重复度比较高的情况下会退化为O(n^2)。如：4，4，4，4，4，1。选取待排序数组的首或尾元素作为枢轴（就是base，我们选出来的比较的数），大于base的放右边，小于base的放左边。我们每次只能一个元素一个元素的拆开，而不是理想情况一半一半的拆，为了处理以上情况有了双路快排。
查找与排序-插入排序
wlq_567的博客
10-02 557
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。是一种简单直观的排序算法，其基本思想是将未排序的元素逐个插入到已排序的部分中，直到所有元素都被插入到合适的位置为止。假设我们有以下待排序的数组：[5, 3, 8, 6, 2]最终，数组变为有序状态：[2, 3, 5, 6, 8]
C++系列-STL容器中的排序算法
weixin_48668114的博客
09-29 543
C++系列-STL容器中的排序算法
排序算法（1）
qq_54065331的博客
09-29 491
排序算法最佳适用场景不适用场景冒泡排序学习排序概念，处理少量数据大数据量排序，性能要求高的场景选择排序数据量小且不要求稳定性时大数据量排序插入排序小规模或部分有序数据排序，实时数据处理大数据量，完全无序的数据。
十大排序算法详解与实现
本文档总结了经典的十大排序算法，包括冒泡排序、选择排序、插入排序、壳排序、归并排序、快速排序、堆排序、拓扑排序、锦标赛排序和基数排序，并提供了冒泡排序和选择排序的代码示例。此外，还提到了二分法和二叉树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值