八大排序算法实现及图解

最新推荐文章于 2021-08-28 00:21:41 发布

置顶春来桃花开

最新推荐文章于 2021-08-28 00:21:41 发布

阅读量550

点赞数 2

分类专栏：算法文章标签：排序冒泡排序插入排序

本文链接：https://blog.csdn.net/loginactivity/article/details/100542374

版权

算法同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

排序

1 篇文章 0 订阅

订阅专栏

1、冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法步骤：

1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3）针对所有的元素重复以上的步骤，除了最后一个。

4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

  /**
     * @param data  要排序的数组
     */
    public static void sort(int data[]){
        for (int i=0;i<data.length;i++){
            for(int j=0;j<data.length-i-1;j++){
                if (data[j]>data[j+1]){
                    int tmp = data[j];
                    data[j] = data[j+1];
                    data[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
        for (int i:data){
            System.out.print(i+"  ");
        }
    }

2、插入排序

在这里插入图片描述
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

算法步骤：

1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

 public static void sort(int[] data ){
 
        for (int i =1;i<data.length;i++){
        
            int j = i ;
            int tmp = data[i];
            
            while (j > 0 && tmp < data[j - 1]){
                data[j] = data[j - 1];
                j--;
            }

            data[j] = tmp;
        }

        for(int i :data){
            System.out.println(i);
        }
    }


    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
    }

3、选择排序

在这里插入图片描述

选择排序(Selection sort)也是一种简单直观的排序算法。

算法步骤：

1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置

2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

3）重复第二步，直到所有元素均排序完毕。

 public static void sort(int[] data){
        for (int i = 0 ;i<data.length;i++){
            int tmp = data[i];
            int index = i ;
            for (int j=i+1;j<data.length;j++){
                if (tmp>data[j]){
                    tmp=data[j];
                    index = j;
                }
            }
            data[index] = data[i];
            data[i]=tmp;

        }

        for (int i:data){
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
    }

第二种实现方法

    public static void sort(int[] data){
        int len = data.length;

        for (int i = 0;i<len;i++){

            for (int j = i+1;j<len;j++){

                if (data[i]>data[j]){
                    int c = data[i];
                    data[i]=data[j];
                    data[j]=c;
                }
            }
        }

        for (int i : data){
            System.out.println(i);
        }

    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
    }

4、快速排序

在这里插入图片描述

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。

算法步骤：

1 从数列中挑出一个元素，称为 “基准”（pivot），

2 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

public static void sort(int[] data , int left , int right){

        if (left < right) {
             //将中间的这个数和第一个数交换
            int i = left, j = right, x = data[left];
            while (i < j) {
                while(i < j && data[j] >= x) // 从右向左找第一个小于x的数
                    j--;
                if(i < j)
                    data[i++] = data[j];

                while(i < j && data[i] < x) // 从左向右找第一个大于等于x的数
                    i++;
                if(i < j)
                    data[j--] = data[i];
            }
            data[i] = x;
            sort(data, left, i - 1); // 递归调用
            sort(data, i + 1, right);
        }


    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data,0,data.length-1);
        for (int i : data){
            System.out.println(i);
        }
    }

5、归并排序

在这里插入图片描述

归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法步骤：

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针达到序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

public static void sort(int[] data){

        //在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        int l = data.length;
        int[] tmp = new int[l];
        sort(data,0,l-1,tmp);

    }

    private static void sort(int[] data, int left, int right, int[] tmp) {
        if (left<right){
            int mid = (left+right)/2;

            sort(data,left,mid,tmp);           //左边归并排序，使得左子序列有序
            sort(data,mid+1,right,tmp); //右边归并排序，使得右子序列有序
            merge(data,left,mid,right,tmp);   //将两个有序子数组合并操作
        }
    }

     private static void merge(int[] data,int left,int mid,int right,int[] tmp){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(data[i]<=data[j]){
                tmp[t++] = data[i++];
            }else {
                tmp[t++] = data[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            tmp[t++] = data[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            tmp[t++] = data[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            data[left++] = tmp[t++];
        }
    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
        System.out.println(Arrays.toString(data));
    }

6、希尔排序

在这里插入图片描述

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

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率

但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

算法步骤：

1）选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；

2）按增量序列个数k，对序列进行k 趟排序；

3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

 public static void sort(int[] data){
 
       int tmp;
       
       for (int k = data.length/2 ; k>0 ; k/=2 ){        //组大小
           for(int i =k; i<data.length; i++){            //多少组
               for (int j =i; j>=k; j-=k){               //同一组
                   if ( data[j-k] > data[j] ){           //比较大小，交换数据
                       tmp = data[j-k];
                       data[j-k] = data[j];
                       data[j] = tmp;
                   }
               }
           }
       }
    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
        System.out.println(Arrays.toString(data));
    }

7、堆排序

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

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤：

1）创建一个堆H[0…n-1]

2）把堆首（最大值）和堆尾互换

3）把堆的尺寸缩小1，并调用shift_down(0)，目的是把新的数组顶端数据调整到相应位置

4）重复步骤2，直到堆的尺寸为1

 public static void sort(int[] data){
        for(int i= data.length/2-1 ; i>=0 ; i--){
            adjustHeap(data,i,data.length);
        }

        for (int j = data.length-1; j>0;j--){
            swap(data,0,j);        //将堆顶元素与末尾元素进行交换
            adjustHeap(data,0,j);  //重新对堆进行调整
        }
    }

    /**
     * 交换元素
     * @param data
     * @param i
     * @param j
     */
    private static void swap(int[] data, int i, int j) {
        int tmp = data[i];
        data[i] = data[j];
        data[j] = tmp;
    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param data
     * @param i
     * @param length
     */
    private static void adjustHeap(int[] data, int i, int length) {
        int tmp = data[i];

        for (int k = i*2+1;k<length;k=k*2+1){
            if (k+1<length && data[k]<data[k+1])
                k++;
            if (data[k] > tmp){
                data[i] = data[k];
                i=k;
            }else {
                break;
            }

        }
        data[i] = tmp;
    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data);
        System.out.println(Arrays.toString(data));
    }

8、基数排序

基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。点击这里了解常用的加密算法。

说基数排序之前，我们简单介绍桶排序：

算法思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是比较排序，他不受到 O(n log n) 下限的影响。

简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。

例如要对大小为[1…1000]范围内的n个整数A[1…n]排序

首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1…10]的整数，集合B[2]存储 (10…20]的整数，……集合B[i]存储( (i-1)10， i10]的整数，i = 1，2，…100。总共有 100个桶。

然后，对A[1…n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任何排序法都可以。

最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这样就得到所有数字排好序的一个序列了。

假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果

对每个桶中的数字采用快速排序，那么整个算法的复杂度是

O(n + m * n/m*log(n/m)) = O(n + nlogn – nlogm)

从上式看出，当m接近n的时候，桶排序复杂度接近O(n)

当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。

前面说的几大排序算法，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

2）其次待排序的元素都要在一定的范围内等等。

 public static int digit(int data,int m,int r){
        /*获取data的第m位数字，该数字为r进制*/
        int i,d;
        if(m==0) return data%r;
        d=r;
        for(i=1;i<m;i++){
            d=d*r;
        }
        return (data/d)%r;
    }

    public static void sort(int array[],int n,int m,int r){
        /*数组array中存放关键字为m位的r进制数，数组大小为n*/
        int i,j,k;
        Queue[] que=new Queue[r];  //定义一个队列数组
        for( i=0;i<r;i++){    //初始化队列数组
            que[i]=new LinkedList<Integer>();
        }

        for(i=0;i<m;i++){ //进行m趟排序

            for(j=0;j<n;j++){
                k=digit(array[j], i, r);   //取出数组中第j个数的第i位的值
                que[k].add(array[j]);      //把数组中第j个数放入k对应的队列中
            }

            j=0;
            for(k=0;k<r;k++){    //把所有队列中的值取出，重新存入数组array中
                while(!que[k].isEmpty()){
                    array[j++]=(int) que[k].remove();
                }
            }

            for(j=0;j<n;j++){   //输出每趟排序的结果
                System.out.print(array[j]+", ");
            }
            System.out.println();
        }

    }

    public static void main(String[] args) {
        int[] data = {10,5,1,9,2,0,18,4};
        sort(data, data.length, 3, 10);
        System.out.println(Arrays.toString(data));
    }

总结

各种排序的稳定性，时间复杂度、空间复杂度、稳定性总结如下图：
在这里插入图片描述

关于时间复杂度：

(1)平方阶(O(n2))排序
各类简单排序：直接插入、直接选择和冒泡排序；

(2)线性对数阶(O(nlog2n))排序
快速排序、堆排序和归并排序；

(3)O(n1+§))排序，§是介于0和1之间的常数。
希尔排序

(4)线性阶(O(n))排序
基数排序，此外还有桶、箱排序。

关于稳定性：

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

春来桃花开

关注

2
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
八大排序算法实现及图解

1、冒泡排序冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。算法步骤：1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。2）对每一对相邻元素作同...
复制链接

扫一扫