特殊排序

十大经典排序算法
9 种经典排序算法可视化动画
特殊排序 - O(n)
• 计数排序（Counting Sort）
计数排序要求输入的数据必须是有确定范围的整数。将输入的数据值转化为键存
储在额外开辟的数组空间中；然后依次把计数大于 1 的填充回原数组

• 桶排序（Bucket Sort）
桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有
限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式
继续使用桶排序进行排）。

• 基数排序（Radix Sort）
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类
推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按
高优先级排序。

function countingSort(arr, maxValue) {
    var bucket = newArray(maxValue + 1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;
 
    for(var i = 0; i < arrLen; i++) {
        if(!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }
 
    for(var j = 0; j < bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }
 
    return arr;
}

合并区间,有效的字母异位词,翻转对
493. 翻转对

给定一个数组 nums ，如果 i < j 且 nums[i] > 2*nums[j] 我们就将 (i, j) 称作一个重要翻转对。
你需要返回给定数组中的重要翻转对的数量。
示例 1:
输入: [1,3,2,3,1]
输出: 2
示例 2:
输入: [2,4,3,5,1]
输出: 3
注意:
给定数组的长度不会超过50000。
输入数组中的所有数字都在32位整数的表示范围内。

/* mergeSort 整体分为三部分:
调进来一开始一分为二,左右部分分别调用mergeSort来统计它的重要翻转对
加到cnt中,且左右两部分已排好序了
接下来单独一个循环统计
左右两个序列之间的重要逆序对
最后再进行一次归并
*/
public class Solution {
	public int reversePairs(int[] nums) {
		return mergeSort(nums, 0, nums.length - 1);
	}
	private int mergeSort(int[] nums, int s, int e) {
		 if (s >= e) return 0;
		 int mid = s + (e - s)/2;
		 int cnt = mergeSort(nums, s, mid) + mergeSort(nums, mid+1, e);
		 for (int i = s, j = mid + 1; i <= mid; i++) {
		 	while(j <= e && nums[i]/2.0 > nums[j]) j++;
		 	cnt += j - (mid + 1);
		 }
		 // 上面只是统计重要翻转对个数,它不会进行归并
		 /*  下面就是归并但是偷懒了,直接sort了下
		 Arrays.sort(int[] a, int fromIndex, int toIndex)
		这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序，
		注意：下标为toIndex的元素不参与排序！
		 */
		 Arrays.sort(nums, s, e+1);
		 return cnt;
	}
}

public int ret;
public int reversePairs(int[] nums) {
	ret = 0;
	mergeSort(nums, 0, nums.length - 1);
	return ret;
}
public void mergeSort(int[] nums, int left, int right) {
	if (right <= left) {
		return;
	}
	int middle = left + (right - left) / 2;
	mergeSort(nums, left, middle);
	mergeSort(nums, middle+1, right);

	// count elements
	int count = 0;
	for (int l = left, r = middle + 1; l <= middle;) {
		if (r > right || (long)nums[l] <= 2 *(long)nums[r]) {
			l++;
			// 把之前统计的count加上
			ret += count;
		}else {
			r++;
			count++; // 累加
		}
	}
	Arrays.sort(nums, left, right + 1);
}

这段代码是最好的.

public int reversePairs(int[] nums) {
	if (nums == null || nums.length == 0) return 0;	
	return mergeSort(nums, 0, nums.length - 1);
}
public int mergeSort(int[] nums, int left, int right) {
	if (right <= left) {
		return 0;
	}
	int middle = left + (right - left) / 2;
	int count = mergeSort(nums, left, middle) + mergeSort(nums,  middle + 1, right);
	int[] cache = new int[right - left + 1];
	int i = left, t = left, c = 0;
	for (int j = mid + 1; j <= right; j++,c++) {
		while(i <= middle &&nums[i] <= 2 *(long)nums[j]) i++;
		while( t <= middle && nums[t] < nums[j]) cache[c++] = nums[t++];
		cache[c] = nums[j];
		count += middle - i + 1;
	}
	while (t <= mid) cache[c++] = nums[t++];
	System.arraycopy(cache, 0, nums, left, right - left + 1);
	return count;

	
}