堆排序

    public void heapInsert(int[] arr, int i) {
        while (arr[(i - 1) / 2] < arr[i]) {
            swap(arr, (i - 1) / 2, i);
            i = (i - 1) / 2;
        }
    }

    public void heapify(int[] arr, int i, int size) {
        int left = 2 * i + 1;
        while (left < size) {
            int maxIndex = left + 1 < size && arr[left] < arr[left + 1] ? left + 1 : left;
            if (arr[maxIndex] > arr[i]) {
                swap(arr, i, maxIndex);
                i = maxIndex;
                left = 2 * i + 1;
            } else {
                break;
            }
        }
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public void sort(int[] arr) {
        if (arr.length <= 1) {
            return;
        }
        int i = 0;
        while (i < arr.length) {
            heapInsert(arr, i++);
        }
        i = arr.length - 1;
        do {
            swap(arr, 0, i);
            heapify(arr, 0, i--);
        } while (i >= 0);
    }

数组 arr, 小规模有序，即某个数的位置，排序后的位置不会相差 K的距离

可以利用小根堆实现

public class Heap<T extends Comparator<Integer>> {
    int[] arr;
    int size;
    Comparator<Integer> comparable;

    public Heap(int size, Comparator<Integer> comparable) {
        arr = new int[size];
        this.comparable = comparable;
    }

    public int getSize() {
        return this.size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void push(int v) {
        if (size >= arr.length) {
            throw new RuntimeException("满了！");
        }
        arr[size] = v;
        heapInsert();
        size++;
    }

    public int pop() {
        if (size == 0) {
            throw new RuntimeException("空了！");
        }
        int v = arr[0];
        swrap(arr, 0, --size);
        heapify();
        return v;
    }

    private void heapInsert() {
        int i = size;
        while (comparable.compare(arr[(i - 1) / 2], arr[i]) > 0) {
            swrap(arr, (i - 1) / 2, i);
            i = (i - 1) / 2;
        }
    }

    private void heapify() {
        int i = 0, left = 2 * i + 1;
        while (left < size) {
            int maxIdx = left + 1 < size && comparable.compare(arr[left], arr[left + 1]) > 0 
            ? left + 1 : left;
            if (comparable.compare(arr[i], arr[maxIdx]) > 0) {
                swrap(arr, i, maxIdx);
                i = maxIdx;
                left = 2 * i + 1;
            } else {
                break;
            }
        }
    }

    private void swrap(int[] arr, int i, int i1) {
        int temp = arr[i];
        arr[i] = arr[i1];
        arr[i1] = temp;
    }

}


    public void sort2(int[] arr, int K) {
        Heap<Comparator<Integer>> heap = new Heap<>(K, Comparator.comparingInt(a -> a));
        int i = 0, index = 0; 
        while (i < arr.length) {
            heap.push(arr[i++]);
            if (heap.getSize() == K) {
                arr[index++] = heap.pop();
            }
        }
        while (!heap.isEmpty()) {
            arr[index++] = heap.pop();
        }
    }