已知一个几乎有序的数组,几乎有序是指,如果把数组排好顺序的话,每个元素移动的距离可以不超过k,并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。
给定一个int数组A,同时给定A的大小n和题意中的k,请返回排序后的数组。
测试样例:
[2,1,4,3,6,5,8,7,10,9],10,2
返回:[1,2,3,4,5,6,7,8,9,10]
分析:<1>首先分析时间复杂度为O(n)的排序算法,其中有计数排序、基数排序,但是考虑到该题是不基于比较的排序算法的限制,不适用;<2>其次时间复杂度为O(n*n)的排序算法:冒泡排序和选择排序,这两个排序算法与数组原始序列无关,插入排序,插入排序的过程与原始顺序有关,每个元素移动距离不超过K,所以说对于本题来说,插入排序O(N*K)就可以实现排序;<3>其次再看看时间复杂度为O(N*logN)的排序算法:快速排序,与数组原始顺序无关,其主要是随机的选择一个数,然后以这个数对数组进行划分,划分出来的两个部分再次进行递归;归并排序,与数组原始顺序无关,把所有组打散,然后小组合大组,大组继续合并,直到为一组;<4>最后我们分析改进后的堆排序来实现本题,由于数组移动位置不超过k,我们可以将数组a[0]-a[k-1]选做一个小根堆,然后进行堆排序,找出0-(k-1)中的最小值,并弹出,然后在将a[1]-a[k]进行最小值的弹出,依次进行堆排序,直到该数组有序,由于每次进行堆排序的时间复杂度为logK,一共有n个数,所以说改进后的堆排序时间复杂度为O(n*logK).
实现代码:
package 直通BAT面试算法题;
public class ScaleSort {
public int[] sortElement(int[] A, int n, int k) {
if (A == null || A.length == 0 || n < k) {
return A;
}
//从数组中取出前k个数组成小根堆
int[] heap = getKHeap(A, k);
//对k个数进行小根堆堆排序
for (int i = k; i < n; i++) {
A[i - k] = heap[0];
heap[0] = A[i];
heapify(heap, 0, k);
}
//添加一个数
for (int i = n - k; i < n; i++) {
A[i] = heap[0];
swap(heap, 0, k - 1);
heapify(heap, 0, --k);
}
return A;
}
public int[] getKHeap(int[] A, int k) {
int[] heap = new int[k];
for (int i = 0; i < k; i++) {
heapInsert(heap, A[i], i);
}
return heap;
}
//创建小根堆
public void heapInsert(int[] heap, int value, int index) {
heap[index] = value;
while (index != 0) {
int parent = (index - 1) / 2;
if (heap[parent] > heap[index]) {
swap(heap, parent, index);
index = parent;
} else {
break;
}
}
}
public void heapify(int[] arr, int index, int heapSize) {
int left = index * 2 + 1;
int right = index * 2 + 2;
int smallest = index;
while (left < heapSize) {
if (arr[left] < arr[index]) {
smallest = left;
}
if (right < heapSize && arr[right] < arr[smallest]) {
smallest = right;
}
if (smallest != index) {
swap(arr, smallest, index);
} else {
break;
}
index = smallest;
left = index * 2 + 1;
right = index * 2 + 2;
}
}
public void swap(int[] arr, int index1, int index2) {
int tmp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = tmp;
}
}