NullPointerException Java BFS

我试图对一个图形执行呼吸优先搜索，该图形是我从文本文件“Input.txt”的邻接列表中创建的。我在第162行得到一个NullPointerException，其中显示“root.visted=true”；我无法理解这是为什么。这是我的代码

     import java.io.BufferedReader;
     import java.io.FileNotFoundException;
     import java.io.FileReader;
     import java.io.IOException;
     import java.util.ArrayList;
     import java.util.Iterator;
     import java.util.LinkedList;
     import java.util.Queue;
     import java.util.Stack;

    public class BFS {
    public static void main(String[] args) {
        {
            Graph g = new Graph();
            // Making Adjacency Matrix
            ArrayList<ArrayList<Integer>> adjacency = new ArrayList<ArrayList<Integer>>();
            adjacency.add(new ArrayList<Integer>());

            String input = "input.txt";
            Graph MyGraph = new Graph();
            boolean root = true;
            Vertex n = null;
            int j = 0;
            try {
                // Reading in the Input File to the Adjacency Matrix
                BufferedReader reader = new BufferedReader(
                        new FileReader(input));
                String line = reader.readLine();

                while (line != null) {
                    // Getting numbers from each line
                    String[] numbers = line.split(",");
                    int[] values = new int[numbers.length];
                    for (int i = 0; i < numbers.length; i++)
                        values[i] += Integer.parseInt(numbers[i]);

                    // Adding values to Matrix
                    for (int i = 0; i < values.length; i++) {
                        adjacency.get(j).add(values[i]);
                        System.out.print(" " + adjacency.get(j).get(i)); // output
                                                                            // of
                                                                            // matrix
                    }
                    System.out.print("\n");

                    // Progressing through file
                    adjacency.add(new ArrayList<Integer>());
                    line = reader.readLine();
                    j++;
                }

                // read each line
                for (int currRow = 0; (line = reader.readLine()) != null; currRow++) {
                    String[] row = line.split(",");

                    // insert vertices
                    if (currRow == 0) {

                        for (int i = 0; i < row.length; i++) {
                            g.addVertex(n);
                            if (root = true) {

                            }
                        }
                    }

                    // create the edges specified in this row
                    for (int i = 0; i < row.length; i++) {

                        // edge exists between indices 'currRow' and col 'i'.
                        if (Integer.parseInt(row[i]) == 1) {
                            g.connectVertex(currRow, i);
                        }
                    }
                }
                reader.close();
            } catch (FileNotFoundException e) {
                System.out.println(e);
            } catch (IOException e) {
                System.out.println(e);
            }

            /* DFS Algorithm */

            // schtuff (use stack? use index of node for unique number?)

            // System.out.print("Visited nodes (in order): ");

        }

        // catch exceptions & errors
        Graph MyGraph = new Graph();
        MyGraph.dfs();
    }

    public static class Graph {
        public Vertex root;
        public ArrayList<Vertex> vertices = new ArrayList<Vertex>();
        public ArrayList<Vertex> dfsArrList = new ArrayList<Vertex>();
        public int[][] adjMatrix;
        int size;

        public void setRootVertex(Vertex n) {
            this.root = n;
        }

        public Vertex getRootVertex() {
            return this.root;
        }

        public void addVertex(Vertex n) {
            vertices.add(n);
        }

        public void removeVertex(int loc) {
            vertices.remove(loc);
        }

        public void connectVertex(int vertexStart, int vertexEnd) {
            if (adjMatrix == null) {
                size = vertices.size();
                adjMatrix = new int[size][size];
            }

            int startIndex = vertices.indexOf(vertexStart) + 1;
            int endIndex = vertices.indexOf(vertexEnd) + 1;
            adjMatrix[startIndex][endIndex] = 1;
            adjMatrix[endIndex][startIndex] = 1;
        }

        public void removeEdge(Vertex v1, Vertex v2) {

            int startIndex = vertices.indexOf(v1);
            int endIndex = vertices.indexOf(v2);
            adjMatrix[startIndex][endIndex] = 1;
            adjMatrix[endIndex][startIndex] = 1;
        }

        public int countVertices() {
            int ver = vertices.size();
            return ver;
        }

        private Vertex getUnvisitedChildNode(Vertex n) {

            int index = vertices.indexOf(n);
            int j = 0;
            while (j < size) {
                if (adjMatrix[index][j] == 1
                        && vertices.get(j).visited == false) {
                    return vertices.get(j);
                }
                j++;
            }
            return null;
        }

        public Iterator<Vertex> dfs() {

            Stack<Vertex> s = new Stack<Vertex>();
            s.push(this.root);
            root.visited = true;
            printVertex(root);
            while (!s.isEmpty()) {
                Vertex n = s.peek();
                Vertex child = getUnvisitedChildNode(n);
                if (child != null) {
                    child.visited = true;
                    dfsArrList.add(child);
                    s.push(child);
                } else {
                    s.pop();
                }
            }
            clearVertices();
            return dfsArrList.iterator();
        }

        private void clearVertices() {
            int i = 0;
            while (i < size) {
                Vertex n = vertices.get(i);
                n.visited = false;
                i++;
            }
        }

        private void printVertex(Vertex n) {
            System.out.print(n.vertexName + " ");
        }
    }

    public class Vertex {

        public char vertexName;
        public boolean visited = false;

        public Vertex(char l) {
            this.vertexName = l;
        }

    }

}

导入java.io.BufferedReader；
导入java.io.FileNotFoundException；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.Iterator；
导入java.util.LinkedList；
导入java.util.Queue；
导入java.util.Stack；
公共类BFS{
公共静态void main（字符串[]args）{
{
图g=新图（）；
//邻接矩阵的生成
ArrayList邻接=新的ArrayList（）；
add（newarraylist（））；
String input=“input.txt”；
Graph MyGraph=新图形（）；
布尔根=真；
顶点n=null；
int j=0；
试一试{
//将输入文件读入邻接矩阵
BufferedReader reader=新的BufferedReader(
新文件读取器（输入）；
字符串行=reader.readLine（）；
while（行！=null）{
//从每行中获取数字
字符串[]数字=行。拆分（“，”）；
int[]值=新的int[numbers.length]；
for（int i=0；iGraph MyGraph = new Graph();
MyGraph.dfs();

Stack<Vertex> s = new Stack<Vertex>();
s.push(this.root);
root.visited = true;

public static void main(String[] args) { 
    {
         // Code
    }
}