Performance of Depth-First Search (DFS) algorithm in Java [closed]

I implemented Depth-First Search (DFS) recursively in Java.

My current implementation searches the entire node list every time I follow an edge in order to find the target node.

public void dfsSearch(String start){ List<String> besuchliste = new ArrayList<>(); for(int i = 0; i < getKnotenListe().size();i++){ Knoten knoten = getKnotenListe().get(i); if(knoten.get_name().equals(start)){ hilfMethodea(knoten,besuchliste); } } } private void hilfsMethode(Knoten aktuellerknoten, List<String> besuchsliste){ besuchsliste.add(aktuellerknoten.get_name()); System.out.println("Besuchter Knoten" + aktuellerknoten.get_name()); for(int i = 0; i < aktuellerknoten.get_kanten().size();i++){ Kante kante = aktuellerknoten.get_kanten().get(i); String ziel = String.valueOf(kante.get_ziel()); if(!besuchsliste.contains(ziel)){ for (int j = 0; j < getKnotenListe().size(); j++){ Knoten knoten = getKnotenListe().get(i); if(knoten.get_name().equals(ziel)){ hilfMethodea(knoten,besuchsliste); break; } } } }

This works, but feels inefficient because of the nested loop.

I am wondering:

Is there a cleaner way to resolve target nodes?

Should I use a Map<String, Knoten> for faster lookup?

Are there additional improvements regarding DFS best practices in Java?