小范围排序 --使用堆排序

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过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)