[Java] Überschreitung einer Arraylänge

import java.util.*; // Endthermaufgabe von Michael Rost
import java.io.*;
import java.nio.*;

class Edge{
Edge()
{
src=trg=weight=-1; // Ein Objekt der Klasse Edge repräsentiert eine Kante,
// welche charakterisiert ist durch Quellknoten, Zielknoten und Gewicht
}
Edge(int s, int t, int w)
{
src=s; trg=t; weight=w;
}
public int src;
public int trg;
public int weight;
}

public class Dijkstra {
static int nofNodes; // # Knoten im Graph
static int nofEdges; // # Kanten im Graph

static double [] xCoords; // X-Koordinaten der Knoten (eigentl. momentan ueberfluessig)
static double [] yCoords; // Y-Koordinaten ..... dito
static Edge [] edgeList; // Liste der Kanten
static int [] edgeOffsets;


public static void readGraph(String filename) // folgende Methode liest aus einer Datei einen Graph ein,
// und füllt die Variablen nofNodes, nofEdges sowie die
// Arrays xCoords, yCoords, edgeList.
// edgeOffsets muss von Ihnen noch sinnvoll gefüllt werden!
{
try {
Scanner sc = new Scanner(new File(filename));
sc.useLocale(Locale.ENGLISH);
nofNodes=sc.nextInt();
nofEdges=sc.nextInt();

xCoords=new double[nofNodes];
yCoords=new double[nofNodes];
edgeList=new Edge[nofEdges];
edgeOffsets=new int[nofNodes+1];


for(int i=0; i<nofNodes; i++) // Einlesen der Knotenkoordinaten; die Daten werden wir nicht mehr nutzen
{ // koennten aber nuetzlich sein, wenn wir den Graph auch malen wollen
float x=sc.nextFloat();
float y=sc.nextFloat();
xCoords=x;
yCoords=y;
}
// knoten=new Ege...(...)

for(int i=0; i<nofEdges;i++) // Einlesen der Kanten und abspeichern in der edgeList
{
int source=sc.nextInt();
int target=sc.nextInt();
int weight=sc.nextInt();

edgeList=new Edge(source,target,weight);

}
}
catch(FileNotFoundException e){System.out.println("Problem beim Einlesen");}

// Ausgabe, was wir gerade eingelesen haben; nur zur Kontrolle

System.out.println("Wir haben "+nofNodes+" Knoten und "+nofEdges+" Kanten im Graph");

System.out.println("Liste der Kanten:");
for(int i=0; i<nofEdges; i++)
{
System.out.println("Kante von "+edgeList.src+" nach "+edgeList.trg+" mit Gewicht "+edgeList.weight);
}
}

public static void computeEdgeOffsets()
{ // i=edgeOffsets
// j=EdgeList und Inhalt von EdgeOffsets
for(int i=0; i<edgeOffsets.length-1; i++){ // wenn i < der Länge des zu erstellenden Arrays-1, dann
for(int j=0; j<edgeList.length; j++){
if(edgeList[j].src>=i){
edgeOffsets=j; // setze an die Stelle i im Array j ein, breche ab und erhöhe i um eins
break;
}
}
}
edgeOffsets[nofNodes]=nofEdges;
System.out.println("edgeOffsets:");
System.out.println(java.util.Arrays.toString(edgeOffsets));
}

public static void printAdjacentEdges(int v)
{
int a=edgeOffsets[v]; // a ist die Stelle in edgeList von der an die Kanten beginnen
System.out.println("Ausgabe Adjazente Kanten von "+v); // v ist der übergebene Knoten
while(a<=edgeList.length-1){
if(edgeList[a].src==v){
System.out.println("Kante von Knoten" +v+ "sind:" +edgeList[a].src+ "(Startknoten) und" +edgeList[a].trg+ "(Zielknoten), der Wert der Kante ist:" +edgeList[a].weight); // gibt die einzelnen Kanten des Graphen mit Wert aus
}
else{
break;
}
a++;
}
}

public static void computeSP(int s, int z)
{
int [][] heap = new int [2][nofNodes]; // erstellen eines Arrays mit 2 Eigenschaften

for(int i=0; i<nofNodes; i++){
heap [0]=i; // erste Spalte des Array
heap [1]=Integer.MAX_VALUE; // zweite Spalte des Array
}

heap[0][0]=s;
heap[1][0]=0;
heap[0]=0;

int kk=0; // kk: Knoten von 0 bis
int aZ=0; // aZ:=aktueller Zielknoten
int aG=0; // aG:=aktuelles Gewicht
int nG=0; // nG:=neues Gewicht vom Zielknoten
int j=0; // j ist der Ort des Zielknotens im Heap
while(kk<edgeList.length-1){ // zum endgültigen Zielknoten+1
// Intervall: edgeOffsets bis edgeOffsets[s+1]-1
for(int i=edgeOffsets; i<edgeOffsets[s+1]; i++){ // Intervall in dem die Kanten stehen
aZ=edgeList.trg; //Zielknoten ausgeben von s aus EdgeList (Intervall)
aG=edgeList.weight;
nG=aG+edgeList.weight; //Gewicht vom aktuellen Startknoten+Zielknoten
int k=0; //k durchläuft die Zeilen.
while(k<edgeList.length-1){ //Überprüfung: Wo in der ersten Spalte steht mein Zielknoten aZ -> j ist Spalte.
if (edgeList[k].src!=aZ){ //Wenn k ungleich aZ, dann wird k um eins erhöht und Schleife beginnt von vorne
k++;
}
else{ //Wenn k gleich aZ, dann wird die Zeile gemerkt(j) und die Schleife abgebrochen.
j=k;
break;
}
}
heap[1][j]=nG; //j: Ort des Zielknoten
}
removeMin(heap, s); // ruft Methode removeMin auf

heapSort(heap); // ruft Methode heapSort auf
kk++; // kk wird um eins erhöht und die while-Schleife fängt von vorne an
}

System.out.println("heap:");
System.out.println(java.util.Arrays.deepToString(heap));

int aK=0; // aK: aktueller Zwischenknoten
int l=0;
System.out.println("Zielknoten: "+z); // gebe Zielknoten aus
while(l<edgeList.length){
if(z!=s){ // solange aZ ungleich dem Startknoten
if (edgeList[l].trg==z){ // wenn in Zeile j der edgeList der Zielknoten gleich aZ ist, dann
aK=edgeList[l].src; // setze aK gleich dem Startknoten des Zielknoten
if(heap[1][z]==heap[1][aK]+edgeList[l].weight){ // Prüfe die Distanzen, ob aK als Wegknoten infrage kommt,
System.out.println("Zwischenknoten: "+aK); // wenn ja, dann gebe aK aus und setze Vorgängerknoten gleich aktuellem Zielknoten
z=aK;
}
}
l++; // sonst erhöhe j
}
}
System.out.println("Startknoten: "+s); // gibt Startknoten aus

}

public static void heapSort(int[][] zuSortieren)
{
int n=(zuSortieren.length-1)/2;
while(n>=0){ //Stelle die Heapeigenschaft her, mit Hilfe von heapify und zwar vom ganzen Heap.
heapify(zuSortieren, zuSortieren.length-1, n);
n--;
}
}

public static void heapify(int [][] myHeap, int size, int node)
{
int nn=myHeap [1][node]; // Inhalt der Stelle n (node)
int r=2*node+2; // Stelle des rechten Kindes (r)
int rr; // Inhalt der Stelle l
if (r>size-1){ // rr=0 wenn es kein rechtes Kind gibt
rr=0;
}
else{
rr=myHeap [1][r];
}
int l=2*node+1; // Stelle des linken Kindes (l)
int ll; // Inhalt der Stelle l
if(l>size-1){ // ll=0 wenn es kein linkes Kind gibt
ll=0;
}
else{
ll=myHeap [1][l];
}

if (rr>=ll && rr>nn){ // wenn rechtes Kind > linkes und > des Elternknoten, dann tauschen und erneut die
myHeap[1][r]=nn; // Heapeigenschaft mit heapify herstellen
myHeap[1][node]=rr;

heapify(myHeap, size-1, r);
}
else{ // wenn nicht, dann tausche entweder das linke Kind mit dem Elternknoten, wenn es größer ist
if (ll>nn){ // oder tue nichts
myHeap[1][l]=nn;
myHeap[1][node]=ll;
// wennn getauscht wird, dann Heapeigenschaft mit heapify von l wiederherstellen
heapify(myHeap, size-1, l);
}
}
}

public static int removeMin(int[][] heap, int size)
{
int a=heap[0][0]; // merke Minimum
int b=heap[1][0];

heap[0][0]=heap[0][size]; // schreibe das Ende des Heaps an die erste Stelle
heap[1][0]=heap[1][size];
heap[0][size]=a; // schreibe das Minimum hinter den Heap
heap[1][size]=b;

return size-1; // gebe die Heaplänge zurück
}

public static void main(String[] args) {
if (args.length!=3)
{
System.err.println("java Dijkstra <GraphFile> <SourceNode> <TargetNode>");
System.exit(1);
}

String graphFile=args[0];
int sourceNode=Integer.parseInt(args[1]);
int targetNode=Integer.parseInt(args[2]);

System.out.println("Aufruf mit Graph "+graphFile
+" und Knoten "+sourceNode+" und "+targetNode);

readGraph(graphFile);

computeEdgeOffsets();



System.out.println("Test: Ausgabe der adjazenten Kanten von "+sourceNode+" und "+targetNode);
printAdjacentEdges(sourceNode);
printAdjacentEdges(targetNode);

computeSP(sourceNode, targetNode);
}
}