排序算法总结(冒泡排序、简单选择排序、直接插入排序、希尔shell排序、快速排序、归并排序、基数排序)

四、排序(Sort Algorithm)

文章目录

    • 四、排序(Sort Algorithm)
      • 1、概念
      • 2、排序算法
        • 2.1冒泡排序
        • 2.2简单选择排序
        • 2.3直接插入排序
        • 2.4希尔排序
        • 2.5快速排序
        • 2.6归并排序(MergeSort)
        • 2.7基数排序(桶排序的扩展)
        • 2.8排序算法总结

1、概念

排序的概念:排序是将一组数据按照指定的顺序进行排列的过程。

排序可以分为内部排序和外部排序,内部排序是将处理的所有数据都加载到内部存储器中进行排序。

若数据量过大,无法全部加载到内存中,需要借助于外部存储进行排序。

1.1、内部排序

  • 插入排序

直接插入排序、希尔排序

  • 选择排序

简单选择排序、堆排序

  • 交换排序

冒泡排序、快速排序

  • 归并排序
  • 基数排序

1.2外部排序

2、排序算法

2.1冒泡排序

概念:冒泡排序是一种交换排序,它的基本思想是:按照某种排序规则,两两比较相邻的元素的关键字,如果是反序则交换,直到没有反序的记录为止。

  • 普通的冒泡算法

    for (int i = 0; i < arr.length - 1; i++) {
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        swap(arr, j, j + 1);
                    }
                }
                System.out.println(Arrays.toString(arr));
            }
    
  • 优化排序算法

    存在这样一种情况,没有数据交换时,即说明此序列已经有序了,即不再需要判断后面的数据了,我们需要优化代码,即当序列已经有序时,不再对后面的数据进行判断。

     boolean flag = true;
            for (int i = 0; i < arr.length - 1&&flag; i++) {
                flag=false;
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        swap(arr, j, j + 1);
                        flag = true;
                    }
                }
                System.out.println(Arrays.toString(arr));
            }
    

2.2简单选择排序

概念:即通过n-i次关键字间的比较,从n-i+1(包括自己)个记录中选出关键字最小的记录,并和第i个记录交换。

for (int i = 0; i < arr.length - 1; i++) {
            int minSize = i;
            int min = arr[minSize];
            for (int j = i + 1; j <= arr.length - 1; j++) {
                if(min>arr[j]){
                    minSize=j;
                    min=arr[j];
                }
            }
            if(i!=minSize){
                arr[minSize]=arr[i];
                arr[i]=min;

            }
        }

2.3直接插入排序

概念:把n个待排序的元素成一个有序列表和一个无序表,开始时有序表只包含一个元素,无序表中包含n-1个元素,排序过程中每次从无序表中取出第一个元素,把它的排序码依次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表。

int insertScrpt=0;//要插入的位置
        int insertValue=0;//插入的值
        for(int i=1;i<=arr.length-1;i++){
            insertScrpt=i-1;
            insertValue=arr[i];
            while (insertScrpt>=0&&insertValue<arr[insertScrpt]){
                arr[insertScrpt+1]=arr[insertScrpt];//向后移
                insertScrpt--;
            }
            if(insertScrpt+1!=i){
                arr[insertScrpt+1]=insertValue;
            }
        }

2.4希尔排序

概念:希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序;随着增量的逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件掐被分成一组,算法终止。

  • 交换法(时间复杂度为17s左右)

    int temp = 0;
            for (int increment = arr.length / 2; increment > 0; increment = increment / 2) {
                for (int i = increment; i < arr.length; i++) {
                    for (int j = i - increment; j >= 0; j -= increment) {
                        if (arr[j] > arr[j + increment]) {
                            temp = arr[j];
                            arr[j] = arr[j + increment];
                            arr[j + increment] = temp;
                        }
                    }
                }
                System.out.println(Arrays.toString(arr));
            }
    
  • 移位法(时间复杂度为1s左右)

    for (int increment = arr.length / 2; increment > 0; increment = increment / 2) {
    
                for (int i = increment; i < arr.length; i++) {
                    int j = i;
                    int temp = arr[j];
                    if (arr[j] < arr[j - increment]) {
                        while (j - increment >= 0 && temp < arr[j - increment]) {
                            arr[j] = arr[j - increment];
                            j -= increment;
                        }
                        arr[j] = temp;
                    }
                }
                System.out.println(Arrays.toString(arr));
            }
    

2.5快速排序

思想:快速排序是对冒泡排序的一种改进,通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有的数据比另一部分的所有数据都要小,然后按此方法对这个两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

public static void quickSort(int[] arr,int left,int right){
        int l=left;
        int r=right;
        int temp=0;
        int privot=arr[(right+left)/2];
       while (l<r){
           while (arr[l]<privot){
                l++;
           }
           while (arr[r]>privot){
               r--;
           }
           if(l>=r){
               break;
           }
           temp=arr[l];
           arr[l]=arr[r];
           arr[r]=temp;

           if(arr[l]==privot){
               r--;
           }
           if(arr[r]==privot){
               l++;
           }
       }
       if(l==r){
           l+=1;
           r-=1;
       }
       //左递归
        if (left<r){
            quickSort(arr,left,r);

        }
        //向右递归
        if(right>l){
            quickSort(arr,l,right);
        }
    }

2.6归并排序(MergeSort)

归并排序是利用归并的思想进行排序的方法,采用经典的分治策略(分治是将问题分解成一些小问题然后递归求解,然后就将各个阶段的答案修补在一起)

网上找的图解
排序算法总结(冒泡排序、简单选择排序、直接插入排序、希尔shell排序、快速排序、归并排序、基数排序)_第1张图片
这种结构很想一个完全二叉树,我们采用递归的方法去实现,也可以采用迭代方法去实现,分阶段可以理解为递归拆分子序列的过程。

  • 序列的拆分

        public static void mergeSort(int[] arr, int left, int right, int[] temp) {
            if (left < right) {
                int mid = (left + right) / 2;
                //向左递归分解
                mergeSort(arr, left, mid, temp);
                //向右递归分解
                mergeSort(arr, mid + 1, right, temp);
                //合并
                 merge(arr, left, mid, right, temp);
            }
        }
    
  • 序列的合并

    /**
         * 合并
         *
         * @param arr   原始数组,待排序的数组
         * @param left  数组的左边坐标
         * @param mid   数组的中间坐标
         * @param right 数组的右边坐标
         * @param temp  临时数组
         */
        public static void merge(int[] arr, int left, int mid, int right, int temp[]) {
            int i = left;//初始化i,左边序列的初始索引
            int j = mid + 1;//初始化j,右边序列的初始索引
            int t = 0; //临时变量的索引
            //1、将拆开的左右数组中的元素分别比较大小,并放入临时数组,直至某一数组被放完
            while (i <= mid && j <= right) {
                if (arr[i] < arr[j]) {
                    temp[t] = arr[i];
                    i++;
                    t++;
                } else {
                    temp[t] = arr[j];
                    j++;
                    t++;
                }
            }
    
            //2、将剩下数组的元素全部移动到临时数组中
            while (i <= mid) {
                temp[t] = arr[i];
                i++;
                t++;
            }
            while (j <= right) {
                temp[t] = arr[j];
                j++;
                t++;
            }
            //3 将临时数组的元素合更新到原数组
            t = 0;
            int tempLeft = left;
            while (tempLeft <= right) {
                arr[tempLeft] = temp[t];
                t++;
                tempLeft++;
            }
    
        }
    

2.7基数排序(桶排序的扩展)

算法描述:基数排序就是分离出数字的每一位,根据每一位的大小放入指定的桶中,桶用数组来表示,共分成编号为0-9的桶。如249,分离个位时,249放入编号为9的桶中,分离十位时,246放入编号为4的桶中,分离千位时,249放入编号为0的桶中。存在负数的序列不能使用基数排序。

基本思想:将所有待比较数值统一为同样的数位长度,数位较短的数前面补零,然后,从最低位开始,依次进行一次排序,这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

 public static void radisSort(int[] arr){
        //找出最大数并确定位数
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(max<arr[i]){
                max=arr[i];
            }
        }
        int maxLength=(max+"").length();
        //定义桶,为了防止元素溢出,需要将每个桶的容量都定义为:arr.length
        int[][] bucket=new int[10][arr.length];
        //定义一个数组bucketElementCount[],用来记录每个桶中放入的元素的数量
        int[] bucketElementCount=new int[10];
        /**
         * 将数据元素放入桶中
         */
        for(int l=0,n=1;l<maxLength;n=n*10,l++){
            for(int i=0;i<arr.length;i++){
                int endDigital=arr[i]/n%10;
                bucket[endDigital][bucketElementCount[endDigital]]=arr[i];
                bucketElementCount[endDigital]++;
            }
            /**
             * 取出元素
             */
            int index=0;
            for(int i=0;i<bucket.length;i++){
                if(bucketElementCount[i]!=0){
                    for(int j=0;j<bucketElementCount[i];j++){
                        arr[index]=bucket[i][j];
                        index++;
                    }
                }
            //将bucketElemnetCount清零
                bucketElementCount[i]=0;
            }
            System.out.println(Arrays.toString(arr));
        }

    }

2.8排序算法总结

排序算法总结(冒泡排序、简单选择排序、直接插入排序、希尔shell排序、快速排序、归并排序、基数排序)_第2张图片

你可能感兴趣的:(数据结构与算法)