Реализация алгоритма Дэйкстры, java.util.NoSuchElementException: Underflow Exception

package heap;
 
class DistPar
{
    public int distance;
    public int parentVert;
 
    public DistPar(int pv, int d)
    {
        distance = d;
        parentVert = pv;
    }
}
 
class Vertex
{
    public String label;
    public boolean isInTree;
 
    public Vertex(String lab)
    {
        label = lab;
        isInTree = false;
    }
}
 
class Graph
{
    private final int MAX_VERTS = 10000;
    private final int INFINITY = 1000000;
    private Vertex vertexList[]; // Список вершин
    private int adjMat[][];      // Матрица смежности
    private int nVerts;          // Текущее количество вершин
    private int nTree;           // Количество вершин в дереве
    private int minDists[];      // массив кратчайших расстояний
    private int currentVert;     // Текущая вершина
    private int startToCurrent;  // Расстояние до currentVert
    private BinaryHeap heap;
 
    public Graph()
    {
        vertexList = new Vertex[MAX_VERTS];
        // Матрица смежности
        adjMat = new int[MAX_VERTS][MAX_VERTS];
        nVerts = 0;
        nTree = 0;
        for(int j=0; j<MAX_VERTS; j++)     // Матрица смежности заполняется бесконечными расстояниями
            for(int k=0; k<MAX_VERTS; k++)
                adjMat[j][k] = INFINITY;
    }
 
    public void addVertex(String lab)
    {
        vertexList[nVerts++] = new Vertex(lab);
    }
 
    public void addEdge(int start, int end, int weight)
    {
        adjMat[start][end] = weight;
    }
 
    public void path()
    {
        int startTree = 0;
        vertexList[startTree].isInTree = true;
        nTree = 1;
 
 
        minDists = new int[nVerts];
        for(int i: minDists){
            i = INFINITY;
        }
        // sPath = mindist, INFINITY
        heap = new BinaryHeap(nVerts*nVerts) ;
        heap.insert(0);
        minDists[0]=0;
 
        while(nTree < nVerts)
        {
            int indexMin = getMin();
            int minDist = minDists[indexMin];
 
            if(minDist == INFINITY)     // Если все расстояния бесконечны
            {                           // или уже находятся в дереве,
                System.out.println("Не можем достигнуть вершины");
                break;
            }
            else
            {
                currentVert = indexMin;
                startToCurrent = minDists[indexMin];
            }
            if(vertexList[currentVert].isInTree)
                continue;
            vertexList[currentVert].isInTree = true;
            nTree++;
            adjust_sPath();
        }
 
        displayPaths();                 // Вывод содержимого sPath[]
        nTree = 0;                      // Очистка дерева
        for(int j=0; j<nVerts; j++)
            vertexList[j].isInTree = false;
    }
 
    public int getMin()
    {
            int vertWithMinDist = heap.deleteMin();
            return vertWithMinDist;
    }
    public void adjust_sPath()
    {
 
        int column = 1;
        while(column < nVerts)
        {
            if( vertexList[column].isInTree)
            {
                column++;
                continue;
            }
            int currentToFringe = adjMat[currentVert][column];
            int startToFringe = startToCurrent + currentToFringe;
            int sPathDist = minDists[column];
            if(startToFringe < sPathDist) {
                heap.insert(column);
            }
            column++;
        }
    }
 
    public void displayPaths()
    {
        System.out.println("Тут я зочу красиво выводить результаты");
    }
 
}
 
class PathApp
{
    public static void main(String[] args)
    {
        long startTime = System.currentTimeMillis();
        for(int i=0;i<20;i++){
            Graph theGraph = new Graph();
            theGraph.addVertex("A");     // 0  (старт)
            theGraph.addVertex("B");     // 1
            theGraph.addVertex("C");     // 2
            theGraph.addVertex("D");     // 3
            theGraph.addVertex("E");     // 4
 
            theGraph.addEdge(0, 1, 50);  // AB 50
            theGraph.addEdge(0, 3, 80);  // AD 80
            theGraph.addEdge(1, 2, 60);  // BC 60
            theGraph.addEdge(1, 3, 90);  // BD 90
            theGraph.addEdge(2, 4, 40);  // CE 40
            theGraph.addEdge(3, 2, 20);  // DC 20
            theGraph.addEdge(3, 4, 70);  // DE 70
            theGraph.addEdge(4, 1, 50);  // EB 50
 
            System.out.println("Самый короткий путь:");
            theGraph.path();
        }
        System.out.println((System.currentTimeMillis() - startTime)/20);
 
    }
}

package heap;
 
import java.util.NoSuchElementException;
import java.util.Arrays;
 
class BinaryHeap
{
    /** The number of children each node has **/
    private static final int d = 2;
    private int heapSize;
    private int[] heap;
 
    /** Constructor **/
    public BinaryHeap(int capacity)
    {
        heapSize = 0;
        heap = new int[capacity + 1];
        Arrays.fill(heap, -1);
    }
 
    /** Function to check if heap is empty **/
    public boolean isEmpty( )
    {
        return heapSize == 0;
    }
 
    /** Check if heap is full **/
    public boolean isFull( )
    {
        return heapSize == heap.length;
    }
 
    /** Clear heap */
    public void makeEmpty( )
    {
        heapSize = 0;
    }
 
    /** Function to  get index parent of i **/
    private int parent(int i)
    {
        return (i - 1)/d;
    }
 
    /** Function to get index of k th child of i **/
    private int kthChild(int i, int k)
    {
        return d * i + k;
    }
 
    /** Function to insert element */
    public void insert(int x)
    {
        if (isFull( ) )
            throw new NoSuchElementException("Overflow Exception");
        /** Percolate up **/
        heap[heapSize++] = x;
        heapifyUp(heapSize - 1);
    }
 
    /** Function to find least element **/
    public int findMin( )
    {
        if (isEmpty() )
            throw new NoSuchElementException("Underflow Exception");
        return heap[0];
    }
 
    /** Function to delete min element **/
    public int deleteMin()
    {
        int keyItem = heap[0];
        delete(0);
        return keyItem;
    }
 
    /** Function to delete element at an index **/
    public int delete(int ind)
    {
        if (isEmpty() )
            throw new NoSuchElementException("Underflow Exception");
        int keyItem = heap[ind];
        heap[ind] = heap[heapSize - 1];
        heapSize--;
        heapifyDown(ind);
        return keyItem;
    }
 
    /** Function heapifyUp  **/
    private void heapifyUp(int childInd)
    {
        int tmp = heap[childInd];
        while (childInd > 0 && tmp < heap[parent(childInd)])
        {
            heap[childInd] = heap[ parent(childInd) ];
            childInd = parent(childInd);
        }
        heap[childInd] = tmp;
    }
 
    /** Function heapifyDown **/
    private void heapifyDown(int ind)
    {
        int child;
        int tmp = heap[ ind ];
        while (kthChild(ind, 1) < heapSize)
        {
            child = minChild(ind);
            if (heap[child] < tmp)
                heap[ind] = heap[child];
            else
                break;
            ind = child;
        }
        heap[ind] = tmp;
    }
 
    /** Function to get smallest child **/
    private int minChild(int ind)
    {
        int bestChild = kthChild(ind, 1);
        int k = 2;
        int pos = kthChild(ind, k);
        while ((k <= d) && (pos < heapSize))
        {
            if (heap[pos] < heap[bestChild])
                bestChild = pos;
            pos = kthChild(ind, k++);
        }
        return bestChild;
    }
 
    /** Function to print heap **/
    public void printHeap()
    {
        System.out.print("\nHeap = ");
        for (int i = 0; i < heapSize; i++)
            System.out.print(heap[i] +" ");
        System.out.println();
    }
}