Реализация HeapSort имеет исключение NullPointerException

Question

У меня проблемы с реализацией HeapSort.По сути, я не знаю, как исправить мой IndexOutOfBoundsExcpetion.У меня есть не только класс HeapSort в файле, но и класс MinHeap.Скажите мне, если я должен добавить часть другого файла, где основной метод.Я использую счетчик для подсчета ключевых сравнений.Поскольку меня попросили, я добавляю основной метод внизу.

public class HeapSort {

    int[] heap;
    int size;
    int count;

    public HeapSort(int[] arr, int n, int counter) {
        this.heap = arr;
        this.size = n;
        this.count = counter;
    }

    public int[] buildHeap(int[] arr) {
        int[] build = new int[size];
        for (int i = 0; i < size; ++i) {
            build[i] = arr[i];
            if (!MinHeap.isHeap(build)) {
                int[] newBuild = new int[build.length];
                newBuild = MinHeap.restoreHeap(i);
                build = newBuild;
                count();
            }
        }
        return build;
    }

    //arr is already a Heap
    public int[] sort(int[] arr) {
        int[] sorted = new int[size];
        int val = size;
        for (int i = 0; size > 0; ++i) {
            int[] newArr = new int[--size];
            for (int j = 1; j < size; ++j) newArr[j - 1] = arr[j];
            arr = newArr;
            sorted[i] = MinHeap.pop();
            MinHeap.restoreHeap(0);
            count();
        }
        size = val;
        return sorted;
    }

    public void count() {
        ++count;
    }

    @Override
    public String toString() {
        int arr[] = buildHeap(heap);
        int[] array = sort(arr);
        String str = "[";
        for (int i = 0; i < size - 1; ++i) str += array[i] + ", ";
        return str += array[size - 1] + "]";
    }
}

class MinHeap {
    static int[] heap;
    static int size = 0;

    public MinHeap() {
        heap = new int[size];
    }

    static int[] restoreHeap(int index) {
        // TODO Auto-generated method stub
        int v; // current node
        int l; // child child
        int r; //right child
        while (2 * index + 1 < size) {
            v = heap[2 * index];
            l = heap[2 * index + 1];
            if (2 * index + 2 < size) r = heap[2 * index + 2];
            else r = 0;
            if (compare(l, v) || compare(r, v)) {
                //Swap with left child
                if (compare(l, r)) {
                    swap(index, index * 2 + 1);
                    index = index * 2 + 1;
                }
                //Swap with right child
                else if (compare(r, l)) {
                    swap(index, index * 2 + 2);
                    index = index * 2 + 2;
                }
            }
            else break;
        }
        return heap;
    }

    static void swap(int v1, int v2) {
        int tmp = v1;
        v1 = v2;
        v2 = tmp;
    }

        //Remove the first element
    static int pop() {
        int min = heap[0];
        heap[0] = heap[--size];
        heap = restoreHeap(0);
        return min;
    }

    static boolean compare(int left, int right) {
        return left < right;
    }

    static boolean isHeap(int[] arr) {
        // TODO Auto-generated method stub
        int v = 0;
        while (2 * v + 1 < size) {
            if (2 * v + 2 < size) {
                if (arr[v] > arr[2 * v + 1] || arr[v] > arr[2 * v + 2]) return false;
            } else if (arr[v] > arr[2 * v + 1]) return false;
            v *= 2;
        }
        return true;
    }

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

Основной метод (в другом файле):

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) arr[i] = scanner.nextInt();
        int[] sort = sorted.sort(arr);
        HeapSort sortHeap = new HeapSort(arr, n, 0);
        int[] toSort = sortHeap.buildHeap(arr);
        sort = sortHeap.sort(toSort);
        int count = sortHeap.count;
        if (count != 1) System.out.print("Heap Sort needed " + count + " key 
        comparisons for sorting the array to: ");
        else System.out.print("Heap Sort needed " + count + " key comparison for 
        sorting the array to: ");
        System.out.println(sortHeap.toString());
        scanner.close();
    }
}