Breadth-first Traversal with a Queue

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

/* The graphs used in the post's diagrams
   have node indexing which starts at 1.
   Since arrays and vectors in C++ use
   0-based indexing, we subtract 1 from the
   indices used in the input, and add 1
   to the indices printed in the output. */

/* This graph can support 10000 nodes
   numbered from 1 to 10000 inclusive. */
bool visited[10000] = {false};

/* Each vector of integers represents
   an individual node and the nodes it
   is connected with. */
vector< vector<int> > adjList;

int main () {
    /* Take the number of nodes in the graph
       and the number of edges in the graph as input. */
    int nodeCount, edgeCount;
    cin >> nodeCount >> edgeCount;

    /* Fill the adjacency list with unconnected nodes. */
    for (int i = 0; i < nodeCount; i++) {
        vector<int> node;
        adjList.push_back (node);
    }

    /* Add undirected edges to the adjacency list
       using the input as a guide. */
    for (int i = 0; i < edgeCount; i++) {
        int n1, n2;
        cin >> n1 >> n2;
        n1--;
        n2--;
        adjList[n1].push_back (n2);
        adjList[n2].push_back (n1);
    }

    /* Take the index of the starting node. */
    int startIndex;
    cin >> startIndex;
    startIndex--;

    /* First, push the index of the starting node
       onto the traversal queue - this structure
       holds the indices of the nodes which we
       will go on to visit. */
    queue<int> bfsQueue;
    bfsQueue.push(startIndex);
    while (!bfsQueue.empty()) {
        /* Take the index of the node that is first
           in the queue - this is the value which
           has been in the queue the longest (that is,
           the value at the 'front' of the queue). */
        int index = bfsQueue.front();
        bfsQueue.pop();
        visited[index] = true;
        cout << index+1 << "\n";

        for (int i = 0; i < adjList[index].size(); i++) {
            if (!visited[adjList[index][i]]) {
                bfsQueue.push(adjList[index][i]);
            }
        }
    }

    return 0;
}