打印索引和数组java的新索引

Question

所以我的代码几乎完成了，我只需要一种打印索引的方法，当我重组我的堆时，打印出原始索引但是在新的位置。我的堆被组织为打印出最小值但是当我尝试打印出索引时，我只打印出新索引。

这是我的java代码

import java.util.*;
import java.util.Scanner;
import java.util.Arrays;
import java.util.NoSuchElementException;

/** Class BinaryHeap **/
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];
    newID(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()
{
    for (int i = 0; i < heapSize; i++){
        System.out.print(heap[i] +" ");
        printID(i);
    }
    System.out.println();
}

public void printID(int i)
{
    System.out.println("Sequence ID: " + (i+1));
} 
public void newID(int i)
{
    int x = i;
}  
 public void printnewID(int i)
{
    System.out.println("Sequence ID: " + (i+1));
}       
}

/** Class BinaryHeapTest **/
public class BinaryHeapTest
{
public static void main(String[] args)
{
    System.out.println("Binary Heap Test\n\n");
    /** Make object of BinaryHeap **/
    BinaryHeap bh = new BinaryHeap(101);  
    BinaryHeap bh2 = new BinaryHeap(101);          

    int check = 0;
    int[] array = new int[100]; //Make 100 numbers
    int[] ID = new int[100]; // ID array
    Random rng = new Random();
    for(int i= 0; i < array.length; i++){
        ID[i] = (i + 1);
        array[i] = rng.nextInt(39);
        bh.insert(array[i]);
        check++;
    }
    System.out.println("Heap 1 : ");    
    bh.printHeap();
    System.out.println("Number of heap values = " + check);
    for (int j = 1; j <= 100; j++){
       bh2.insert(bh.deleteMin());
    }
    System.out.println("Heap 2 : ");    
    bh2.printHeap();            
}
}