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

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

这是我的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();            
}
}

import java.util.*；
导入java.util.Scanner；
导入java.util.array；
导入java.util.NoSuchElementException；
/**类二进制堆**/
类二进制堆
{
/**每个节点具有的子节点数**/
专用静态最终整数d=2；
私人治疗；
私有int[]堆；
/**建造商**/
公共二进制堆（int容量）
{
heapSize=0；
堆=新整数[容量+1]；
数组。填充（堆，-1）；
}
/**函数检查堆是否为空**/
公共布尔值为空（）
{
返回heapSize==0；
}
/**检查堆是否已满**/
公共布尔值已满（）
{
返回heapSize==heap.length；
}
/**清除堆*/
公共void makeEmpty（）
{
heapSize=0；
}   
/**函数获取i的索引父级**/
私有整数父级（整数i）
{
返回（i-1）/d；
}
/**函数获取i的第k个子项的索引**/
私人智力测验（智力i，智力k）
{
返回d*i+k；
}
/**插入元素的函数*/
公共空白插入（int x）
{
if（isFull（））
抛出新的NoTouchElementException（“溢出异常”）；
/**渗透**/
堆[heapSize++]=x；
heapifyUp（heapSize-1）；
}
/**查找最小元素的函数**/
公共int findMin（）
{
if（isEmpty（））
抛出新的NoTouchElementException（“下溢异常”）；
返回堆[0]；
}
/**删除最小元素的函数**/
公共int deleteMin（）
{
int-keyItem=heap[0]；
newID（0）；
删除（0）；
返回键项；
}
/**函数删除索引中的元素**/
公共整数删除（整数索引）
{
if（isEmpty（））
抛出新的NoTouchElementException（“下溢异常”）；
int-keyItem=heap[ind]；
heap[ind]=堆[heapSize-1]；
医治--；
heapifyDown（ind）；
返回键项；
}
/**函数heapifyUp**/
私有空堆堆（int childInd）
{
int tmp=堆[childInd]；
而（childInd>0&&tmpwhile（（k）也许您可以提供您得到的输出与您想要的输出的示例？printnewID（）似乎什么都没做。如果您的代码现在运行，那么删除该方法应该不会产生任何效果。我不认为需要导入java.util。*添加了输出的图片，序列ID是第一个数组的索引，但它在第二个数组中打印出新索引，我希望它打印出这些数字的原始索引。例如e、 第二堆中的值1应该打印出ID为5的ID，因为这是第一堆中的ID。依此类推。它在序列ID中从0到100执行此操作，我只是无法在1张图片中获得每个堆的完整输出。我执行此操作的方法是使用构造函数创建一个内部类：
IndexNumPair（int index，int number）
并有一个
IndexNumPair[]
数组，只需执行类似
IndexNumPair[i].getNum（）和
IndexNumPair[i].getIndex（）的操作
。但我相信有更好的方法，这只是一种方法。您可能需要重新编码heap方法以适应这种情况。也许您可以提供您获得的输出与您想要的输出的示例？printnewID（）似乎什么都没做。如果您的代码现在运行，那么删除该方法应该不会产生任何效果。我不认为需要导入java.util。*添加了输出的图片，序列ID是第一个数组的索引，但它在第二个数组中打印出新索引，我希望它打印出这些数字的原始索引。例如e、 第二堆中的值1应该打印出ID为5的ID，因为这是第一堆中的ID。依此类推。它在序列ID中从0到100执行此操作，我只是无法在1张图片中获得每个堆的完整输出。我执行此操作的方法是使用构造函数创建一个内部类：
IndexNumPair（int index，int number）
并有一个
IndexNumPair[]
数组，只需执行类似于
IndexNumPair[i].getNum（）
和
IndexNumPair[i].getIndex（）
的操作。但我确信有更好的方法，这只是一种方法。您可能需要重新编写堆方法以适应。