Cleaned up some syntax, added a ugraph unit test.

Setting up graph generation code and testing changes.
Set up the GraphGen directory to contain the code for generating
large numbers of arbitrarily sized strongly-connected graphs. I
will use this to generate a large database of graphs to perform
testing upon. Also made some changes to the randomization functions
for the edge-weighting in the unit tests, this more evenly distributes
the weights, which makes our tests run slower but represents a more
accurate and complex scenario for testing.

Added back in main README, somehow got deleted ..
Not sure how that happened, good thing it''s saved in the history.

Improvments to connectivity algorithms and testing suite
The check for connectivity was very slow, which was in turn slowing
down the unit tests considerably, and rendering our ability to test
dijkstra''s algorithm on very large graphs to be non-existent. This
came from an error in the copy constructor, where we were deleting
all of our vertices by un-tangeling the web of edges in the graph,
one-by-one. This is unnecessary, since we were just clobbering the
current graph, so I added a destroyGraph() function, which just
goes through and deletes/frees up all vertices and edges in the
graph.
I also simplified the dijkstra testing suite by making the various
union-build-graph techniques into one function that can be called
with various parameters, like number of vertices, number of
subgraphs, and number of random edges to tack on. This function
can now be called when-ever which makes it easier to test large
graphs in the suite.

Cleaned up code logic in traversal functions
In depthFirst and breadthFirst search functions for both dGraph
and uGraph, I cleaned up the structure of some of the statements,
mostly having to do with the graph traveler. The overall logic is
still the same, but there were some unneccessary if-statements
and unused variables that got cleaned up. All changes were tested
and confirmed correct with the respective testing suites.

Cleaned up comment formatting/fixed typos
Once again just edited the 200+ char long lines to be shorter
and more manageable. Fixed some typos and what not, no code logic
changes were added.

Cleaned up the in-line documentation and fixed typos.
Went through some of the pre-function documentation and made it
so the comments are too long, causing ugly line-wrapping to
occur on regular-sized screens. Fixed a few typos, no actual code
changes occured.

Cleaned up some in-line code documentation that was copied and pasted without being appropriately changed.

Cleaned up the syntax by doing a few things, namely getting rid of all of the pointless this-> calls that I used to think were helpful to the reader.

Removed some files that showed up in the data structures directory accidentally.

Added some clarification to the inline documentation in both the uGraph and dGraph classes. Changed the random weighting routine a bit to generate better random weights.

Updating README files for the graph testing suites

Updated some of the tests

Started working on the string testing suite for both the directed and undirected graphs. I uploaded a file of 10,000 random unique words to use as vertices for all of the tests. I noticed something kind of odd, it takes almost 10x as long to delete 10,000 vertices for a directed graph as it does for an undirected graph, I know this is because a directed graph has to scan through all of the other vertices to find edges that are outgoing towards the vertex to be deleted, while an undirected graph, by its very nature, knows all of the edges that are incoming and outgoing of it, and so it doesn''t have to search much to find all of the edges to delete. What is puzzling to me is that there are no edges in the graphs I''m working on, so the directed graph should have to do much work.. need to do some investigation. Everything is compiling and running fine.

Some large changes, #1 Found a bug in dGraph minSpanningTree Testing function that was passing it a non-connected tree to be spanned which caused the test to fail. Not a problem with the data structure just the test input. #2 Changed around the testing directory structure, now all of the current tests are under a IntTest directory, because they all test on graphs with integer vertices. I''m preparing to add tests over graphs with strings, pairs, and other classes as vertex data

Found a novel way to increase the speed of my dijkstras shortest path algorithm by 30-50%, before I was computing the entire shortest path tree from the source vertex to every other vertex in the tree, which works fine if the user wants the shortest path to every other vertex. However, this is not the case often, where they just want one path between a source and dest vertex. I now just cut off the algorithm when it reaches the destination vertex, if the dest in null then we compute the entire spanning tree

Performing more performance testing, especially with the priority search algorithms

Restructured testing suite into multiple files, each one dealing with a specific type of testing (Vertex, edge, algorithm, etc)

Found a simple way to speed up Dijkstras search by about 8-12%, didn''t change the search algorithm, only the unwinding algorithm

Vastly improved the unit testing on dijkstras algorithm. All connected graphs from a minimum spanning graph to a dense graph over thousands of vertices are tested thoroughly. Now that the algorithm works 100%, we need to work on efficiency