十大经典排序算法——原理+动图+代码(下)

最新推荐文章于 2023-04-13 21:22:03 发布
最新推荐文章于 2023-04-13 21:22:03 发布
阅读量754 收藏
点赞数 2
分类专栏： 数据结构与算法 面试系列 文章标签： 快速排序 堆排序 计数排序 桶排序 基数排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36095679/article/details/93611365
版权

 

 十大经典排序算法——原理+动图+代码(下)   目录

         十大经典排序算法——原理+动图+代码(上)

6、快速排序（Quick Sort）

6.1 算法描述

6.2 动图演示

 6.3 代码实现

6.4 算法分析

7、堆排序（Heap Sort）

7.1 算法描述

7.2 动图演示

 7.3 代码实现

7.4 算法分析

8、计数排序（Counting Sort）

8.1 算法描述

8.2 动图演示

 8.3 代码实现

8.4 算法分析

9、桶排序（Bucket Sort）

9.1 算法描述

9.2 动图演示

 9.3 代码实现

9.4 算法分析

10、基数排序（Radix Sort）

10.1 算法描述

10.2 动图演示

 10.3 代码实现

10.4 算法分析

6、快速排序（Quick Sort）

6.1 算法描述

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

步骤：

  1. 快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。
  2. 从数列中挑出一个元素，称为 “基准”（pivot）（动图中浅黄色的数字）；
  3. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  4. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
  5. 重复步骤1~4。

6.2 动图演示

 6.3 代码实现

package xmcc.datajpa_test.算法;

import java.util.Arrays;

public class Quick_Sort {

    /**
     * 快速排序算法
     * @param arr
     * @return
     */
    public static int[] quick(int[]arr,int start,int end){
        if (arr.length < 1 || start < 0 ||
                end >= arr.length || start > end)
            return null;
        int smallIndex = partition(arr,start,end);
        if (smallIndex > start)
            quick(arr,start ,smallIndex-1 );
        if (smallIndex < end)
            quick(arr,smallIndex+1 ,end );
        return arr;
    }

    /**
     * 算法——partition
     * @param arr
     * @param start
     * @param end
     * @return
     */
    private static int partition(int[] arr, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex =start - 1;
        myswap(arr,pivot,end);
        for (int i = start; i <= end; i++) {
            if (arr[i] <= arr[end]){
                smallIndex++;
                if (i > smallIndex)
                    myswap(arr,i,smallIndex);
            }
        }
        return smallIndex;
    }

    /**
     * 交换数组内两个元素
     * @param arr
     * @param i
     * @param j
     */
    private static void myswap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] =temp;
    }

    //测试
    public static void main(String[] args) {
        int[]arr=new int[]{10,9,5,11,2,6,3};
        int[] result = quick(arr,0,0);
        System.out.println(Arrays.toString(result));
    }
}

6.4 算法分析

最佳情况：T(n) = O(nlogn)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(nlogn)　

7、堆排序（Heap Sort）

7.1 算法描述

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

步骤：

  1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
  2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
  3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

7.2 动图演示

 7.3 代码实现

package xmcc.datajpa_test.算法;

import java.util.Arrays;

public class Heap_Sort {
    //声明全局变量，用于记录数组arr的长度
    static int len;
    /**
     * 堆排序算法
     * @param arr
     * @return
     */
    public static int[] heap(int[] arr){
        len = arr.length;
        if (len < 1) return arr;
        //1、构建一个最大堆
        buildMaxHeap(arr);
        //2、循环将堆首位（最大值）与末位交换，然后再重新调整最大堆
        while(len > 0){
            myswap(arr,0,len - 1);
            len--;
            adjustHeap(arr,0);
        }
        return arr;
    }

    /**
     * 建立最大堆
     * @param arr
     */
    private static void buildMaxHeap(int[] arr) {
        //从最后一个非叶子节点开始向上构造最大堆
        for (int i = (len - 1) / 2; i >= 0; i--) {
            adjustHeap(arr,i );
        }
    }

    /**
     * 调整使之成为最大堆
     * @param arr
     * @param i
     */
    private static void adjustHeap(int[] arr, int i) {
        int maxIndex = i;
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2 < len && arr[i * 2] > arr[maxIndex])
            maxIndex = i * 2;
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 +1 < len && arr[i * 2 +1] > arr[maxIndex])
            maxIndex = i * 2 + 1;
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置
        if (maxIndex != i){
            myswap(arr,maxIndex ,i );
            adjustHeap(arr,maxIndex );
        }
    }



    /**
     * 交换数组内两个元素
     * @param arr
     * @param i
     * @param j
     */
    private static void myswap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] =temp;
    }
    //测试
    public static void main(String[] args) {
        int[]arr=new int[]{10,9,5,11,2,6,3};
        int[] result = heap(arr);
        System.out.println(Arrays.toString(result));
    }
}

7.4 算法分析

最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

8、计数排序（Counting Sort）

8.1 算法描述

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

步骤：

  1. 找出待排序的数组中最大和最小的元素；
  2. 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  3. 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  4. 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 动图演示

 8.3 代码实现

package xmcc.datajpa_test.算法;

import java.util.Arrays;

public class Count_Sort {
    /**
     * 计数排序
     */
    private static int[] count(int[] arr) {
        if (arr.length ==0 ) return arr;
        int bias,min = arr[0],max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max)
                max = arr[i];
            if (arr[i] < min)
                min = arr[i];
        }
        bias = 0 - min;
        int[] bucket = new int[max - min + 1];
        Arrays.fill(bucket,0 );
        for (int i = 0; i < arr.length; i++) {
            bucket[arr[i] + bias]++;
        }
        int index = 0, i = 0;
        while (index < arr.length){
            if (bucket[i] != 0){
                arr[index] = i - bias;
                bucket[i]--;
                index++;
            }else
                i++;
        }
        return arr;
    }

    //测试
    public static void main(String[] args) {
        int[]arr=new int[]{10,9,5,11,2,6,3};
        int[] result = count(arr);
        System.out.println(Arrays.toString(result));
    }


}

8.4 算法分析

当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。

最佳情况：T(n) = O(n+k)  最差情况：T(n) = O(n+k)  平均情况：T(n) = O(n+k)

9、桶排序（Bucket Sort）

9.1 算法描述

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序。

步骤：

  1. 人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；
  2. 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  3. 对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
  4. 从不是空的桶里把排好序的数据拼接起来。
  5. 注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。

9.2 动图演示

 9.3 代码实现

package xmcc.datajpa_test.算法;

import java.util.ArrayList;
import java.util.Arrays;

public class Bucket_Sort {

    /**
     * 桶排序
     * @param arr
     * @param bucketSize
     * @return
     */
    private static ArrayList<Integer> bucket(ArrayList<Integer> arr,int bucketSize) {
        if (arr == null || arr.size() < 2)
            return arr;
        int max = arr.get(0) , min = arr.get(0);
        //找到最大值  最小值
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i) > max)
                max = arr.get(i);
            if (arr.get(i) < min)
                min = arr.get(i);
        }
        int bucketCount = (max -min) / bucketSize + 1;
        ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
        ArrayList<Integer> resultArr = new ArrayList<>();
        for (int i = 0; i < bucketCount; i++) {
            bucketArr.add(new ArrayList<Integer>());
        }
        for (int i = 0; i < arr.size(); i++) {
            bucketArr.get((arr.get(i) - min) / bucketSize).add(arr.get(i));
        }
        for (int i = 0; i < bucketCount; i++) {
            if (bucketCount == 1)
                bucketSize--;
            ArrayList<Integer> temp = bucket(bucketArr.get(i), bucketSize);
            for (int j = 0; j < temp.size(); j++)
                resultArr.add(temp.get(j));
        }
        return resultArr;
    }

    public static void main(String[] args) {
        int[]arr=new int[]{10,9,5,11,2,6,3};
        ArrayList<Integer> arrayList = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            arrayList.add(arr[i]);
        }

        ArrayList<Integer> bucket = bucket(arrayList, 4);
        bucket.stream().forEach(
                integer -> System.out.print(integer+"  ")
        );

    }



}

9.4 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

最佳情况：T(n) = O(n+k)   最差情况：T(n) = O(n+k)   平均情况：T(n) = O(n2)　　

10、基数排序（Radix Sort）

10.1 算法描述

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn)，n为数组长度，k为数组中的数的最大的位数；

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

步骤：

  1. 取得数组中的最大数，并取得位数；
  2. arr为原始数组，从最低位开始取每个位组成radix数组；
  3. 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

10.2 动图演示

 10.3 代码实现

package xmcc.datajpa_test.算法;

import java.util.ArrayList;
import java.util.Arrays;

public class Radix_Sort {

    /**
     * 基数排序
     * @param arr
     * @return
     */
    public static int[] radix(int[]arr){
        if (arr == null || arr.length < 2)
            return arr;
        //1、先算出最大数的位数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            max = Math.max(max,arr[i] );
        }
        int maxDigit = 0;
        while (max != 0){
            max /= 10;
            maxDigit++;
        }
        int mod = 10,div = 1;
        ArrayList<ArrayList<Integer>> buceketList = new ArrayList<>();
        for (int i = 0; i < 10; i++)
            buceketList.add(new ArrayList<Integer>());
        for (int i = 0; i < maxDigit; i++,mod *= 10,div *= 10) {
            for (int j = 0; j < arr.length; j++) {
                int num = (arr[j] % mod) / div;
                buceketList.get(num).add(arr[j]);
            }
            int index = 0;
            for (int j = 0; j < buceketList.size(); j++) {
                for (int k = 0; k < buceketList.get(j).size(); k++)
                    arr[index++] = buceketList.get(j).get(k);
                buceketList.get(j).clear();
            }
        }
        return arr;
    }

    //测试
    public static void main(String[] args) {
        int[]arr=new int[]{10,9,5,11,2,6,3};
        radix(arr);
        System.out.println(Arrays.toString(arr));
    }
    
}

10.4 算法分析

最佳情况：T(n) = O(n * k)   最差情况：T(n) = O(n * k)   平均情况：T(n) = O(n * k)

基数排序有两种方法：

MSD 从高位开始进行排序 LSD 从低位开始进行排序

基数排序 vs 计数排序 vs 桶排序

这三种排序算法都利用了桶的概念，但对桶的使用方法上有明显差异：

  • 基数排序：根据键值的每位数字来分配桶
  • 计数排序：每个桶只存储单一键值
  • 桶排序：每个桶存储一定范围的数值
方才coding
关注
专栏目录
排序算法介绍——冒泡排序+插入排序+选择排序
12-21
总结起来，冒泡排序、插入排序和选择排序都是基于比较的排序算法，它们在不同的场景下各有优劣。冒泡排序适用于小规模数据或接近有序的数据，插入排序在部分有序的数据上表现优秀，而选择排序则在内存限制的环境中...
算法——图的排序
贝克街的流浪猫
04-04 865
引言 本文整理了常见的图排序相关算法，方便以后查阅。 图 BFS package bbm.graph; import java.util.LinkedList; import java.util.List; import java.util.concurrent.LinkedBlockingQueue; import static bbm.graph.BFS.Color.BLACK; import static bbm.graph.BFS.Color.GRAY; import static bbm.g
146. LRU缓存机制(lru-cache)——LinkedHashMap实现版超简单
e891377的专栏
09-30 371
146. LRU缓存机制 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果关键字 (key) 存在于缓存中，则获取关键字的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 进
快速排序算法动图演示及解析2021版（附Java代码实现）
qq_38082146的博客
04-06 8356
1、快速排序算法实现方式 快速排序的核心思想是分治法，分而治之。它的实现方式是每次从序列中选出一个基准值，其他数依次和基准值做比较，比基准值大的放右边，比基准值小的放左边，然后再对左边和右边的两组数分别选出一个基准值，进行同样的比较移动，重复步骤，直到最后都变成单个元素，整个数组就成了有序的序列。 简单概括如下： 从数列中挑出一个元素，称为 “基准”（pivot）; 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退
快速排序入门（动图演示）
热门推荐
qq_40595682的博客
10-05 1万+
快速排序时间复杂度是O（nlogn）
快速排序（讲解＋动图直观过程）
张^老头的博客
03-11 2687
快速排序 必冒泡排序法更快的排序方法：快速排序` 该方法的基本思想是： 1．先从数列中取出一个数作为基准数。(一般为了方便通常取第一个） 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 3．再对左右区间重复第二步，直到各区间只有一个数 简言之：挖坑 + 分治 实现过程（第一部分）： ( i从前寻找比基准数大的，j从后寻找小的） 分成两个区间重复上面的过程。 总结： 1．i =str; j = end; 将基准数挖出形成第一个坑a[i]。 2．j- -由后向前找比它小的数，找
十大经典排序算法（动图演示） - 一像素 - 博客园.mhtml
04-10
通过学习十大经典排序算法（动图演示），你可以了解C语言中的排序方法，对C语言的程序设计会有很大帮助，有助于今后的工作和学习
七种经典排序算法[代码+详细注释+性能测试]
01-07
本文将深入探讨七种经典排序算法，包括它们的工作原理、代码实现、性能测试以及适用场景。** 1. **冒泡排序（Bubble Sort）** 冒泡排序是最基础的排序算法之一，通过不断交换相邻的逆序元素来逐步排序。它的时间...
十大经典排序算法，附带动画演示效果，超硬核
最新发布
12-30
本教程涵盖了十大经典排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。通过对这些算法的详细讲解和代码实现，学生将能够深入理解排序算法的原理、...
十大内部排序算法动图演示.zip
09-10
这里我们讨论的是“十大内部排序算法”，这些算法通常用于在内存中进行数据排序，对于小到中等规模的数据集尤其有效。下面我们将逐一解析这十种排序算法的动图演示所体现的知识点。 1. 插入排序（Insertion Sort）...
快速排序-flash演示
11-16
快速排序-flash演示 可自己输入数据.......
快速排序GIF动画生成程序
06-23
动画效果详见：http://blog.csdn.net/sealeader/article/details/51700248
排序算法动态图解！一看就懂
03-30
收集了几乎全部的排序算法的动图图解，更有堆排序算法逐帧截图！绝对让你一看就懂！
七种常见排序算法动态演示图.rar
08-08
包含了最常见的七种排序的动态演示，均为gif格式的，方便查看，也方便在制作课件的时候插入到课件当中，以便于给学生演示排序过程。 冒泡排序、插入排序、选择排序、快速排序、希尔排序、归并排序、堆排序。
各动态图示排序算法（冒泡、快排、堆排）
06-10
Qt 书写c++各图示排序，其中包含冒泡排序、快速排序、堆排序算法
七大经典排序算法(动图演示+代码展示)
weixin_43224539的博客
04-21 3447
常见排序算法可以分为两大类：非线性时间比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此称为非线性时间比较类排序。线性时间非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。 算法复杂度 1. 冒泡排序(BubbleSort) 冒泡排序是一种简单的排序算法，是...
快排（动图详细版，快速理解）
weixin_73584362的博客
04-13 4456
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
Python实战：LeetCode十大经典排序算法详解
在本文档中，我们将深入探讨Python实现的十大经典排序算法，结合LeetCode案例，帮助读者理解和掌握这些算法。以下是每个部分的主要知识点： 1. **引言** - 问题需求：本文着重解决实际编程中的问题，即对整数数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值