桶排序

桶排序是非基于比较的排序，它是一个非常大的概念。他的思想是准备一些有序的桶，把数据放在桶里面。例如输入n个0-1000大小的数，那就准备1001个桶，每个桶放的是每个数出现的次数，这样就可以不用比较就能排好序了。下面介绍一个关于桶的经典的算法。时间复杂度O(N),额外空间复杂度O(N)。

给定一个数组,求如果排序之后,相邻两数的最大差值,要求时间复杂度O(N),且要求用非基于比较的排序。

解题思路：如果有n个数，就准备n + 1个桶，把最小值放第一个桶，最大值放最后一个桶，其他的数按等同划分放中间的桶内。桶内记录放在桶内的最大值，最小值和是否放入数，这样至少会有一个桶内是没有数的，那么就可以得出，相邻两数最大差值是不可能在同一个桶内的，那么最大差值就在前一个有数据的桶内的最大值和下一个最近的有数据的最小值之间的差的集合内，这样就求出相邻两数的最大差值了。

以下是代码：

public class maxGap {
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			if (maxGap(arr1) != comparator(arr2)) {
				succeed = false;
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
	}
	//找出相邻相差最大值
	public static int maxGap(int[] nums) {
		if(nums == null || nums.length < 2) {
			return 0;
		}
		int len = nums.length;
		int min = Integer.MAX_VALUE;
		int max = Integer.MIN_VALUE;
		//获取数组中的最大值和最小值
		for(int i = 0; i < len; i++) {
			min = Math.min(min, nums[i]);
			max = Math.max(max, nums[i]);
		}
		if(min == max) {
			return 0;
		}
		//创建桶，为是否有数，最大值和最小值
		boolean[] hasNum = new boolean[len + 1];
		int[] maxs = new int[len + 1];
		int[] mins = new int[len + 1];
		//桶的位置
		int bid = 0;
		//确定每个桶里是否有数，最大值和最小值
		for(int i = 0; i < len; i++) {
			bid = bucket(nums[i], len, min, max);
			mins[bid] = hasNum[bid] ? Math.min(mins[bid], nums[i]) : nums[i];
			maxs[bid] = hasNum[bid] ? Math.max(maxs[bid], nums[i]) : nums[i];
			hasNum[bid] = true;
		}
		int res = 0;
		int lastMax = maxs[0];
		int i = 1;
		for(; i <= len; i++) {
			if(hasNum[i]) {
				res = Math.max(res,  mins[i] - lastMax);
				lastMax = maxs[i];
			}
		}
		return res;
	}
	//确定数所在桶的位置
	public static int bucket(long num, long len, long min, long max) {
		return (int) ((num - min) * len / (max - min));
	}
	//以下代码是对数器的代码
	//设计一个简单的正确的排序
	public static int comparator(int[]nums) {
		if (nums == null || nums.length < 2) {
			return 0;
		}
		Arrays.sort(nums);
		int gap = Integer.MIN_VALUE;
		for (int i = 1; i < nums.length; i++) {
			gap = Math.max(nums[i] - nums[i - 1], gap);
		}
		return gap;
	}
	//获取随机的数组
	public static int[] generateRandomArray(int maxSize,int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		//取值为-maxValue到+maxValue
		for(int i = 0; i < arr.length; i++) {
				arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}
	//复制数组
	public static int[] copyArray(int[] arr) {
		if(arr == null) {
			return null;
		}
		int [] res = new int[arr.length];
		for(int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}
	//比较数组是否相等
	public static boolean isEqual(int[]arr1, int[] arr2)  {
		if((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if(arr1 == null && arr2 == null) {
			return true;
		}
		if(arr1.length != arr2.length) {
			return false;
		}
		for(int i = 0; i < arr1.length; i++) {
			if(arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}
	//打印出排序的数组
	public static void printArray(int[] arr) {
		if(arr == null) {
			return;
		}
		for(int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}
}