-1

我正在尝试对从文本文件“Input.txt”的邻接列表创建的图形执行呼吸优先搜索我在第 162 行收到 NullPointerException,其中显示“root.visited = 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;
        }

    }

}
4

3 回答 3

1

看看这段代码(在 的大括号部分之后有点奇怪main):

Graph MyGraph = new Graph();
MyGraph.dfs();

dfs方法开始于:

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

你希望MyGraph.root在这里做什么?它怎么可能是 null 以外的任何东西?(请注意,您在MyGraph中声明了两个变量main。出于某种原因,第一个没有用于任何用途。)

我强烈建议您对这段代码进行重大重组:

  • main将您的方法重构为更小
  • 避免仅仅为了它而引入一个新的范围 - 你的主要方法是有效的事实:

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

    很奇怪。

  • 当你真的不需要嵌套类时避免它们:使用单独的文件
  • 避免公共变量
  • 尽可能使您的数据不可变。构造真的需要更改顶点的根吗?你不能将它传递给构造函数吗?这样的事情使代码更容易理解。
于 2013-04-02T07:15:06.013 回答
0

当您调用
MyGraph.dfs();
公共静态类图{公共顶点根;

您的根未初始化。

于 2013-04-02T07:17:28.727 回答
0

Vertex root未初始化,因此在运行root.visitednull.visited会导致NullPointerException.

Vertex root预计通过setRootVertex方法设置值。

于 2013-04-02T07:15:08.123 回答