线性时间的排序算法--桶排序(以leetcode164. Maximum Gap为例讲解)

前言

   在比较排序的算法中，快速排序的性能最佳，时间复杂度是O(N*logN).因此，在使用比较排序时，时间复杂度的下限就是O(N*logN)。而桶排序的时间复杂度是O(N+C)，因为它的实现并不是基于比较实现的，而是基于映射函数实现的。

桶排序

    桶排序工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序)。

   桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。

时间复杂度和空间复杂度分析

    对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：

               O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)

    当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。

 

    空间负载度：O(N+M)

 

下面以leetcode164. Maximum Gap为例具体讲解桶排序的实现

   题目要求：

   Given an unsorted array, find the maximum difference between the successive elements in its sorted form.

   Try to solve it in linear time/space.  //题目要求我们使用线性的时间

   Return 0 if the array contains less than 2 elements.

   You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.

解题思路：

  首先对数组进行桶排序，然后找出最大的gap。

  首先明确，最大的gap肯定是后桶的最小值减去前桶的最大值，注意此处说的桶均为有效桶，即不包括空桶。

  因此无需进行桶内排序，仅需记录每个有效桶的最大值和最小值即可。

  为何最大的gap肯定是后桶的最小值减去前桶的最大值？

  假设有数组x[1...n]，其中最大的元素为max，最小元素为min，将左闭右开的实数区间[min，max)划分为n-1个等长的子区间（桶），每个子区间也是左闭右开的，我们用len来表示每个子区间的长度。除去max和min，剩下的n-2个数，每个数都属于其中一个桶。对于同一个桶的两个数，因为桶是左闭右开的，所以他们的距离肯定是小于len的。然后，关键的一点是，n-2个数放进n-1个桶，由抽屉原理可以知道，肯定有一个桶是空的，所以，距离最远的相邻的两个数，肯定是属于两个不同的桶。于是，我们可以把每个桶都扫描一次，相邻最远的两个数，必定其中一个是某个桶里的最大值，另一个是另一个桶里的最小值。

代码：

public class Solution {
  public int maximumGap(int[] num) {
      if(num == null || num.length<2){
          return 0;
      }
      int maxval = Integer.MIN_VALUE;
      int minval = Integer.MAX_VALUE;
      //求解数组最值
      for(int i=0; i<num.length; i++){
          if(num[i]>maxval) maxval = num[i];
          if(num[i]<minval) minval = num[i];
      }
      
      //数组内的元素值相同
      if(minval==maxval){
          return 0;
      }
      
      //数组仅有两个元素
      if(num.length==2){
          return maxval-minval;
      }
      
      int len = (int)Math.ceil((double)(maxval-minval)/(num.length-1));  //求解桶间差值,向上取整
      int n = (maxval-minval)/len;
      
      int maxBuk[] = new int[n+1];
      int minBuk[] = new int[n+1];
      
      Arrays.fill(maxBuk,Integer.MIN_VALUE);
      Arrays.fill(minBuk,Integer.MAX_VALUE);
      
      //桶映射
      for(int val:num){
          int temp = (val-minval)/len;
          maxBuk[temp] = Math.max(val,maxBuk[temp]);
          minBuk[temp] = Math.min(val,minBuk[temp]);
      }
      
      //求解最大gap,最大差值位于后桶的min-前桶的max
      int gap = 0;
      int pre = maxBuk[0];
      for(int i=1; i<=n; i++){
          if(maxBuk[i]==Integer.MIN_VALUE && minBuk[i]==Integer.MAX_VALUE){  //忽略空桶
              continue;
          }
          gap = Math.max(gap,minBuk[i]-pre);
          pre = maxBuk[i];
      }
      
      return gap;
      
      
  }
}