排序问题思考（要求时间和空间复杂度尽可能的低）【Part 1】

题目：

有一个无序整型数数组，如何求出这个数组排序后的任意两个相邻元素的最大差值？要求时间和空间复杂度尽可能低。（例如：无序数组 2、3、1、4、6，排序后是1、2、3、4、6，最大差值是 6-4=2）

解题思路分析：

用一种较快的稳定排序算法（比如归并算法，时间复杂度N*logN）给原数组排序，然后遍历排好序的数组，每两个相邻元素求差，最终得到最大差值。 

该解法的时间复杂度是O（N*logN），在不改变原数组的情况下，空间复杂度是O（N）。

但是，这个题的本意，其实不是纯粹的排序问题

要处理这个问题，可以从要求上出发考虑，即什么排序算法的时间复杂度比O（N*logN）还要低？ 嗯，从这点出发，似乎可以找到答案，回顾排序算法，比归并算法还要快的，是计数排序以及桶排序算法了。

那下面，就先从计数排序开始分析：

1.利用计数排序的思想，先求出原数组的最大值Max与最小值Min的区间长度k（k=Max-Min+1）。 

2.创建一个长度为k的新数组Array。 

3.遍历原数组，把原数组每一个元素插入到新数组Array对应的位置，比如元素的值为n，则插入到Array[n-min]当中。此时Array的部分位置为空，部分位置填充了数值。 

4.遍历新数组Array，统计出Array中最大连续出现空值的次数+1，即为相邻元素最大差值。

例如给定无序数组 { 2、6、3、4、5、10、9 }，处理过程如下图：

该解法的时间复杂度为O（n+k），空间复杂度同样是O（n+k）。

下面看看其java代码实现过程：

/**
 * @author "shihuc"
 * @date   2017年1月11日
 */
package jishuSort;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @author chengsh05
 *
 */

class MaxMin {
    int max;
    int min;
    /**
     * @return the max
     */
    public int getMax() {
        return max;
    }
    /**
     * @param max the max to set
     */
    public void setMax(int max) {
        this.max = max;
    }
    /**
     * @return the min
     */
    public int getMin() {
        return min;
    }
    /**
     * @param min the min to set
     */
    public void setMin(int min) {
        this.min = min;
    }
}

public class Algorithm {

    /**
     * @param args 
     */
    public static void main(String[] args) {
        
        File file = new File("./src/jishuSort/sample.txt");
        Scanner sc = null;
        try {
            sc = new Scanner(file);
            int N = sc.nextInt();
            for(int i=0; i<N; i++){
                int S = sc.nextInt();
                int data[] = new int[S];
                for(int j=0; j<S; j++){
                    data[j] = sc.nextInt();
                }
                MaxMin mm = getMaxMin(data);
                int mArr[] = getMinusArray(data, mm);
                int minus = getTarget(mArr, mm.getMin() - 1);
                System.out.println(i + " -- >  " + minus);                
            }            
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if(sc != null){
                sc.close();
            }
        }        
    }
    
    /**
     * 在时间复杂度为O(n)情况下，计算出最大值与最小值
     * 
     * @param da
     * @return
     */
    public static MaxMin getMaxMin(int da[]){
        MaxMin mm = new MaxMin();
        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;
        for(int i=0; i<da.length; i++){
            if(da[i] > max){
                max = da[i];
            }
            if(da[i] < min){
                min = da[i];
            }
        }
        
        mm.setMax(max);
        mm.setMin(min);
        return mm;
    }
    
    /**
     * 获取最大值与最小值之间的距离 k
     * 
     * @param mm
     * @return k
     */
    public static int getDistance(MaxMin mm){
        return mm.getMax() - mm.getMin() + 1;
    }
    
    /**
     * 获取差值数组，即原数组中的每个数与最小值的差值位置处放置原数组的元素
     * 
     * @param da 原数组
     * @param mm 最大最小值对象
     * @return 差值数组
     */
    public static int[] getMinusArray(int da[], MaxMin mm){
        int K = getDistance(mm);
        int min = mm.getMin();
        
        int minusArray[] = new int[K];
        //将数组初始化为全mm.getMin() - 1的值， 假设，这里的mm.getMin()比Integer.MIN_VALUE大，自己分析
        Arrays.fill(minusArray, mm.getMin() - 1); 
        
        for(int i=0; i<da.length; i++){
            int n = da[i];
            minusArray[n - min] = n; 
        }
        
        return minusArray;
    }
    
    /**
     * 找出连续出现空值的最大个数,注意，是两个数之间的差距，所以，最后要补加一个1    
     * 
     * @param minusArr
     * @param empty
     * @return
     */
    public static int getTarget(int minusArr[], int empty){
        int size = 0;
        int temp = 0;
        for(int i=0; i<minusArr.length; i++){
            if(minusArr[i] == empty){
                temp++;
            }else{
                if(temp > size){
                    size = temp;                    
                }
                temp = 0;
            }
        }
        return size + 1;
    }
}

附加程序中用到的测试数据sample.txt：

2
7
2 6 3 4 5 10 9
5
2 3 1 4 6

数据中第一行，表示有多少个测试案例，后续每两行表示一个测试里，上一行是测试数组元素个数，下一行表示数组元素的内容。

测试运行后的结果如下：

0 -- >  3
1 -- >  2

今天，就只说到这里吧，仅仅将计数排序实现了下，里面有个注意的地方，就是如何判断差值数组的内容是空，请读者自行分析。

后续将补充桶排序的实现方案！