Java网络/树模拟在一定数量的节点之后进入无限循环

我希望有人能帮我解决这个问题。首先，我尝试删除尽可能多的没有引起问题的代码

我的问题是：当我运行程序时，一切都运行得很好，直到我创建了一个有大约130个节点的图。一旦达到130多个节点，程序将永远在无限循环中运行

我试着在15点运行135个节点的程序，以获得所需的图形密度

为了提供一些背景信息，我正在进行研究模拟，为此我创建了随机图，并使用BFS构建生成树

我的问题出现在生成树的创建过程中

在一个文件中复制和粘贴代码并使用javac MMB.java进行编译

import java.util.*;

/**
 *  Custom type Set used to differentiate nodes in the FAST and SLOW sets
*/
enum Set {
    FAST, SLOW;
}

/**
 *  Custom node class used to store our spanning tree
*/
class Node<T> {

    private T data;
    private Node<T> parent;
    private List<Node<T>> children;
    private int level;
    private int rank;
    private Set set;

    // constructor for root Nodes and stand alone nodes
    public Node(T data){
        this.data = data;
        this.parent = null;
        this.level = 0;
        this.rank = Integer.MIN_VALUE;
        this.children = new ArrayList<Node<T>>();
    }

    // constructor for all non root nodes
    public Node(T data, Node<T> parent){
        this.data = data;
        this.setParent(parent);
        this.level = (parent.getLevel()) + 1;
        this.rank = Integer.MIN_VALUE;
        this.children = new ArrayList<Node<T>>();
    }

    // get data
    public T getData(){
        return this.data;
    }

    // set data
    public void setData(T data){
        this.data = data;
    }

    // add child node
    public void addChild(Node<T> child){
        children.add(child);
    }

    // remove child node
    public void removeChild(Node<T> child){
        children.remove(child);
    }

    // get rank
    public int getRank(){
        return this.rank;
    }

    // set rank
    public void setRank(int rank){
        this.rank = rank;
    }

    // get parent
    public Node<T> getParent(){
        return this.parent;
    }

    // set parent - updates parent node to have child
    public void setParent(Node<T> parent){
        this.parent = parent;
        parent.addChild(this);
    }

    // returns level of a Node
    public int getLevel(){
        return this.level;
    }

    // returns a list of children of a given node
    public List<Node<T>> getChildren(){
        return this.children;
    }

    // set the Set a node is in
    public void setSet(Set set){
        this.set = set;
    }

    // get the Set a node is in
    public Set getSet(){
        return this.set;
    }

    // returns the tree as a list of nodes using DFS traversal
    public List<Node<T>> treeToList(){
        List<Node<T>> list = new LinkedList<Node<T>>();
        List<Node<T>> visitedNodes = new LinkedList<Node<T>>();

        list.add(this);
        while(list.size() > 0){
            Node<T> currentNode = list.get(list.size() - 1);
            List<Node<T>> currentNodesChildren = currentNode.getChildren();
            if(!visitedNodes.contains(currentNode)){
                for(Node<T> n : currentNodesChildren){
                    list.add(n);
                }
                visitedNodes.add(currentNode);
            }
            else {
                list.remove(currentNode);
            }
        }
        return visitedNodes;
    }

    // returns the number of levels in the tree
    // Note: levels start at 0
    public int numberOfLevels(){
        List<Node<T>> list = this.treeToList();
        int maxLevel = 0;
        for(Node<T> n : list)
            if(n.getLevel() > maxLevel)
                maxLevel = n.getLevel();
        return maxLevel + 1;
    }

    // returns the max rank in the tree
    public int maxRank(){
        List<Node<T>> list = this.treeToList();
        int maxRank = 0;
        for(Node<T> n : list)
            if(n.getRank() > maxRank)
                maxRank = n.getRank();
        return maxRank;
    }

    // returns a list of nodes with a given rank and level in the FAST set
    public List<Node<T>> nodeRankLevelSubset(int rank, int level){
        List<Node<T>> list = this.treeToList();
        List<Node<T>> subset = new LinkedList<Node<T>>();
        for(Node<T> n : list)
            if(n.getRank() == rank && n.getLevel() == level && n.getSet() == Set.FAST)
                subset.add(n);
        return subset;
    }

    // Print All
    public void printAll(){
        List<Node<T>> list = this.treeToList();
        for(Node<T> n : list){
            System.out.println("{");
            System.out.println(" \"data\": " + n.getData() + ",");
            System.out.println(" \"level\": " + n.getLevel() + ",");
            System.out.println(" \"rank\": " + n.getRank() + ",");
            switch(n.getSet()){
                case FAST:
                    System.out.println(" \"set\": \"FAST\"");
                    break;
                case SLOW:
                    System.out.println(" \"set\": \"SLOW\"");
                    break;
            }
            System.out.print(" \"parent\": ");
            if(n.getParent() != null)
                System.out.println(n.getParent().getData() + ",");
            else
                System.out.println(" ,");
            System.out.print(" \"children\": [");
            for(Node<T> cn : n.getChildren()){
                System.out.print(cn.getData() + ",");
            }
            System.out.println("]\n}");
        }
    }
    // BFS to print
    public void printTree(){
        List<Node<T>> discoveredNodes = new LinkedList<Node<T>>();
        List<Node<T>> queue = new LinkedList<Node<T>>();
        List<Node<T>> children;
        Node<T> currentNode;
        queue.add(this);
        discoveredNodes.add(this);
        while(queue.size() > 0){
            currentNode = queue.remove(0);
            children = currentNode.getChildren();
            System.out.print("\n" + currentNode.getData() + ": ");
            for(Node<T> n : children){
                queue.add(n);
                discoveredNodes.add(n);
                System.out.print(n.getData() + " " + " Rank: " + n.getRank() + " ");
            }
        }
        System.out.print("\n");
    }
}

public class MMB {
    // boolean 2D array used to make the edges in a random graph
    public static boolean[][] randomGraph;
    // custom Node class used to store our BFS spanning tree
    public static Node<Integer> spanningTree;

    public static void main(String[] args){
        int numberOfNodes, graphDensity;

        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the desired number of Nodes: ");
        numberOfNodes = scanner.nextInt();
        System.out.print("Enter the desired graph density: ");
        graphDensity = scanner.nextInt();

        randomGraph = randomGraph(numberOfNodes, graphDensity);

        /* Print Out Graph */
        for(int i = 0; i < randomGraph.length; i++){
            System.out.print(i + " ");
            for(int j = 0; j < randomGraph.length; j++){
                System.out.printf(" " + randomGraph[i][j] + " ");
            }
            System.out.println("");
        }
        System.out.println("");
        System.out.println("HERE - CREATED GRAPH");
        spanningTree = spanningTree(0);
        System.out.println("HERE - CREATED SPAnnING TREE");
        // rankNodes(spanningTree, spanningTree.numberOfLevels());
        // System.out.println("HERE - FIRST RANK");
        // determineSet(spanningTree);
        // System.out.println("HERE - DETERMINE SET");
        // //spanningTree.printTree();
        // reRankNodes(spanningTree);
        // System.out.println("HERE - RERANK NODES");
        // //spanningTree.printTree();
        // spanningTree.printAll();
    }


    /**
     *  Create an undirected graph at random
     *  A 2D boolean array will represent the edges between nodes
     *  @param  numberOfNodes   number of nodes in the graph
     *  @param  graphDensity    integer percentage of graph density
    */
    public static boolean[][] randomGraph(int numberOfNodes, int graphDensity){
        boolean[][] graph = new boolean[numberOfNodes][numberOfNodes];
        Random randomNumber = new Random();

        boolean hasEdge;
        for(int i = 0; i < numberOfNodes; i++){
            hasEdge = false;
            for(int j = 0; j < numberOfNodes; j++){
                // i != j ensures no loops
                if(i != j && (randomNumber.nextInt(100) + 1) < graphDensity){
                    graph[i][j] = true;
                    graph[j][i] = true;
                    hasEdge = true;
                }
            }
            // to ensure no disconnected nodes, keep track with hasEdge
            // if no edge exists create a random one
            int randomNum;
            while(!hasEdge){
                if((randomNum = randomNumber.nextInt(numberOfNodes)) != i){
                    graph[i][randomNum] = true;
                    graph[randomNum][i] = true;
                    hasEdge = true;
                }
            }
        }
        return graph;
    }


    /**
     *  Create a Spanning Tree from an undirected graph using BFS
     *  A custom Node structure will represent our spanning tree
     *  @param  root    root of undirected graph from 0 to numberOfNodes-1
    */
    public static Node<Integer> spanningTree(int root){
        Node<Integer> tree = new Node<Integer>(root);
        Node<Integer> currentNode;
        Integer currentNodeData;

        LinkedList<Node<Integer>> discoveredNodes = new LinkedList<Node<Integer>>();
        LinkedList<Node<Integer>> queue = new LinkedList<Node<Integer>>();

        queue.add(tree);
        discoveredNodes.add(tree);
        while(queue.size() > 0){
            currentNode = queue.removeFirst();
            currentNodeData = currentNode.getData();
            for(int i = 0; i < randomGraph.length; i++){
                if(randomGraph[currentNodeData][i] && !listContainsNode(discoveredNodes, i)){
                    Node<Integer> newNode = new Node<Integer>(i, currentNode);
                    queue.add(newNode);
                    discoveredNodes.add(newNode);
                }
            }
        }
        return tree;
    }

    /* Helper Methods */
    // search a list of Nodes for a value
    public static boolean listContainsNode(List<Node<Integer>> list, Integer data){
        for(Node<Integer> n : list)
            if(n.getData() == data)
                return true;
        return false;
    }
}

import java.util.*；
/**
*用于区分快集和慢集中节点的自定义类型集
*/
枚举集{
快，慢；
}
/**
*用于存储生成树的自定义节点类
*/
类节点{
私有T数据；
私有节点父节点；
私人名单儿童；
私有整数级；
私有整数秩；
私有集；
//根节点和独立节点的构造函数
公共节点（T数据）{
这个数据=数据；
this.parent=null；
这个水平=0；
this.rank=Integer.MIN_值；
this.children=new ArrayList（）；
}
//所有非根节点的构造函数
公共节点（T数据，节点父节点）{
这个数据=数据；
这个.setParent（parent）；
this.level=（parent.getLevel（））+1；
this.rank=Integer.MIN_值；
this.children=new ArrayList（）；
}
//获取数据
公共T getData（）{
返回此.data；
}
//设置数据
公共无效设置数据（T数据）{
这个数据=数据；
}
//添加子节点
公共void addChild（节点子节点）{
添加（child）；
}
//删除子节点
public void removeChild（节点子节点）{
儿童。移除（儿童）；
}
//排名
public int getRank（）{
返回此.rank；
}
//定级
公共无效设置秩（整数秩）{
这个.等级=等级；
}
//得到父母
公共节点getParent（）{
将此文件返回给父对象；
}
//设置父节点-将父节点更新为具有子节点
公共void setParent（节点父节点）{
this.parent=parent；
parent.addChild（this）；
}
//返回节点的级别
public int getLevel（）{
返回此.level；
}
//返回给定节点的子节点列表
公共列表getChildren（）{
把这个还给孩子们；
}
//设置节点所在的集合
公共无效集合（集合）{
this.set=set；
}
//获取节点所在的集合
公共集getSet（）{
返回此.set；
}
//使用DFS遍历将树作为节点列表返回
公共列表树列表（）{
列表=新建LinkedList（）；
List visitedNodes=新建LinkedList（）；
列表。添加（此）；
while（list.size（）>0）{
节点currentNode=list.get（list.size（）-1）；
List currentNodesChildren=currentNode.getChildren（）；
如果（！visitedNodes.contains（currentNode））{
用于（节点n:currentNodesChildren）{
列表。添加（n）；
}
添加（当前节点）；
}
否则{
list.remove（当前节点）；
}
}
返回访问的节点；
}
//返回树中的级别数
//注意：级别从0开始
公共int numberOfLevels（）{
List=this.treeToList（）；
int maxLevel=0；
用于（节点n：列表）
如果（n.getLevel（）>maxLevel）
maxLevel=n.getLevel（）；
返回maxLevel+1；
}
//返回树中的最大秩
公共整数maxRank（）{
List=this.treeToList（）；
int-maxRank=0；
用于（节点n：列表）
如果（n.getRank（）>maxRank）
maxRank=n.getRank（）；
返回maxRank；
}
//返回FAST集中具有给定秩和级别的节点列表
公共列表nodeRankLevelSubset（整数秩，整数级）{
List=this.treeToList（）；
列表子集=新建LinkedList（）；
用于（节点n：列表）
if（n.getRank（）==rank&n.getLevel（）==level&n.getSet（）==Set.FAST）
子集。添加（n）；
返回子集；
}
//全部打印
public void printAll（）{
List=this.treeToList（）；
用于（节点n：列表）{
System.out.println（“{”）；
System.out.println（“\”数据\“：“+n.getData（）+”，”）；
System.out.println（“\”level\”：“+n.getLevel（）+”，”）；
System.out.println（“\'rank\”：“+n.getRank（）+”，”）；
开关（n.getSet（））{
不区分大小写：
System.out.println（“\”set\“：”FAST\”）；
打破
慢格：
System.out.println（“\”set\“：”SLOW\”）；
打破
}
系统输出打印（“\”父项“：”）；
如果（n.getParent（）！=null）
System.out.println（n.getParent（）.getData（）+“，”；
其他的
System.out.println（“，”）；
系统输出打印（“\”子项“：[”）；
对于（节点cn:n.getChildren（））{
System.out.print（cn.getData（）+“，”）；
}
System.out.println（“]\n}”）；
}
}
//要打印的BFS
公共void printree（）{
List discoveredNodes=new LinkedList（）；
列表队列=新建LinkedList（）；
列出儿童名单；
节点当前节点；
queue.add（这个）；
discoveredNodes.add（此）；
while（queue.size（）>0）{
currentNode=queue.remove（0）；
children=currentNode.getChildren（）；
System.out.print（“\n”+currentNode.getData（）+”：”；
用于（节点n：子节点）
/* Helper Methods */
// search a list of Nodes for a value
public static boolean listContainsNode(List<Node<Integer>> list, Integer data){
    for(Node<Integer> n : list)
        if(n.getData() == data)  // <-- Can you spot the bug?
            return true;
    return false;
}

if (n.getData().equals(data))

for(int i = 0; i < randomGraph[currentNodeData].length; i++){

for(int i = 0; i < randomGraph.length; i++){

    Integer x;
    Integer y;

    x = 111;
    y = 111;

    System.out.println(x == y);

    x = 130;
    y = 130;

    System.out.println(x == y);

true
false

    Integer x;
    Integer y;

    x = 111;
    y = 111;

    System.out.println(x.equals(y));

    x = 130;
    y = 130;

    System.out.println(x.equals(y));

true
true