Dijkstra in Java

Gepostet: , Zuletzt aktualisiert:

package dijkstra.java.simple;

import java.util.Arrays;

/**
 * Used to perform the dijkstra Algorithm using adjacency matrices.
 * For a faster implementation, see @see ../fast/Dijkstra.java (using adjacency Lists)
 */
public class Dijkstra {
    /**
     * Implementation of dijkstra using adjacency matrix.
     * This returns an array containing the length of the shortest path from the start node to each other node.
     * It is only guaranteed to return correct results if there are no negative edges in the graph. Positive cycles are fine.
     * This has a runtime of O(|V|^2) (|V| = number of Nodes), for a faster implementation see @see ../fast/Dijkstra.java (using adjacency lists)
     *
     * @param graph an adjacency-matrix-representation of the graph where (x,y) is the weight of the edge or 0 if there is no edge.
     * @param start the node to start from.
     * @return an array containing the shortest distances from the given start node to each other node
     */
    public static int[] dijkstra(int[][] graph, int start) {

        //This contains the distances from the start node to all other nodes
        int[] distances = new int[graph.length];
        //Initializing with a distance of "Infinity"
        Arrays.fill(distances, Integer.MAX_VALUE);
        //The distance from the start node to itself is of course 0
        distances[start] = 0;

        //This contains whether a node was already visited
        boolean[] visited = new boolean[graph.length];

        //While there are nodes left to visit...
        while (true) {

            // ... find the node with the currently shortest distance from the start node...
            int shortestDistance = Integer.MAX_VALUE;
            int shortestIndex = -1;
            for (int i = 0; i < graph.length; i++) {
                //... by going through all nodes that haven't been visited yet
                if (distances[i] < shortestDistance && !visited[i]) {
                    shortestDistance = distances[i];
                    shortestIndex = i;
                }
            }

            System.out.println("Visiting node " + shortestDistance + " with current distance " + shortestDistance);

            if (shortestIndex == -1) {
                // There was no node not yet visited --> We are done
                return distances;
            }

            //...then, for all neighboring nodes....
            for (int i = 0; i < graph[shortestIndex].length; i++) {
                //...if the path over this edge is shorter...
                if (graph[shortestIndex][i] != 0 && distances[i] > distances[shortestIndex] + graph[shortestIndex][i]) {
                    //...Save this path as new shortest path.
                    distances[i] = distances[shortestIndex] + graph[shortestIndex][i];
                    System.out.println("Updating distance of node " + i + " to " + distances[i]);
                }
            }
            // Lastly, note that we are finished with this node.
            visited[shortestIndex] = true;
            System.out.println("Visited nodes: " + Arrays.toString(visited));
            System.out.println("Currently lowest distances: " + Arrays.toString(distances));

        }
    }
}

Über den Algorithmus und die Programmiersprache in diesem Snippet:

Dijkstra's Algorithmus

Der Dijkstra-Algorithmus ist ein Algorithmus, der verwendet wird, um das Problem des kürzesten Pfades in einem Diagramm zu lösen. Dies bedeutet, dass der Dijkstra-Algorithmus bei einer Anzahl von Knoten und den Kanten zwischen ihnen sowie der “Länge” der Kanten (als “Gewicht” bezeichnet) den kürzesten Weg vom angegebenen Startknoten zu allen anderen Knoten findet.

Beschreibung des Algorithmus

Das Grundprinzip des Dijkstra-Algorithmus besteht darin, den Knoten mit dem derzeit kleinsten Abstand zur Quelle iterativ zu betrachten und alle noch nicht besuchten Nachbarn zu aktualisieren, wenn der Pfad zu ihm über den aktuellen Knoten kürzer ist. Im Einzelnen führt dies zu den folgenden Schritten:

  1. Initialisieren Sie den Abstand zum Startknoten als 0 und den Abstand zu allen anderen Knoten als unendlich
  2. Setzen Sie alle Knoten auf “nicht besucht”.
  3. Während wir nicht alle Knoten besucht haben:

    1. Suchen Sie den Knoten mit der aktuell kürzesten Entfernung von der Quelle (beim ersten Durchgang ist dies der Quellknoten selbst).
    2. Überprüfen Sie für alle Knoten daneben, die wir noch nicht besucht haben, ob die derzeit kleinste Entfernung zu diesem Nachbarn größer ist, als wenn wir über den aktuellen Knoten gehen würden
    3. Wenn dies der Fall ist, aktualisieren Sie die kleinste Entfernung dieses Nachbarn auf die Entfernung von der Quelle zum aktuellen Knoten plus die Entfernung vom aktuellen Knoten zu diesem Nachbarn

Am Ende enthält das Array, mit dem wir die aktuell kürzeste Entfernung von der Quelle zu allen anderen Knoten verfolgt haben, die (endgültigen) kürzesten Entfernungen.

Beispiel des Algorithmus

Betrachten Sie das folgende Diagramm: Grafik für den Dijkstra-Algorithmus für kürzeste Wege

Die Schritte, die der Algorithmus in diesem Diagramm ausführt, wenn der Knoten 0 als Startpunkt angegeben wird, sind:

  1. Besuche Knoten 0
  2. Aktualisieren der Entfernung von Knoten 1 bis 3
  3. Aktualisieren des Abstands von Knoten 2 zu 1
  4. Besuchte Knoten: 0
  5. Derzeit niedrigste Entfernungen: [0, 3, 1, unendlich, unendlich, unendlich]
  6. Besuch von Knoten 1 mit der aktuellen Entfernung 1

    • Aktualisieren der Entfernung von Knoten 3 bis 5
    • Besuchte Knoten: 0, 2
    • Derzeit niedrigste Entfernungen: [0, 3, 1, 5, unendlich, unendlich]
  7. Besuch von Knoten 3 mit der aktuellen Entfernung 3

    • Aktualisieren der Entfernung von Knoten 4 bis 4
    • Besuchte Knoten: 0, 1, 2
    • Derzeit niedrigste Entfernungen: [0, 3, 1, 5, 4, unendlich]
  8. Besuche Knoten 4 mit der aktuellen Entfernung 4

    • Aktualisieren der Entfernung von Knoten 5 bis 5
    • Besuchte Knoten: 0, 1, 2, 4
    • Derzeit niedrigste Entfernungen: [0, 3, 1, 5, 4, 5]
  9. Besuche Knoten 5 mit aktueller Entfernung 5

    • Keine zu aktualisierenden Entfernungen
    • Besuchte Knoten: 0, 1, 2, 3, 4
    • Derzeit niedrigste Entfernungen: [0, 3, 1, 5, 4, 5]
  10. Besuch des Knotens 5 mit der aktuellen Entfernung 5

    • Keine zu aktualisierenden Entfernungen
    • Besuchte Knoten: 0, 1, 2, 3, 4, 5

Alle besuchten Knoten Letzte niedrigste Abstände: [0, 3, 1, 5, 4, 5]

Laufzeit des Algorithmus

Die Laufzeitkomplexität von Dijkstra hängt davon ab, wie es implementiert wird. Wenn ein Min-Heap verwendet wird, um den nächsten zu besuchenden Knoten zu bestimmen, und die Adjazenz unter Verwendung von Adjazenzlisten implementiert wird, ist die Laufzeit O(| E | + | V | log | V|) (|V| = Nummer Anzahl der Knoten, |E| = Anzahl der Kanten). Wenn wir einfach alle Entfernungen durchsuchen, um den Knoten mit der niedrigsten Entfernung in jedem Schritt zu finden, und mithilfe einer Matrix nachsehen, ob zwei Knoten benachbart sind, steigt die Laufzeitkomplexität auf O(| V | ^ 2).

Speicherkomplexität des Algorithmus

Die Speicherkomplexität von Dijkstra hängt auch davon ab, wie es implementiert ist, und entspricht der Laufzeitkomplexität.

Java

The Java Logo

Java ™ ist eine kompilierte Sprache, die für viele Zwecke verwendet wird, von eingebetteten Systemen über UI-Anwendungen bis hin zu Webservern.

“Hello World” in Java

Das Wichtigste zuerst - hier erfahren Sie, wie Sie Ihre erste Codezeile in Java ausführen können.

  1. Laden Sie die neueste Version von Java von [java.com] herunter und installieren Sie sie (https://www.java.com/en/download/). Sie können auch eine frühere Version herunterladen, wenn Ihr Anwendungsfall dies erfordert.
  2. Öffnen Sie ein Terminal, stellen Sie sicher, dass die Befehle “javac” und “javac” funktionieren und dass sich der Befehl, den Sie verwenden werden, auf die Version bezieht, die Sie gerade installiert haben, indem Sie “java -version” ausführen. Wenn der Fehler “Befehl nicht gefunden” (oder ähnlich) angezeigt wird, starten Sie die Befehlszeile und, falls dies nicht hilft, Ihren Computer neu. Wenn das Problem weiterhin besteht, finden Sie hier einige hilfreiche Fragen zu StackOverflow für jede Plattform:

  3. Sobald dies funktioniert, kopieren Sie das folgende Snippet in eine Datei mit dem Namen HelloWorld.java:

    class HelloWorld {
    public static void main(String[] args) {
        // Paste any following code snippets here.
        System.out.println("Hello World");
    }
    }
  4. Ändern Sie das Verzeichnis, indem Sie “cd path / to / HelloWorld” eingeben, dann “javac HelloWorld.java” ausführen, um die Datei zu kompilieren (die den Bytecode erstellt), und dann “java HelloWorld” ausführen (* ohne die .java-Endung *). Dies sollte “Hello World” auf Ihrem Terminal drucken.

Das ist es! Beachten Sie, dass die Eintrittsbarriere bei Java etwas höher ist als bei z. Python - aber Java ist viel schneller und weist meiner Erfahrung nach aufgrund starker Typisierung und anderer Faktoren weniger Fehler in großen Projekten auf.

Fundamentals in Java

Um in Java implementierte Algorithmen und Technologien zu verstehen, muss man zunächst verstehen, wie grundlegende Programmierkonzepte in dieser bestimmten Sprache aussehen. Jedes der folgenden Snippets sollte vom Boilerplate-Code des Hello World-Beispiels umgeben sein und mit den oben genannten Befehlen kompiliert und ausgeführt werden.

Variables and Arithmetic

Variablen in Java sind statisch typisiert, dh der Inhalt einer Variablen muss beim Schreiben des Codes angegeben werden. Der Datentyp für ganze Zahlen ist beispielsweise “int”. Zahlen mit Dezimalstellen werden je nach erforderlicher Genauigkeit mit “float” oder “double” eingegeben. Der Texttyp lautet “String”.

int number = 5;
double decimalNumber = 3.25;
double result = number * decimalNumber;
String callout = "The number is ";
// In this instance, the values are concatenated rather than added because one of them is a String.
System.out.println(callout + result);

Arrays

Arrays in Java sind echte Arrays (im Gegensatz zu beispielsweise Python, wo sie als Listen implementiert sind). Dies hat zur Folge, dass die Größe beim Erstellen festgelegt werden muss und nicht geändert werden kann, aber auch, dass sie in Java effizienter sind als in Python.

int[] integers = new int[5];
integers[3] = 12; // Assigning values to positions in the array
// integers[4] is 0, integers[6] would give IndexOutOfBoundsException
String[] strings = {"Hello", "World"}; // Array initialization with initial values
System.out.println(strings[0] + integers[3]); // Prints "Hello12"

Conditions

Wie die meisten Programmiersprachen kann Java “if-else” -Anweisungen ausführen. Darüber hinaus kann Java auch “switch-case” -Anweisungen ausführen.

int value = 5;
if(value == 5){
    System.out.println("Value is 5");
} else if(value < 5){
    System.out.println("Value is less than 5");
} else {
    System.out.println("Value is something else");
}

switch (value){
    case 1:
        System.out.println("Value is 1");
        break; // Don't go further down the cases
    case 2:
        System.out.println("Value is 2");
        break; // Don't go further down the cases
    case 3:
        System.out.println("Value is 3");
        break; // Don't go further down the cases
    case 4:
        System.out.println("Value is 4");
        break; // Don't go further down the cases
    case 5:
        System.out.println("Value is 5");
        break; // Don't go further down the cases
    default:
        System.out.println("Value is something else");
}

Der obige Java-Code gibt zweimal “Wert ist 5” aus.

Schleifen

Java unterstützt “for” -, “while” - und “do while” -Schleifen. Die Anweisungen break undcontinue werden ebenfalls unterstützt. Das folgende Beispiel zeigt die Unterschiede:

int value = 2;
for (int i = 0; i < value; i++) {
    System.out.println(i);
}
while (value > 0) {
    System.out.println(value);
    value--;
}
do {
    System.out.println(value);
    value--;
} while (value > 0);

Dadurch wird Folgendes auf das Terminal gedruckt:

0
1
2
1
0

Beachten Sie die letzte “0”: Sie wird gedruckt, weil in der “do-while” -Schleife im Vergleich zur “while” -Schleife. Der Codeblock wird mindestens einmal ausgeführt, bevor die Bedingung überprüft wird.

Funktionen

Funktionen in Java können Teil einer Klasse oder eines Objekts einer Klasse sein. Für weitere Informationen zur objektorientierten Programmierung empfehle ich den w3schools-Kurs. Hier ist ein minimales Beispiel für eine Funktion als Teil einer Klasse (auch als statische Funktion bezeichnet):

class HelloWorld {
    public static void main(String[] args) {
        System.out.println(addNumbers(3, 4));
    }

    public static int addNumbers(int numberOne, int numberTwo) {
        return numberOne + numberTwo;
    }
}

Und hier ist ein Beispiel für den Aufruf einer Funktion eines Objekts einer Klasse:

class HelloWorld {
    public static void main(String[] args) {
        System.out.println(new HelloWorld().addNumbers(3, 4));
    }

    public int addNumbers(int numberOne, int numberTwo) {
        return numberOne + numberTwo;
    }
}

Beachten Sie, wie im ersten Beispiel das Schlüsselwort static verwendet wird und im zweiten Beispiel das Objekt der Klasse instanziiert werden muss, bevor in die Funktion dieses Objekts aufrufen kann. Dies sind einige der Unterschiede bei Klassenmethoden und Objektfunktionen.

Syntax

Java erfordert die Verwendung von geschweiften Klammern ({}), um Codeblöcke in Bedingungen, Schleifen, Funktionen usw.; Außerdem sind am Ende der Anweisungen Semikolons erforderlich. Dies kann zwar zu lästigen Syntaxfehlern führen, bedeutet jedoch auch, dass die Verwendung von Leerzeichen für die bevorzugte Formatierung (z. B. Einrücken von Codeteilen) den Code nicht beeinflusst.

Fortgeschrittenes Wissen in Java

Java wurde erstmals 1995 veröffentlicht und ist ein Multi-Paradigma. Das heißt, es ist in erster Linie objektorientiert, hat aber auch funktionale und reflektierende Elemente. Es ist statisch typisiert, bietet jedoch in neueren Versionen ein gewisses Maß an dynamischer Typisierung. Für weitere Informationen hat Java einen großartigen Artikel Wikipedia.