堆排序

import java.util.Arrays;

public class Heap {

    private int limit;
    private int[] arr;
    private int size;

    public Heap(int limit) {
        this.limit = limit;
        this.arr = new int[limit];
        this.size = 0;
    }

    public Heap(int[] arr) {
        this.limit = arr.length;
        this.arr = arr;
        this.size = arr.length;
    }

    private void swap(int a, int b) {
        if (a == b) {
            return;
        }
        arr[a] = arr[a] ^ arr[b];
        arr[b] = arr[a] ^ arr[b];
        arr[a] = arr[a] ^ arr[b];
    }

    public int left(int index) {
        return index << 1 | 1;
    }

    public int right(int index) {
        return (index + 1) << 1;
    }

    public int parent(int index) {
        return (index - 1) >> 1;
    }

    public void push(int ele) {
        if (isFull()) {
            throw new RuntimeException("堆满了");
        }
        arr[size] = ele;
        heapifyUp(size++);
    }

    public void heapifyUp(int index) {
        int parent;
        while (index != 0) {
            parent = parent(index);
            if (arr[index] > arr[parent]) {
                swap(index, parent);
                index = parent;
            } else {
                break;
            }
        }
    }

    public void heapifyDown(int index) {
        int left, right;
        while (index < size && (left = left(index)) < size) {
            int maxIndex = index;
            if (arr[left] > arr[maxIndex]) {
                maxIndex = left;
            }
            if ((right = right(index)) < size && arr[right] > arr[maxIndex]) {
                maxIndex = right;
            }
            if (maxIndex == index) {
                break;
            }
            swap(index, maxIndex);
            index = maxIndex;
        }
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("堆空了");
        }
        int ele = arr[0];
        swap(0, --size);
        heapifyDown(0);
        return ele;
    }

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

    public boolean isFull() {
        return size == limit;
    }

    public static void main(String[] args) {
        System.out.println("test begin");
        int maxValue = 1000;
        for (int i = 0; i < 100000; i++) {
            int len = HeapSort.generateRandomLen(100);
            int[] arr = HeapSort.generateRandomArray(len, maxValue);
            int[] copy = Arrays.copyOf(arr, arr.length);
            HeapSort.sort(copy);
            Arrays.sort(arr);
            if (!HeapSort.isRight(arr, copy)) {
                System.out.println("失败了");
            }
        }
        System.out.println("test finish");
    }
}

class HeapSort {

    public static boolean isRight(int[] a, int[] b) {
        if (a == null) {
            return b == null;
        }
        if (b == null) {
            return false;
        }
        if (a.length != b.length) {
            return false;
        }
        for (int i = 0; i < a.length; ++i) {
            if (a[i] != b[i]) {
                return false;
            }
        }
        return true;
    }

    public static int[] generateRandomArray(int len, int maxValue) {
        int[] res = new int[len];
        for (int i = 0; i != res.length; i++) {
            res[i] = (int) (Math.random() * maxValue);
        }
        return res;
    }

    public static int generateRandomLen(int limit) {
        return (int) (Math.random() * limit + 1);
    }

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }

        // O(n)
        Heap heap = new Heap(arr);
        for (int i = heap.parent(arr.length - 1); i >= 0; --i) {
            heap.heapifyDown(i);
        }

        // O(n*logn)
//        Heap heap = new Heap(arr.length);
//        for (int i = 0; i < arr.length; ++i) {
//            heap.push(arr[i]);
//        }

        for (int i = arr.length - 1; i >= 0; --i) {
            arr[i] = heap.pop();
        }
    }
}