十大经典排序算法
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;
}