一、 排序算法概述

  日常的程序设计中,排序是很常见的需求,把数据元素按照一定的规则进行排序,比如淘宝上的货品按照上架日期排序,百度的搜索按照最新的内容排序。

二、 冒泡排序

  2.1排序原理

  • 比较相邻的元素,如果前一个元素比后一个元素大,就交换两个元素的位置
  •  第一次冒泡,最大的元素会被交换到最后的位置,第二次冒泡,第二大的元素会被交换到倒数第二的位置,以此类推,每次冒泡后参与冒泡的数量都会减少一个,直到最后参与冒泡的个数为1,则此时排序完成

  2.2排序演示图

   

  2.3代码实现

import java.util.Arrays;

 

public class Bubble {

      

       public static void main(String[] args) {

              Integer[] list = new Integer[] {5,1,3,2,4};

              Bubble.sort(list);

              System.out.println(Arrays.toString(list));

       }

      

       /**

        * 冒泡核心排序算法

        * @param col

        */

       private static void sort(Comparable[] col) {

              for(int i=col.length-1;i>0;i--) {//每次冒泡完都会减少一个数参与下一轮冒泡,直到剩最后一个数为止

                     for(int j=0;j<i;j++) {//前后元素的比较,由于每次冒泡完减少一个数参与比较,故j跟着i的数量走

                            if(bigger(col[j], col[j+1])) {

                                   switchPos(col,j,j+1);

                            }

                     }

              }

       }

      

       /**

        * 前后元素的比较

        * @param a

        * @param b

        * @return

        */

       private static boolean bigger(Comparable a,Comparable b) {

              return a.compareTo(b)>0;

       }

 

       /**

        * 元素位置的交换

        * @param col

        * @param i

        * @param j

        */

       private static void switchPos(Comparable[] col,int a,int b) {

              Comparable t = col[a];

              col[a] = col[b];

              col[b] = t;

       }

}

      

  2.4时间复杂度分析

  冒泡排序中,元素交换的执行次数为

  (n-1)+(n-2)+…+2+1 = n^2/2-n/2

  元素参与比较的执行次数为

  (n-1)+(n-2)+…+2+1 = n^2/2-n/2

  故冒泡的算法时间复杂度相加为n^2-n,根据大O计数法为O(n^2)

三、 选择排序

  3.1排序原理

  • 对于需要排序的数据对象中,假设第一个索引处的值为最小值,遍历过程中,当前索引处的值大于其他索引处的值时,认为其他索引处的值为最小值,并互相交换位置,直到遍历至数据对象的导数第二个数为止

  3.2排序演示图

   

  3.3代码实现

import java.util.Arrays;

 

public class Select {

 

       public static void main(String[] args) {

              Integer[] list = new Integer[] {5,1,3,2,4};

              Select.sort(list);

              System.out.println(Arrays.toString(list));

       }

      

       /**

        * 选择核心排序算法

        * @param col

        */

       private static void sort(Comparable[] col) {

              for(int i=0;i<col.length-1;i++) {

                     int minIndex = i;

                     for(int j=i+1;j<col.length;j++) {

                            if(bigger(col[minIndex],col[j])) {

                                   minIndex = j;

                            }

                     }

                     switchPos(col, i, minIndex);

              }

       }

      

       /**

        * 前后元素的比较

        * @param a

        * @param b

        * @return

        */

       private static boolean bigger(Comparable a,Comparable b) {

              return a.compareTo(b)>0;

       }

 

       /**

        * 元素位置的交换

        * @param col

        * @param i

        * @param j

        */

       private static void switchPos(Comparable[] col,int a,int b) {

              Comparable temp = col[a];

              col[a] = col[b];

              col[b] = temp;

       }

}

 

  3.4时间复杂度分析

  选择排序使用双层for循环,外层是数据交换,里层是数据比较

  数据比较的次数是:(n-1)+(n-2)+…+2+1 = n^2/2-n/2

  数据交换的次数是:n-1

  故冒泡的算法时间复杂度相加为n^2/2+n/2-1,根据大O计数法为O(n^2)

四、 插入排序

  4.1排序原理

  • 把待排序的数据元素分成已排序和待排序的两组
  • 找到未排序的第一个元素,向已排序的数据元素中插入
  • 倒叙遍历已经排序的元素,直到找到比待插入元素小的元素,将待插入元素放在此位置,其余元素向后移动一位

  4.2排序演示图

   

  4.3代码实现

import java.util.Arrays;

 

public class Insert {

 

       public static void main(String[] args) {

              Integer[] list = new Integer[] {5,1,3,2,4};

              Insert.sort(list);

              System.out.println(Arrays.toString(list));

       }

      

       /**

        * 插入核心排序算法

        * @param col

        */

       private static void sort(Comparable[] col) {

              //外层为未排序对象

              for(int i=1;i<col.length;i++) {

                     //里层为已排序对象的倒序

                     for(int j=i;j>0;j--) {

                            if(bigger(col[j-1], col[j])) {

                                   switchPos(col, j-1, j);

                            }else {

                                   break;

                            }

                     }

              }

       }

      

       /**

        * 前后元素的比较

        * @param a

        * @param b

        * @return

        */

       private static boolean bigger(Comparable a,Comparable b) {

              return a.compareTo(b)>0;

       }

 

       /**

        * 元素位置的交换

        * @param col

        * @param i

        * @param j

        */

       private static void switchPos(Comparable[] col,int a,int b) {

              Comparable temp = col[a];

              col[a] = col[b];

              col[b] = temp;

       }

}

      

  4.4时间复杂度分析

  插入排序使用双层for循环,外层是未排序数据元素,里层是已排序数据元素

  数据比较的次数是:(n-1)+(n-2)+…+2+1 = n^2/2-n/2

  数据交换的次数是:(n-1)+(n-2)+…+2+1 = n^2/2-n/2

  故冒泡的算法时间复杂度相加为n^2-n,根据大O计数法为O(n^2)

五、 希尔排序

  5.1排序原理

  • 选定一个增长量h,对数据对象按h的间隔进行分组,并对分组后的数据进行插入排序
  • 减小增长量h直到剩下1,即排序成功
  • 增长量h的选定无固定规则,经过科学论证h的规则存在多种可行的可能,没有绝对最优的规则,一般选择数组的长度n/2作为初始值,随后也是按n=n/2做递减
  • 假设在插入排序中,有序的数组为2,3,5,6,无序数组为1,8,那么1和8的插入每次都得遍历2,3,5,6后才能做插入,而设定了增长量后,可以有效的减少遍历的次数,故希尔排序是插入排序的优化

  5.2排序演示图

   

  5.3代码实现

import java.util.Arrays;

 

public class Hill {

 

       public static void main(String[] args) {

              Integer[] list = new Integer[] {5,1,3,2,4};

              Hill.sort(list);

              System.out.println(Arrays.toString(list));

       }

      

       /**

        * 希尔核心排序算法

        * @param col

        */

       private static void sort(Comparable[] col) {

              int n = col.length;

              int h = 1; //初始增量

              while(h<n/2) {

                     h = h*2+1;

              }

             

              while(h>=1) {

                     //外层先找到待插入的元素,待插入的元素以h为起始索引

                     for(int i=h;i<n;i++) {

                            //里层对待插入的元素,往前按h间隔找到待插入排序的数进行插入排序

                            for(int j=i;j>=h;j=j-h) {

                                   if(bigger(col[j-h],col[j])) {

                                          switchPos(col, j-h, j);

                                   }

                            }

                            h = h/2;

                     }

              }

       }

      

       /**

        * 前后元素的比较

        * @param a

        * @param b

        * @return

        */

       private static boolean bigger(Comparable a,Comparable b) {

              return a.compareTo(b)>0;

       }

 

       /**

        * 元素位置的交换

        * @param col

        * @param i

        * @param j

        */

       private static void switchPos(Comparable[] col,int a,int b) {

              Comparable temp = col[a];

              col[a] = col[b];

              col[b] = temp;

       }

}

 

  5.4时间复杂度分析

  希尔排序的时间复杂度无法做清晰的计算,有人根据大量数据得出平均时间复杂度为O(n^1.3),我们可以做个实验如下,对于10w的大数据量情况下的排序,是不是希尔排序要优于插入排序

   

   

  通过实际的测验证明,希尔排序的性能确实是优于插入排序的

六、 归并排序

  6.1排序原理

  

   如图,归并算法采用分治的思想,主要通过如下三步实现数据有序

  • 将数据元素进行对半拆分,直到拆成只有1个数据元素的n组数据
  • 对相邻的两组数进行排序,使之有序并合并
  • 不断重复上一步,直到合成了一组有序的数据
  • 归并排序是一种空间换时间的算法

  6.2排序演示图

   

   

   

   

  6.3代码实现

import java.util.Arrays;

 

public class Merge {

      

       //辅助数组声明

       private static Comparable[] assist;

 

       public static void main(String[] args) {

              Integer[] list = new Integer[] {5,1,3,2,4};

              Merge.sort(list);

              System.out.println(Arrays.toString(list));

       }

      

       /**

        * 归并核心排序算法

        * @param col

        */

       public static void sort(Comparable[] col) {

              int low = 0;

              int high = col.length-1;

              assist = new Comparable[col.length];

              sort(col,low,high);

       }

      

       private static void sort(Comparable[] col,int low,int high) {

              if(high<=low) {

                     return;

              }

             

              int mid = low + (high-low)/2;

             

              //对左子组进行递归排序

              sort(col,low,mid);

             

              //对右子组进行递归排序

              sort(col,mid+1,high);

             

              //归并排序

              merge(col,low,mid,high);

       }

      

       /**

        * 对已排序的几组数据进行归并排序

        * @param col

        * @param low

        * @param mid

        * @param high

        */

       private static void merge(Comparable[] col, int low, int mid, int high) {

              int index = low;

              int p1 = low;    //左右子组比对的左指针

              int p2 = mid+1;  //左右子组比对的右指针

             

              //左右指针分别走,对比两个指针下的数据,小的往辅助数组里放

              while(p1<=mid && p2<=high) {

                     int leftNum = (int) col[p1];

                     int rightNum = (int) col[p2];

                     System.out.println("左数:"+leftNum+" 右数:"+rightNum);

                     if(bigger(leftNum, rightNum)) {

                            assist[index++] = col[p2++];

                     }else {

                            assist[index++] = col[p1++];

                     }

              }

             

              //右指针的数据比较完了,把左指针剩余的数填充到辅助数组中

              while(p1<=mid) {

                     assist[index++] = col[p1++];

              }

             

              //左指针的数据比较完了,把右指针剩余的数填充到辅助数组中

              while(p2<=high) {

                     assist[index++] = col[p2++];

              }

             

              for(int i=low;i<=high;i++) {

                     col[i]=assist[i];

              }

       }

 

       /**

        * 前后元素的比较

        * @param a

        * @param b

        * @return

        */

       private static boolean bigger(Comparable a,Comparable b) {

              return a.compareTo(b)>0;

       }

 

       /**

        * 元素位置的交换

        * @param col

        * @param i

        * @param j

        */

       private static void switchPos(Comparable[] col,int a,int b) {

              Comparable temp = col[a];

              col[a] = col[b];

              col[b] = temp;

       }

}

 

  6.4时间复杂度分析

   

   假设数据元素的个数为N,那么拆分有logN层,每层的最坏情况都是比较N次,所以算法复杂度为logN*N+logN,根据大O计数法为O(N*logN)

七、 快速排序

  7.1排序原理

   

  • 从数据元素中取一个值作为分界值,选取小于该分界值的元素作为左子组,选取大于该分解值的元素作为右子组
  • 左右子组一直重复上述操作,直到子组的个数为1

  7.2排序演示图

   

   

  

   

  

   

  7.3代码实现

package com.data.struct.common.sort.quick;

 

import java.util.Arrays;

import com.data.struct.common.sort.merge.Merge;

 

public class Quick {

 

       public static void main(String[] args) {

              //Integer[] list = new Integer[] { 6,7,8,9,10,2,3,1};

              Integer[] list = new Integer[] {3,1,2};

              Quick.sort(list);

              System.out.println(Arrays.toString(list));

       }

 

       /**

        * 归并核心排序算法

        *

        * @param col

        */

       public static void sort(Comparable[] col) {

              int low = 0;

              int high = col.length - 1;

              sort(col, low, high);

       }

 

       private static void sort(Comparable[] col, int low, int high) {

              if (high <= low) {

                     return;

              }

             

              System.out.println(Arrays.toString(col));

             

              int quickIndex = quick(col, low, high);

 

              // 对左子组进行递归排序

              sort(col, low, quickIndex-1);

 

              // 对右子组进行递归排序

              sort(col,  quickIndex+1, high);

       }

 

       /**

        * 对已排序的几组数据进行归并排序

        *

        * @param col

        * @param low

        * @param mid

        * @param high

        */

       private static int quick(Comparable[] col, int low,  int high) {

              //设定一个基准值,一般以第一个数为准

              Comparable value = col[low];

              //左指针起始位置

              int leftPointer = low;

              //右指针起始位置

              int rightPointer = high + 1;

             

              while(true) {

                     boolean flag = bigger(col[--rightPointer],value);

                     while(flag) {     //从右往左扫指针,发现比基准值小的值则停下

                            if(rightPointer<=low) {

                                   break;

                            }

                     }

                    

                     while(bigger(value,col[++leftPointer])) {     //从左往右扫指针,发现比基准值大的值则停下

                            if(leftPointer>=high) {

                                   break;

                            }

                     }

                    

                     if(leftPointer>=rightPointer) {                          //左指针和右指针相遇,说明全部元素已扫描完成,跳出while循环

                            break;

                     }else {

                            switchPos(col, leftPointer, rightPointer); //左指针和右指针没相遇前,说明元素还没扫描完成,此时符合条件的元素交换位置

                     }                                                                              

              }

             

              //此时左边的元素小于基准值,右边的元素大于基准值,此时交换基准值和左右指针重叠处的值,基准值所在的索引,为新分组数据的分界线

              switchPos(col, low, rightPointer);           

              return rightPointer;

       }

 

       /**

        * 前后元素的比较

        *

        * @param a

        * @param b

        * @return

        */

       private static boolean bigger(Comparable a, Comparable b) {

              return a.compareTo(b) > 0;

       }

 

       /**

        * 元素位置的交换

        *

        * @param col

        * @param i

        * @param j

        */

       private static void switchPos(Comparable[] col, int a, int b) {

              Comparable temp = col[a];

              col[a] = col[b];

              col[b] = temp;

       }

}

 

  7.4时间复杂度分析

   

  假设每次选中的基准值都是中位数,则会出现如图的情况,切分次数为logN次,每次交换元素的操作为N/2,所以最优情况下的算法复杂度为N/2*logN次,根据大O计算法推算出为O(N*logN)

   

  假设每次选中的基准值都是最大值或最小值,则每次左或右指针都得全量扫描,即N次,切分次数因此也需要N次,如果有数字为4,1,2,3,那么每次快排的结果如下

  4123

  3124

  2134

  1234

  所以最坏情况下的快排结果为O(N^2)

7.5快速排序和归并排序的区别

  • 归并排序是将若干数据元素切割成了最细粒度的左右子组,并对相邻子组进行排序,并合并。快速排序是将若干数据元素切割成了有序的左右子组,这样当所有左右子组都有序时,整个数据元素对象也就有序了。
  • 在归并排序中,一个数组被等分为两半,递归调用发生在排序之前,在快速排序中,切分数组的位置取决于数组的内容,递归调用发生在排序之后

八、 排序的稳定性

  在一组数据元素中,A和B相等,并且A元素排在B元素后面,经过一轮排序后,值相等的A和B的位置依然不变,此时排序是稳定的。

   

  稳定性的意义:

  如果一组数据元素只需要根据一种排序方式进行排序,此时排序稳定性是没有意义的,多种方式的排序,如几件商品同时进行价格,销量,库存等方式的排序,则此时排序稳定性是有意义的,如下:

  按价格从高到低排序

   

  按销量从高到低排序

   

  排序算法的稳定性:

  冒泡排序(稳定算法):冒泡排序中,通过相邻元素的大小比较,只有当前一个元素比后一个元素大时才交换位置,所以相等元素的位置保持不变,所以冒泡排序是稳定的算法

  选择排序(不稳定算法):选择排序中,是假设第一个数为最小的,往后遍历发现比该数小的则交换位置,在5,6,5,2这一组数中,当第一个数遍历至元素2时,会发生元素交换,此时变成了2,6,5,5

  由此判断选择排序是不稳定的

  希尔排序(不稳定算法):希尔排序是按照一定增长量进行排序的算法,假设有一组数3,3,1,5,希尔的增长量为2,则在第一次插入排序后变成了1,3,3,5,由此判断希尔排序是不稳定的

  归并排序(稳定算法):归并算法是虽然将数据元素拆分成n对,并且对相邻组的元素进行排序,但是只有在发生左指针扫到的元素,大于右指针扫的元素时,才将小的元素填充到辅助数组中

  相等元素不会发生操作,所以归并排序是稳定的

  快速排序(不稳定算法):快速排序是找一个基准值,左指针扫到比基准值小的放左边,右指针扫到比基准值大的放右边,若基准值找的数据元素中的中位数,如 4,3,2,2,1

  第一轮快排后的位置是1,2,2,3,4,由此判断快速排序是不稳定的

 


发布评论
IT源码网

微信公众号号:IT虾米 (左侧二维码扫一扫)欢迎添加!

数据结构(一):算法分析讲解
你是第一个吃螃蟹的人
发表评论

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。