@Override
	/*
	 * Method to find the shortest possible route between two nodes in the graph
	 * using the Breadth-First Search Algorithm. Returns: ArrayList of Nodes in
	 * order which they should be traversed in order to reach destination.
	 */
	public ArrayList<Node> findRoute(Node sourceNode, Node destinationNode) {
		// if start = end. stop. return null

		// "Source Station matches destination station";
		if (sourceNode.getNodeID() == destinationNode.getNodeID()) {
			System.out
					.println("Error: Source station identical to destination station");
			return null;
		}

		// To store directions to show the user
		ArrayList<Node> directionOutput = new ArrayList<Node>();
		Queue<Node> unvisited = new LinkedList<Node>();
		// route holds a node and the previous node connected to it
		HashMap<Node, Node> route = new HashMap<Node, Node>();
		List<Node> visited = new LinkedList<Node>();

		Node currentStation = sourceNode;

		unvisited.add(currentStation);
		visited.add(currentStation);

		while (!unvisited.isEmpty()) {
			currentStation = unvisited.remove();
			if (currentStation.equals(destinationNode)) {
				// destination reached, exit body of while loop
				break;
			} else {
				// for each of the nodes connected to n...
				for (Node n : getAdjacentNodes(currentStation)) {
					// if unvisited...
					if (!visited.contains(n)) {
						// mark node as visited
						visited.add(n);
						// add node to queue
						unvisited.add(n);
						route.put(n, currentStation);
					}
				}
			}
		}

		// If there is no route
		if (currentStation.equals(destinationNode) == false) {
			System.out.println("A route was not found");
			return null;
		} else {
			// retrace route though hashmap, add nodes to the directions
			// arraylist
			for (Node n = destinationNode; n != null; n = route.get(n)) {
				directionOutput.add(n);
			}

			/*
			 * ASSERTION that all nodes contained in the output were actually
			 * visited and haven't been added accidentally.
			 */
			Boolean a = true;
			for (int i = 0; i < directionOutput.size(); i++) {
				if (!visited.contains(directionOutput.get(i))) {
					a = false;
				}
			}
			assert a : "Route does not contain all visited nodes";

			// have to reverse to put directions in chronological order
			Collections.reverse(directionOutput);

			/*
			 * ASSERTION that the start node entered at the beginning of
			 * findRoute exists in the list returned
			 */
			assert directionOutput.get(0).equals(sourceNode);
			/*
			 * ASSERTION that the end node entered at the beginning of findRoute
			 * exists in the list returned
			 */
			assert directionOutput.get(directionOutput.size() - 1).equals(
					destinationNode);

			return directionOutput;
		}
	}