A data structure for storing a set of keys, each with a set of links; keeping in memory whether those links have been visited to by their parent key.
I designed this data-structure initially when I needed something to help me deal with the triangulation of polygons.
The basic idea is this: we have some key, and that key points to a set of links which store in memory
whether they have been visited to from the parent key or not. For example, say we have 3 vertices: v1
, v2
and v3
.
v1
is the key, which points to two links: v2
and v3
. Both of which have initially not been visited to
by their parent key, v1
. So, the data structure initially looks like the following:
Keys Links Visited?
v1 --> v2 --> false
--> v3 --> false
Afterwards, we may traverse to v2
from v1
, in which case we then declare v2
as been visited to from its parent
v1
. So now the structure looks like this:
Keys Links Visited?
v1 --> v2 --> true
--> v3 --> false
Now, let us say we have another key-links set, say: v2
links to v1
and v3
:
Keys Links Visited?
v1 --> v2 --> true
--> v3 --> false
v2 --> v1 --> false
--> v3 --> false
Here, you will notice that the link between v2
and v1
is marked as false. This is correct, as v1
has not
been visited to from its parent key of v2
, even though v2
has been visited to from v1
.
To create and initialise a new VisitorList, we use:
VisitorList<Integer, Integer> visitorlist = new VisitorList<Integer, Integer>();
as we would with any List, Map or Set within Java. Once the VisitorList has been created, we can
give the visitorlist
a new key to store links by:
int vertex1 = 1;
visitorlist.add(vertex1);
and this will add vertex1
to the list of keys contained within the visitorlist
. It will also initialise
an empty List of Links and visitation information. If we wish to add a new key, with an initial link and
set its visitation details, we use:
int vertex1 = 1;
int vertex2 = 2;
visitorlist.add(vertex1, vertex2, false);
So here, we create a new key of vertex1
with an initial link to vertex2
, and we state that vertex2
has
not yet been visited to by vertex1
with a boolean value of false
.
In most cases, it will be vital to get the first non-visited link from some key. Therefore, assuming we have the VisitorList created just above, we can use:
int nextVertex = visitorlist.getNext(vertex1);
This will return vertex2
, because vertex2
has not yet been visited to by vertex1
. If we wish to change
the visitation details of a specific link from non-visited to visited, we can use:
visitorlist.setVisited(vertex1, vertex2, true);
Which will set the visitation details of vertex2
to have now been visited to by vertex1
.
Adding a new link for some key is also simple, we can just:
int vertex3 = 3;
visitorlist.add(vertex1, vertex3, false);
Now, we still have one key within the visitorlist
; namely, vertex1
. But now, this key has two links: vertex2
and
vertex3
. Except, vertex2
has already been visited to by vertex1
, yet vertex3
has not. Therefore, if we
were to call,
int nextVertex = visitorlist.getNext(vertex1);
again on vertex1
, this time around we would yield the link of vertex3
. Now let us say that vertex3
has
already been visited to. If we call getNext(vertex1)
again then a value of null
is returned as all links
for vertex1
have been visited to by it.
Obviously, we have a problem will int = null
, therefore, if this is ever the case, you could use either:
if (visitorlist.getNext(vertex1) != null) {
nextVertex = visitorlist.getNext(vertex1);
}
or
if (!visitorlist.allVisited(vertex1)) {
nextVertex = visitorlist.getNext(vertex1);
}
These are only two possible workarounds, but of course, there are others. Another could be:
Object obj = visitorlist.getNext(vertex1);
if (obj != null) {
nextVertex = (Integer)obj;
}
It should also be clear as to what it is allVisited(vertex1)
is doing. This method returns true
if every link
for the key vertex1
has been visited to by it, false otherwise.