文章标题

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过k 并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。给定一个int数组A，同时给定A的大小n和题意中的k，请返回排序后的数组。
思路：
1、将0——k-1之间的元素建立小根堆，堆顶则为整个数组的最小值，
2、然后弹出堆顶，将其放在位置0上，然后把原序列的位置k上的数放在小根堆的堆顶，调整小根堆，
3、弹出堆顶，将其放在位置1上，然后把原序列的位置k-1上的数放在小根堆的堆顶，
4、依次重复上述步骤，知道数组排序完毕
每次调整一个数的代价是O(logK)，一共N个数，所以真个的时间复杂度是O(NlogK)

public class 小范围排序 {

    public int[] sortElement(int[] A, int n, int k) {
        if (A == null || n == 0 || n < k) {
            return null;
        }
        int heap[] = buildHeap(A, k);// 完成第一步
        for (int i = k; i < n; i++) {
            A[i - k] = heap[0];// 弹出堆顶，将其放在位置0上
            heap[0] = A[i];// 原序列的位置k上的数放在小根堆的堆顶
            heapify(heap, 0, k);// 调整小根堆

        }
        // 逐步建堆排序结束后，最后还有n-1-k+1到n-1的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[] buildHeap(int A[], int k) {// A是元数组，heap是需要返回的堆
        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) {// 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) {// index为当前节点的位置
        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 temp;
        temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }

}