九大排序算法Java实现

Posted 2020-09-01 JetHu

之前学习数据结构与算法时花了三天时间整理九大排序算法，并采用Java语言来实现，今天第一次写博客，刚好可以把这些东西从总结的文档中拿出来与大家分享一下，同时作为自己以后的备忘录。   

1.排序算法时间复杂度、稳定性分类：

2.排序算法问题描述与实现

2.1冒泡排序（交换排序-稳定）

【问题描述】对于一个int数组，请编写一个冒泡排序算法，对数组元素排序。 
问题分析：冒泡排序，顾名思义，从前往后遍历，每次遍历在末尾固定一个最大值。

易错点：每次内层循环结束都会在末尾确定一个元素的位置，因此内层循环的判断条件要减去外层的循环次数i

public int[] BobbleSort(int[] array){ 

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

            for(int j=0;j<array.length-1-i;j++){  //内层循环，注意array.length-1-i，一定要-i

                swap(array,j,j+1);//交换数据元素的方法

            }

         }

         return array;

      }

      public void swap(int[] array,int i,int j){//交换数据元素的方法

         if(array[i]>array[j]){

            int temp=array[i];

             array[i]=array[j];

             array[j]=temp;

         }

      }

冒泡排序的改进：加一个布尔型的flag，当某一趟冒泡排序没有元素交换时，则冒泡结束，元素已经有序，可以有效的减少冒泡次数。

 

2.2 选择排序（不稳定）

【问题描述】对于一个int数组，请编写一个选择排序算法，对数组元素排序。  
问题分析：选择排序，从前往后遍历，每次遍历从头开始依次选择最小的来排序。

注意点：

【初始升序】：交换0次，时间复杂度为o(n); 【初始降序】：交换n-1次，时间复杂度为o(n^2)。

【特点】：交换移动数据次数少，比较次数多。

   public int[] choose(int[] array){

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

         int min=i;

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

            if(array[min]>array[j])

                min=j;

         }

         if(i!=min){

            swap(array,i,min);

         }

      }

      return array;

   }

  public void swap(int[] array,int i,int j){

      if(array[i]>array[j]){

         int temp=array[i];

          array[i]=array[j];

          array[j]=temp;

      }

   }

 

2.3 直接插入排序（稳定的 ）

【问题描述】对于一个int数组，请编写一个插入排序算法，对数组元素排序。  
问题分析：插入排序，从前往后遍历，每次遍历确定一个元素的位置，下一个元素从后往前依次与排序好的元素比较，类似于摸扑克牌。

注意点：假定n是数组的长度，首先假设第一个元素被放置在正确的位置上，这样仅需从1-n-1范围内对剩余元素进行排序。对于每次遍历，从0-i-1范围内21.的元素已经被排好序，每次遍历的任务是：通过扫描前面已排序的子列表，将位置i处的元素定位到从0到i的子列表之内的正确的位置上。将arr[i]复制为一个名为target的临时元素。向下扫描列表，比较这个目标值target与arr[i-1]、arr[i-2]的大小，依次类推。这个比较过程在小于或等于目标值的第一个元素(arr[j])处停止，或者在列表开始处停止（j=0）。在arr[i]小于前面任何已排序元素时，后一个条件（j=0）为真，因此，这个元素会占用新排序子列表的第一个位置。在扫描期间，大于目标值target的每个元素都会向右滑动一个位置（arr[j]=arr[j-1]）。一旦确定了正确位置j，目标值target（即原始的arr[i]）就会被复制到这个位置。与选择排序不同的是，插入排序将数据向右滑动，并且不会执行交换。

   public int[] insert1(int[] array){

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

         int j=i;

         int temp=array[i];

         while(j>0&&array[j-1]>temp){

            array[j]=array[j-1];//元素右移

            j--;

         }

         array[j]=temp;

      }

      return array;

   }

 

2.4 希尔排序（2个for循环+最后一个while，不稳定）

问题描述：对于一个int数组，请编写一个希尔排序算法，对数组元素排序。  
问题分析：希尔排序是改进的插入排序，算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。希尔排序法(缩小增量法) 属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。

• public int[] hillInsert(int[] array){
•     for (int d = array.length>>1; d>=1; d=d>>1) {
•        for(int i=d;i<array.length;i++){
•           int j=i;
•           int temp=array[i];
•           while(j>=d&&array[j-d]>temp){
•              array[j]=array[j-d];
•              j-=d;
•           }
•           array[j]=temp;
•        }
•     }
•     return array;
• }

2.5.堆排序（不稳定）

 问题描述：对于一个int数组，请编写一个堆排序算法，对数组元素排序。  
问题分析：堆数据结构是一种数组对象，它可以被视为一科完全二叉树结构（完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树）。它的特点是父节点的值大于（小于）两个子节点的值（分别称为大顶堆和小顶堆）。它常用于管理算法执行过程中的信息，应用场景包括堆排序，优先队列等。

完全二叉树性质：如果i>1,则双亲是结点[i/2]。也就是说下标i与2i和2i+1是双亲子女关系。 当排序对象为数组时，下标从0开始，所以下标 i 与下标 2i+1和2i+2是双亲子女关系。

算法思路：

• 堆排序：（大根堆）
• ①将存放在array[0，...，n-1]中的n个元素建成初始堆；
• ②将堆顶元素与堆底元素进行交换，则序列的最大值即已放到正确的位置；
• ③但此时堆被破坏，将堆顶元素向下调整使其继续保持大根堆的性质，再重复第②③步，直到堆中仅剩下一个元素为止。
• 堆排序算法的性能分析：
• 空间复杂度:o(1)；
• 时间复杂度:建堆：o(n)，每次调整o(log n)，故最好、最坏、平均情况下：o(n*logn);
• 稳定性：不稳定

• public static int[] heapMax(int[] array){  //建立大根堆
•     for(int i=(array.length-2)/2;i>=0;i--){
•        buildHeap(array,i,array.length);
•     }
•     return array;
• }
• private static void buildHeap(int[] array, int k, int length) {  //建堆方法
•     // TODO Auto-generated method stub
•     int temp=array[k];
•     for(int i=2*k+1;i<length-1;i=2*i+1){
•        if(array[i]<array[i+1]){
•           i++;
•        }
•        if(temp>=array[i])
•           break;
•        else{
•           array[k]=array[i];
•           k=i;
•        }
•     } 
•        array[k]=temp;
• }
• public static int[] heapSortArray(int[] array){ //进行堆排序
•      array=heapMax(array);  
•     for (int i =array.length-1; i >0; i--) {
•        int temp=array[0];   
•        array[0]=array[i];
•        array[i]=temp;
•        buildHeap(array,0,i);
•     }
•     return array;
• }

 

2.6 归并排序（稳定）

问题描述：对于一个int数组，请编写一个归并排序算法，对数组元素排序。 
问题分析：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。可以看出合并有序数列的效率是比较高的，可以达到O(n)。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

   public int[] mergeSort(int[] A, int n) {

          //归并排序，递归做法，分而治之

           mSort(A,0,n-1);

           return A;

       }

 

       private void mSort(int[] A,int left,int right){

    //分而治之，递归常用的思想，跳出递归的条件

    if(left>=right){

        return;

    }

    //中点

    int mid = (left+right)/2;

    //有点类似后序遍历！

    mSort(A,left,mid);

    mSort(A,mid+1,right);

    merge(A,left,mid,right);

}

//将左右俩组的按序子序列排列成按序序列

private void merge(int[] A,int left,int mid,int rightEnd){

    //充当tem数组的下标

    int record = left;

    //最后复制数组时使用

    int record2 = left;

    //右子序列的开始下标

    int m =mid+1;

    int[] tem = new int[A.length];

    //只要left>mid或是m>rightEnd，就跳出循环

    while(left<=mid&&m<=rightEnd){

        if(A[left]<=A[m]){

            tem[record++]=A[left++];

        }else{

            tem[record++]=A[m++];

        }

    }

    while(left<=mid){

        tem[record++]=A[left++];

    }

    while(m<=rightEnd){

        tem[record++]=A[m++];

    }

    //复制数组

    for( ;record2<=rightEnd;record2++){

        A[record2] = tem[record2];

    }

}

 

2.7 快速排序算法（不稳定）

问题描述：对于一个int数组，请编写一个快速排序算法，对数组元素排序。 
问题分析：快速排序（Quicksort）是对冒泡排序的一种改进，使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

从数列中挑出一个元素，称为”枢轴”（pivot）。重新排序数列，所有元素比枢轴值小的摆放在基准前面，所有元素比枢轴值大的摆在枢轴的后面（相同的数可以到任一边）。

在这个分区结束之后，该枢轴就处于数列的中间位置。这个称为分区（partition）操作。递归地（recursive）把小于枢轴值元素的子数列和大于枢轴值元素的子数列排序。

• public static final void quickSort(int[] array, intstart, intend) {
•        // i相当于助手1的位置，j相当于助手2的位置
•        int i = start, j = end;
•        int pivot = array[i]; // 取第1个元素为基准元素
•        int emptyIndex = i; // 表示空位的位置索引，默认为被取出的基准元素的位置
•        // 如果需要排序的元素个数不止1个，就进入快速排序(只要i和j不同，就表明至少有2个数组元素需要排序)
•        while (i < j) {
•          // 助手2开始从右向左一个个地查找小于基准元素的元素
•          while (i < j && pivot <= array[j])
•            j--;
•          if (i < j) {
•            // 如果助手2在遇到助手1之前就找到了对应的元素，就将该元素给助手1的"空位"，j成了空位
•            array[emptyIndex] = array[emptyIndex = j];
•          }
•           
•          // 助手1开始从左向右一个个地查找大于基准元素的元素
•          while (i < j && array[i] <= pivot)
•            i++;
•          if (i < j) {
•            // 如果助手1在遇到助手2之前就找到了对应的元素，就将该元素给助手2的"空位"，i成了空位
•            array[emptyIndex] = array[emptyIndex = i];
•          }
•        }   
•        // 助手1和助手2相遇后会停止循环，将最初取出的基准值给最后的空位
•        array[emptyIndex] = pivot;
•         
•        // =====本轮快速排序完成=====
•        // 如果分割点i左侧有2个以上的元素，递归调用继续对其进行快速排序
•        if (i - start > 1) {
•          quickSort(array, 0, i - 1);
•        }
•        // 如果分割点j右侧有2个以上的元素，递归调用继续对其进行快速排序
•        if (end - j > 1) {
•          quickSort(array, j + 1, end);
•        }
•      }

 

算法优化：选取基准轴点时采用三数取中法：

public class Quick {

   public void sort(int[] array){

      int start=0;

      int end=array.length-1;

      quickSort(array,start,end);

   }

   public void quickSort(int[] array, int start, int end) {

      // TODO Auto-generated method stub

      int i=start;

      int j=end;

      int emptyIndex=start;

      int pivot=middle3(array,start,end);

      while(i<j){

         while(i<j&&array[j]>=pivot){

            j--;

         }

         if(i<j)

            array[emptyIndex]=array[emptyIndex=j];

         while(i<j&&array[i]<=pivot){

            i++;

         }

         if(i<j)

            array[emptyIndex]=array[emptyIndex=i];

      }

      array[emptyIndex]=pivot;

     

      if(i-start>1)

         quickSort(array,start,i-1);

      if(end-j>1)

         quickSort(array,j+1,end);

   }

 

2.8 计数排序算法（稳定，也是桶排序）

问题描述：对于一个int数组，请编写一个计数排序算法，对数组元素排序。 
问题分析：

1. 提前必须是已知待排序的关键字为整型且范围已知。 
2. 时间复杂度为O(n+k)，n指的是桶的个数，k指的是待排序数组的长度，不是基于比较的排序算法，因此效率非常之高。 
3. 稳定性好，这个是计数排序非常重要的特性，可以用在后面介绍的基数排序中。 
4. 但需要一些辅助数组，如C[0..k]，因此待排序的关键字范围0~k不宜过大。

    public int[] countingSort(int[] A, int n) {

        if(A==null ||n<2){

            return A;

        }

        //找出桶的范围,即通过要排序的数组的最大最小值来确定桶范围

        int min=A[0];

        int max=A[0];

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

            min=Math.min(A[i],min);

            max=Math.max(A[i],max);

        }

        //确定桶数组，桶的下标即为需排序数组的值，桶的值为序排序数同一组值出现的次数

        int[] arr = new int[max-min+1];

        //往桶里分配元素

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

            arr[A[i]-min]++;

        }

        //从桶中取出元素

        int index=0;

        for(int i=0;i<arr.length;i++){

            while(arr[i]-->0){

                A[index++]=i+min;

            }

        }

        return A;

    }

}

 

2.9 基数排序算法（稳定）

问题描述：对于一个int数组，请编写一个基数排序算法，对数组元素排序。 
问题分析：

基数排序（Radix sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。

键字范围0~k不宜过大。

public void sort(int[] array){

      int max=0;

      int d=0;// 位数

      for (int i = 0; i < array.length; i++) {

         max=Math.max(max, array[i]);

      }

      while(max>0){

         max/=10;

         d++;

      }

      int t=0;

      int m=1;

      int n=1;

      int[][] temp=new int[10][array.length];

      int[] order=new int[10];

      while(m<=d){

         for (int i = 0; i < array.length; i++) {

                int k=((array[i]/n)%10);

                temp[k][order[k]++]=array[i];

            }

        

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

            if(order[i]!=0){

                for (int j = 0; j <order[i]; j++) {

                   array[t++]=temp[i][j];

                }

                order[i]=0;

            }

         }

         t=0;

         n=n*10;

         m++;

      }

   }

采用链表的方式来实现基数排序： 

//基数排序开始
public static void radixSort(int[] array){
int max=array[0];
for (int i = 0; i < array.length; i++) {
max=Math.max(max, array[i]);
}
int time=0;
while(max!=0){
time++;
max=max/10;
}
List<List<Integer>> list=new ArrayList<List<Integer>>();
for(int i=0;i<10;i++){
List<Integer> item=new ArrayList<Integer>();
list.add(item);
}

for (int i = 0; i < time; i++) {
for (int j = 0; j < array.length; j++) {
int index=array[j]%(int)Math.pow(10, i+1);
index/=(int)Math.pow(10, i);
list.get(index).add(array[j]);
}
int count=0;
for (List<Integer> a : list) {
for (int m : a) {
if(m!=0){
array[count++]=m;
}
}
a.clear();
}
}
}

//基数排序结束