/DFS vs BFS

              #include <iostream>
        #include <stack>
        #include <queue>
        
        using namespace std;
        
        class Vertex {
        public:
          string label;
          bool visited;
        
          Vertex(string label = "", bool visited = false) {
            this->label = label;
            this->visited = visited;
          }
        };
        
        void addVertex(Vertex* vertices, string label, int index) {
          Vertex v(label);
          vertices[index] = v;
        }
        
        void addEdge(bool** adjMatrix, int start, int end) {
          adjMatrix[start][end] = true;
          adjMatrix[end][start] = true;
        }
        
        void displayVertex(const Vertex& v) {
          cout << v.label << ' ';
        }
        
        void dfsIteration(Vertex* vertices, bool** adjMatrix, int size, int index) {
          stack<int> iDex;
          iDex.push(index);
        
          while (!iDex.empty()) {
            int index = iDex.top();
            iDex.pop();
        
            if (!vertices[index].visited) {
              displayVertex(vertices[index]);
              vertices[index].visited = true;
        
              for (int i = 0; i < size; i++) {
                if (adjMatrix[index][i]) {
                  iDex.push(i);
                }
              }
            }
          }
        }
        
        void bfsIteration(Vertex* vertices, bool** adjMatrix, int size, int index) {
          queue<int> iDex;
          iDex.push(index);
          vertices[index].visited = true;
        
          while (!iDex.empty()) {
            int index = iDex.front();
            iDex.pop();
        
            displayVertex(vertices[index]);
            for (int i = 0; i < size; i++) {
              if (adjMatrix[index][i] && !vertices[i].visited) {
                iDex.push(i);
                vertices[i].visited = true;
              }
            }
          }
        }
        
        void reset(Vertex* vertices, int n) {
          for (int i = 0; i < n; i++) {
            vertices[i].visited = false;
          }
        }
        
        int main() {
          int numberOfVertex;
          cout << "Nhap so dinh: ";
          cin >> numberOfVertex;
        
          Vertex* vertices = new Vertex[numberOfVertex];
        
          for (int i = 0; i < numberOfVertex; i++) {
            cout << "Ten dinh: ";
            string label;
            cin >> label;
            addVertex(vertices, label, i);
          }
        
          bool** adjMatrix = new bool* [numberOfVertex];
          for (int i = 0; i < numberOfVertex; i++) {
            adjMatrix[i] = new bool[numberOfVertex]();
          }
        
          int start, end;
          while (true) {
            cin >> start;
            if (start < 0) break;
            cin >> end;
            addEdge(adjMatrix, start - 1, end - 1);
          }
        
          bfsIteration(vertices, adjMatrix, numberOfVertex, 0);
        
        
          for (int i = 0; i < numberOfVertex; i++) {
            delete adjMatrix[i];
          }
          delete adjMatrix;
        
          return 0;
        }