算法基础十：八大基本排序

最新推荐文章于 2021-11-23 16:20:39 发布

千寻之森

最新推荐文章于 2021-11-23 16:20:39 发布

阅读量149

点赞数

分类专栏： # 算法基础文章标签：排序算法数据结构算法

本文链接：https://blog.csdn.net/wuqiqi1992/article/details/109507499

版权

算法基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、交换排序

1、冒泡排序

相邻比较，交换，把最大交换到最后

 /**
     * 冒泡排序，两两比较
     * @param data
     */
    private static void bubbleSort(int[] data){
        for(int i=0;i<data.length-1;i++){
            for(int j=0;j<data.length-i-1;j++){
                if(data[j]>data[j+1]){
                    data[j]^=data[j+1];
                    data[j+1]^=data[j];
                    data[j]^=data[j+1];
                }
            }
        }
        System.out.print("冒泡排序算法：");
        print(data);
    }


/**
     * 冒泡排序，两两比较
     * @param data
     */
    private static void bubbleSort2(int[] data){
        for(int i=0;i<data.length-1;i++){
            for(int j=i+1;j<data.length;j++){
                if(data[i]>data[j]){
                    data[i]^=data[j];
                    data[j]^=data[i];
                    data[i]^=data[j];
                }
            }
        }
        System.out.print("冒泡排序算法：");
        print(data);
    }

2、快速排序

主要采用分治思想，也是有二分法的影子

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

private static void quickSort(int data[], int start,int end){
        int i,j,temp;
        if(start<end){
            i = start;
            j = end;
            temp = data[start];
            while (i<j){
                while (temp<=data[j] && i<j){
                    j--;
                }
                while (temp>=data[i] && i<j){
                    i++;
                }
                if(i<j && data[i]!=data[j]){
                    data[i]^=data[j];
                    data[j]^=data[i];
                    data[i]^=data[j];
                }
            }
            if(data[start]!=data[i]){
                data[start]^=data[i];
                data[i]^=data[start];
                data[start]^=data[i];
            }
            quickSort(data,start,j-1);
            quickSort(data,j+1,end);
        }
    }

二、选择排序

1、简单选择排序

把后面最小的数与第0个交换，剩下的最小数再与剩下的第0个交换，时间复杂度O( $n^{2}$ )

 private static void selectSort(int[] data){
        int key;
        for(int i=0;i<data.length-1;i++){
            key = minIndex(data,i);
            if(key!=i){
                data[i]^=data[key];
                data[key]^=data[i];
                data[i]^=data[key];
            }
        }
        System.out.print("选择排序算法：");
        print(data);
    }

 private static int minIndex(int[] data,int start){
        int result = start;
        for(int i=start+1;i<data.length;i++){
            if(data[result]>data[i]) result = i;
        }
        return result;
    }

2、二元选择排序

前面是最小值，可以改进为最小值和最前面交换，最大值和最后交换，减少比较次数：最多只需进行[n/2]趟循环

  /**
     * 二元选择排序，把后面最小的数于第0个交换，剩下的最小数再于剩下的第0个交换
     * @param data
     */
    private static void selectSort2(int[] data){
        int i,j,min,max;
        int len = data.length;
        for(i=0;i<=(len-1)/2;i++){
            min = i; max = i;
            for(j=i+1;j<=len-i-1;j++){
                if(data[j]>data[max]){
                    max = j;
                    continue;
                }
                if(data[j]<data[min]){
                    min = j;
                }
            }
            if(i!=min){
                data[i]^=data[min];
                data[min]^=data[i];
                data[i]^=data[min];
            }
            if(len-i-1!=max){
                data[len-i-1]^=data[max];
                data[max]^=data[len-i-1];
                data[len-i-1]^=data[max];
            }
        }
        System.out.print("二元选择排序算法：");
        print(data);
    }

3、堆排序

一般正序先调整成大根堆，一般逆序先调整成小根堆

大根堆：根节点大于或等于左右子结点

小根堆：根节点小于或等于左右子结点

 private static void  heapSort(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--){
            if(data[0]!=data[j]){
                data[0]^=data[j];
                data[j]^=data[0];
                data[0]^=data[j];
            }
            adjustHeap(data,0,j);
        }
        System.out.print("堆排序算法：");
        print(data);
    }

    private static void adjustHeap(int[] data, int i, int length){
        int temp = data[i];
        for(int j=i*2+1;j<length;j=j*2+1){
            if(j+1<length && data[j] <data[j+1]){
                j++;
            }
            if(data[j]>temp){
                data[i] = data[j];
                i = j;
            }else{
                break;
            }
        }
        data[i] = temp;
    }

三、插入排序

1、直接插入排序

把后面的数字插入到前面已经排好序的有序集合中

private static void insertSort(int[] data){
        int temp;
        for(int i=1;i<data.length;i++){
            temp = data[i];
            int j= i-1;
            while (temp<data[j]){
                data[j+1] = data[j];
                j--;
            }
            data[j+1] = temp;
        }
        System.out.print("插入排序算法：");
        print(data);
    }

2、希尔排序

思路：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

就是插入排序变种版

 private static void shellSort(int[] data){
        int len = data.length;
        int factor = len/2;
        int temp,j;
        while (factor>=1){
            for(int i=factor;i<len;i++){
                if(data[i]<data[i-factor]){
                    temp = data[i];
                    j= i-factor;
                    while (j>=0 && temp<data[j]){
                        data[j+factor] = data[j];
                        j-=factor;
                    }
                    data[j+factor] = temp;
                }
            }
            factor/=2;
        }
        System.out.print("希尔排序算法：");
        print(data);
    }

四、归并排序

最开始分成n/2 个 2个元素的小组，进行排序，再两两相互合并，最后合并成有序序列

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

    private static void merge(int[] data, int left, int mid, int right){
        int[] temp = new int[data.length];
        int i = left, j = mid+1, k = left;
        while (i <=mid && j<=right){
            if(data[i] <= data[j]){
                temp[k++] = data[i++];
            }else{
                temp[k++] = data[j++];
            }
        }
        while (i!= mid+1){
            temp[k++] = data[i++];
        }
        while (j!=right+1){
            temp[k++] = data[j++];
        }
        for(i = left; i<=right;i++){
            data[i] = temp[i];
        }
    }

五、基数排序/桶排序

来源百度百科：

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

最高位优先(Most Significant Digit first)法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。

最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列

LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。

这里我们就来看看 LSD的解法：

 public static void main(String[] args) {

       int[] data = new int[]{1,7,9,10,3,5,6,123,98,8,24};
     /*   System.out.print("原数据：");
        print(data);
        mergeSort(data,0,data.length-1);
        System.out.print("归并算法：");
        print(data);*/
        System.out.println("原数据："+ Arrays.toString(data));
        radixSort(data,3);
        System.out.println("基数排序后："+Arrays.toString(data));
    }

//表示最大的数有多少位
    private static void radixSort(int[] number, int d){
        int k = 0; //排序后 的索引位置
        int n = 1; //辅助变量，为了得到 多少位的值
        int m = 1; //控制键值排序依据在哪一位
        int[][]temp = new int[10][number.length]; //数组的第一维表示可能的余数0-9
        int[]order = new int[10]; //数组orderp[i]用来表示该位是i的数的个数
        while(m <= d)
        {
            for(int i = 0; i < number.length; i++)
            {
                int lsd = ((number[i] / n) % 10);
                temp[lsd][order[lsd]] = number[i];
                order[lsd]++;
            }
            for(int i = 0; i < 10; i++)
            {
                if(order[i] != 0)
                    for(int j = 0; j < order[i]; j++)
                    {
                        number[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }
            n *= 10;
            k = 0;
            m++;
        }
    }

六、排序的时间复杂度

时间复杂度函数比较

参考：https://www.jb51.net/article/98211.htm

千寻之森

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
算法基础十：八大基本排序

一、交换排序1、冒泡排序相邻比较，交换，把最大交换到最后 /** * 冒泡排序，两两比较 * @param data */ private static void bubbleSort(int[] data){ for(int i=0;i<data.length-1;i++){ for(int j=0;j<data.length-i-1;j++){ if(data[j]&g
复制链接

扫一扫