已知一个几乎有序的数组,几乎有序是指,如果把数组排好顺序的话,每个元素移动的距离可以不超过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]
分析:每个元素的距离不超过k,直觉上肯定先想到插入排序,每个元素插入访问不超过k个元素,n个元素时间复杂度为O(N*K)。
更好的办法是堆排序,我们维护一个大小为k的最小堆,先将A[0]~A[k-1]放入堆heap中调整,则heap[0]就是最小值,这个元素就可以被排除出堆,放在A[0]位置。
然后把A[k]加入最小堆,继续调整,最小值放在A[1],然后排除A[1],再加入A[k+1],重复操作,直到最后一个元素。
这时,数组中最后k个元素仍然是没有排序的,这时对他们使用堆排序即可。不过同样是用最小堆的排序,注意--k,因为元素在不断减小。
代码如下:
class ScaleSort {
public:
vector<int> sortElement(vector<int> A, int n, int k) {
if(A.size() > 0 && n > 0 && k > 0 && n >= k)
heap_dispose(A, n, k);
return A;
}
private:
void heap_dispose(vector<int>& A, const int size, int k){
vector<int> heap(k); //注意预先分配空间,不然会段错误
std::copy_n(A.begin(), k, heap.begin());
for(int i=(k>>1)-1; i>=0; --i)
sift_down(heap, i, k);
for(int i=k; i<size; ++i){
A[i-k] = heap[0]; //A[k-k] = A[0]
heap[0] = A[i];
sift_down(heap, 0, k);
}
for(int i=size-k; i<size; ++i){ //当k=0是,i=size
A[i] = heap[0];
std::swap(heap[0], heap[k-1]);
sift_down(heap, 0, --k);
}
}
int left_child(int i) {
return i * 2 + 1;
}
void sift_down(vector<int>& heap, int i, const int size){
int child, temp = heap[i];
for(child=i; left_child(i)<size; i=child){
child = left_child(i);
if(child != size-1 && heap[child] > heap[child+1])
++child;
if(temp > heap[child])
heap[i] = heap[child];
else
break;
}
heap[i] = temp; //注意是i
}
};
要注意的是,最后是heap[i] = temp,写成heap[child] = temp就等着排错吧。
这里顺便提一下std::copy和std::copy_n函数,它们只负责复制,不会申请空间,提防段错误:
std::copy:
std::copy(start, end, std::back_inserter(container));
std::copy(start, end, container.begin());
std::copy_n:
OutputIterator copy_n (InputIterator first, Size n, OutputIterator result)