DFS in Perl (or Java or C++ ...) - depth-first-search

Question

I have done some in 3D computer graphics but am somewhat new to graph
theory.
In particular I have been looking at and trying to solve my problem using a
depth first search (DFS) as described in Mastering Algors w/ Perl (Jarkko
Hietaniemi). So far I have not been able to get it :-( but I am pretty-sure a DFS
is what I want.
It does not have to be in Perl (just trying to learn the language), but Java or C++ would be good.
I have 53 position vectors, ie (x,y,z), which I represent as
(x1,y1,z1)
(x2,y2,z2)
.
.
.
(x53,y53,z53)
I then run a Perl program that I wrote to generate random links between
nodes, assigning some max no. of hops, say 6. So the topology may look like
this
5 <-- node 1 has 5 links to
18 4 23 6 48, <-- node 18, node 4, node 23, node 6, node 48
2 <-- node 2 has 2 links to
14 5, <-- node 14, node 5
0 <-- node 3 is a leaf since it has no links
.
.
.
2 <-- node 18 has 2 links to
3 17 <-- node 3, node 17
.
.
.
4 <-- node 53 has 4 links to
10 46 49 22 <-- node 10, node 46, node 49, node 22
I would like to determine the path "run" till I hit a sink, ie a 0.
e.g. node 1 to node
18 to node 3, ...
This path is completed already.
.
.
.
I think I want DFS; it seems like a recursive exercise.
If someone understands and could give me code, that would be great. I am not a student but am 51! Maybe that has something to do with me not getting this :-)
I looked at my q and for some reason (probably me :-( it was "garbled"
Topology should look like
5 <-- node 1 has 5 links;
18 4 23 6 48 <-- node 18, node 4, node 23, node 6, node 48
2 <-- node 2 has 2 links;
14 5, <-- node 14, node 5
0 <-- node 3 is a leaf since it has no links
.
.
.
2 <-- node 18 has 2 links;
3 17 <-- node 3, node 17
.
.
.
4 <-- node 53 has 4 links;
10 46 49 22 <-- node 10, node 46, node 49, node 22
Just want to be clear in case someone can provide code (Perl, Java, c++/C ...)
Thanks.

Answer 1

The idea of a depth first search is to search a "deep" as possible for your query first and then move across the train. This is easy to think of in terms of a data tree:
The search will go from nodes 1 -> 53, the search order will be
1 -> 18 -> 3 -> 17 -> 4 -> 23 -> 6 -> 48 -> 2 -> 5 -> 14 ....
It goes to Node 1, looks at its first link: node 18, then node 18's first link node 3, hits a node without a link. Then goes back to search on the same depth level to node 17, etc. In your case you will only need to stop there.
There is the full solution in Java below, sorry I am not familiar with perl so I have written the pseudo-code logic out instead.
The problem is fairly straight forward except for the case where there is a circular linkage which could cause an infinite loop, so I have added a list of previously visited nodes and check against this to avoid redundant or infinite searching.
depthFirstSearch(node) { // call to search a node
result = depthFirstSearch(node, empty list for previously searched list);
if (the result is null) {
print "No leaf node found"
} else {
"Found: " + result info
}
return result;
}
depthFirstSearch(node, previouslySearchedList) { // method with a list of previously visited nodes
// if the node is null, return null
// add the node to the list of searched nodes
if (// the node has 0 links) {
// we have found a leaf, return it.
} else {
for (each of the links the current node has) {
for (each of the previously searched links) {
if (the current node has been searched) {
set a null return value
break the loop
} else {
set the return value to this node
}
}
// recursively search the next node, passing the previously searched list along
last_node = depthFirstSearch(next,previouslySearchedList);
if (the last recursive call returned a null value move on to the next child) {
break the loop
}
}
return the last node found // could be a null, could be a result.
}
}
And here is a full working solution:
class Node {
int default_size = 10;
ArrayList<Node> links = new ArrayList<Node>();
int numberOfLinks = 0;
int x, y, z, index;
public Node(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
this.index = -1;
}
public Node(int x, int y, int z, int index) {
this.x = x;
this.y = y;
this.z = z;
this.index = index;
}
public void addNodeLink(Node node) {
this.links.add(node);
}
public int getIndex() {
return this.index;
}
public int getNumberOfLinks() {
return links.size();
}
public ArrayList<Node> getLinks() {
return this.links;
}
public String getInfo() {
String info = "";
if (index < 0) {
info += "Unindexed node ";
} else {
info += "Node " + index + " ";
}
info += "with " + this.getNumberOfLinks() + " links\n ";
for (int i = 0; i < this.getNumberOfLinks(); i++) {
info += this.getLinks().get(i).getIndex() + " ";
}
return info;
}
public String toString() {
return getInfo();
}
public static Node depthFirstSearch(Node node) {
Node result = depthFirstSearch(node, new ArrayList<Node>());
if (result == null) {
System.out.println("\nNo leaf node found");
} else {
System.out.println("\nFound: " + result);
}
return result;
}
public static Node depthFirstSearch(Node node, ArrayList<Node> searchList) {
if (node == null) { return null; }
searchList.add(node);
if (node.getNumberOfLinks() == 0) {
System.out.println(" -> Node " + node.getIndex());
return node;
} else {
System.out.print((searchList.size() > 1 ? " -> " : "Path: ") + "Node " + node.getIndex());
Node last_node = null, next = null;
int i, j;
for (i = 0; i < node.getNumberOfLinks(); i++) {
for (j = 0; j < searchList.size(); j++) {
if (node.getLinks().get(i).getIndex() == searchList.get(i).getIndex()) {
next = null;
break;
} else {
next = node.getLinks().get(i);
}
}
last_node = depthFirstSearch(next,searchList);
if (last_node != null) {
break;
}
}
return last_node;
}
}
public static void main(String[] args) {
Node[] graph = new Node[53];
// set up your nodes
int randomNum = 0 + (int)(Math.random()*100);
for (int i = 0; i < graph.length; i++) {
randomNum = 0 + (int)(Math.random()*100);
graph[i] = new Node(randomNum,randomNum,randomNum,i+1);
}
System.out.println("Example given in question");
// Example given in question
graph[0].addNodeLink(graph[17]);
graph[0].addNodeLink(graph[3]);
graph[0].addNodeLink(graph[22]);
graph[0].addNodeLink(graph[5]);
graph[0].addNodeLink(graph[47]);
graph[1].addNodeLink(graph[13]);
graph[1].addNodeLink(graph[4]);
graph[17].addNodeLink(graph[2]);
graph[17].addNodeLink(graph[16]);
graph[52].addNodeLink(graph[9]);
graph[52].addNodeLink(graph[45]);
graph[52].addNodeLink(graph[48]);
graph[52].addNodeLink(graph[21]);
for (int i = 0; i < graph.length; i++) {
if (graph[i].getNumberOfLinks() != 0) {
System.out.println(graph[i]);
}
}
depthFirstSearch(graph[0]);
// reset the nodes
randomNum = 0 + (int)(Math.random()*100);
for (int i = 0; i < graph.length; i++) {
randomNum = 0 + (int)(Math.random()*100);
graph[i] = new Node(randomNum,((59+3*randomNum)%100),((19+17*randomNum)%100),i+1);
}
// circular reference example
System.out.println();
System.out.println();
System.out.println("Circular reference");
graph[0].addNodeLink(graph[1]);
graph[1].addNodeLink(graph[2]);
graph[2].addNodeLink(graph[0]);
for (int i = 0; i < graph.length; i++) {
if (graph[i].getNumberOfLinks() != 0) {
System.out.println(graph[i]);
}
}
depthFirstSearch(graph[0]);
System.out.println();
System.out.println();
System.out.println("Circular reference, with a leaf node added");
graph[0].addNodeLink(graph[3]);
for (int i = 0; i < graph.length; i++) {
if (graph[i].getNumberOfLinks() != 0) {
System.out.println(graph[i]);
}
}
depthFirstSearch(graph[0]);
}
}