当前位置 博文首页 > Yawn:常见排序算法

    Yawn:常见排序算法

    作者:[db:作者] 时间:2021-08-02 18:38

    0. 概述

    排序算法可以分为内部排序和外部排序:

    • 内部排序是数据记录在内存中进行排序。
    • 外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。

    在这里插入图片描述

    1. 直接插入排序

    通常人们整理桥牌的方法是一张一张的来,将每一张牌插入到其他已经有序的牌中的适当位置。在计算机的实现中,为了要给插入的元素腾出空间,我们需要将其余所有元素在插入之前都向右移动一位。

    一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

    • 从第一个元素开始,该元素可以认为已经被排序
    • 默认从第二个数据开始比较。
    • 如果第二个数据比第一个小,则交换。然后在用第三个数据比较,如果比前面小,则插入(狡猾)。否则,退出循环
    • 说明:默认将第一数据看成有序列表,后面无序的列表循环每一个数据,如果比前面的数据小则插入(交换)。否则退出。
    public static void main(String[] args) {
    
            int arr[] = {7, 5, 3, 2, 4};
    
            //插入排序
            for (int i = 1; i < arr.length; i++) {
                //外层循环,从第二个开始比较
                for (int j = i; j > 0; j--) {
                    //内存循环,与前面排好序的数据比较,如果后面的数据小于前面的则交换
                    if (arr[j] < arr[j - 1]) {
                        int temp = arr[j - 1];
                        arr[j - 1] = arr[j];
                        arr[j] = temp;
                    } else {
                        //如果不小于,说明插入完毕,退出内层循环
                        break;
                    }
                }
            }
        }
    

    时间复杂度:
    在这里插入图片描述
    插入排序所需的时间取决于输入元素的初始顺序。例如,对一个很大且其中的元素已经有序(或接近有序)的数组进行排序将会比随机顺序的数组或是逆序数组进行排序要快得多。

    2. 冒泡排序

    • a、冒泡排序,是通过每一次遍历获取最大/最小值
    • b、将最大值/最小值放在尾部/头部
    • c、然后除开最大值/最小值,剩下的数据在进行遍历获取最大/最小值
    public static void main(String[] args) {
    
            int arr[] = {8, 5, 3, 2, 4};
    
            //冒泡
            for (int i = 0; i < arr.length; i++) {
                //外层循环,遍历次数
                for (int j = 0; j < arr.length - i - 1; j++) {
                    //内层循环,升序(如果前一个值比后一个值大,则交换)
                    //内层循环一次,获取一个最大值
                    if (arr[j] > arr[j + 1]) {
                        int temp = arr[j + 1];
                        arr[j + 1] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
    

    排序过程:
    在这里插入图片描述

    时间复杂度:
    在这里插入图片描述

    • 冒泡排序是最容易实现的排序, 最坏的情况是每次都需要交换, 共需遍历并交换将近n2/2次, 时间复杂度为O(n2).
    • 最佳的情况是内循环遍历一次后发现排序是对的, 因此退出循环, 时间复杂度为O(n). 平均来讲, 时间复杂度为O(n2). 由于冒泡排序中只有缓存的temp变量需要内存空间, 因此空间复杂度为常量O(1).

    3. 选择排序

    • a、将第一个值看成最小值
    • b、然后和后续的比较找出最小值和下标
    • c、交换本次遍历的起始值和最小值
    • d、说明:每次遍历的时候,将前面找出的最小值,看成一个有序的列表,后面的看成无序的列表,然后每次遍历无序列表找出最小值。
    public void sort3(int arr[]) {
            for(int i = 0; i < arr.length; i++){
                int min = arr[0];
                int index = i;
                for(int j = i + 1; j <arr.length; j++){
                    if(min > arr[j]){
                        index = j;
                        min = arr[j];
                    }
                }
                int temp = arr[i];
                arr[i] = min;
                arr[index] = temp;
            }
            System.out.println("选择排序,排序后--------------------");
        }
    

    排序过程:
    在这里插入图片描述

    4. 希尔排序

    希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一。

    • 希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。
    • 简单插入排序很循规蹈矩,不管数组分布是怎么样的,依然一步一步的对元素进行比较,移动,插入,比如[5,4,3,2,1,0]这种倒序序列,数组末端的0要回到首位置很是费劲,比较和移动元素均需n-1次。
    • 而希尔排序在数组中采用跳跃式分组的策略,通过某个增量将数组元素划分为若干组,然后分组进行插入排序,随后逐步缩小增量,继续按组进行插入排序操作,直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序,小的基本在前,大的基本在后。然后缩小增量,到增量为1时,其实多数情况下只需微调即可,不会涉及过多的数据移动。

    看下希尔排序的基本步骤:

    • 我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2…1},称为增量序列。
    • 希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
      在这里插入图片描述
    	public static void swap(int []arr,int a,int b){
            int temp = arr[a];
            arr[a] = arr[b];
            arr[b] = temp;
        }
        
    	 /**
         * 希尔排序 针对有序序列在插入时采用交换法
         * @param arr
         */
        public static void sort(int []arr){
            //增量gap,并逐步缩小增量
           for(int gap=arr.length/2;gap>0;gap/=2){
               //从第gap个元素,逐个对其所在组进行直接插入排序操作
               for(int i=gap;i<arr.length;i++){
                   int j = i;
                   while(j-gap>=0 && arr[j]<arr[j-gap]){
                       //插入排序采用交换法
                       swap(arr,j,j-gap);
                       j-=gap;
                   }
               }
           }
        }
    

    排序过程:
    在这里插入图片描述

    cs