Question

我是一名学生，并且从我的数据结构和算法课程中获得了这个项目：

•生成具有100,000个节点的图，其中每个节点随机具有与其他节点的1至5个连接。 •每个节点内应包含1到300,000之间的随机值。（因此，通常约三分之一的搜索将产生查询匹配） •允许用户输入要搜索的数字，并实现以下三种搜索算法中的每一种。

•广度优先。 •深度优先。 •Dijkstra的算法。

•不允许在搜索中回溯。（将已经搜索过的节点标记为已完成，并且不要在同一搜索中重新访问它们） •每次搜索应返回以下内容： •搜索成功/失败。 •到找到的节点的最短路径的长度。 •搜索过程中检查的节点总数。

我们最终将其作为图形和搜索算法实现的最终NO惯例...我编写了以下代码，在运行它时绝对没有任何作用，请记住，这只是我到目前为止所做的： / p>

package finalproject;

import java.util.Random;

import finalproject.RandomGraph.GraphNodes;

public class GenerateGraph {

    public static void main(String[] args) {
         Random random = new Random();        
            int num = random.nextInt(300000) + 1;

            RandomGraph graph = new RandomGraph();
            GraphNodes gn = graph.new GraphNodes(0, num);

            for(int i = 0; i < 100000; i++)
            {
                num = random.nextInt(300000) + 1;

                gn.adjacent.add(graph.new GraphNodes(i, num));
            }




    }

    }

package finalproject;

import java.util.LinkedList;
import java.util.HashMap;
import java.util.HashSet;



public class RandomGraph {

    public HashMap<Integer,GraphNodes> nodeLookup = new HashMap<Integer, GraphNodes>();

    public class GraphNodes
    {
        public int Nodeid; 
        public int Nodevaule; 

        LinkedList<GraphNodes> adjacent = new LinkedList<GraphNodes>();

        GraphNodes(int Nodeid, int Nodevalue) 
        {
            this.Nodeid = Nodeid;
            this.Nodeid = Nodevalue;

        }

    public GraphNodes getGraphNodes(int Nodeid)
    {
        GraphNodes sn = nodeLookup.get(Nodeid);
        return sn;
    }

    public void addEdge(int sourceNode, int destinationNode)
    {
        GraphNodes sn = getGraphNodes(sourceNode);
        GraphNodes dn = getGraphNodes(destinationNode);

        sn.adjacent.add(dn);

    }


public boolean hasPathDFS(int sourceNode, int destinationNode)
{
    GraphNodes sn = getGraphNodes(sourceNode);
    GraphNodes dn = getGraphNodes(destinationNode);


    HashSet<Integer> visited = new HashSet<Integer>();
    return hasPathDFS(sn, dn, visited);
}




public boolean hasPathDFS(GraphNodes sourceNode, GraphNodes destinationNode, HashSet<Integer> visited)
{
    if(visited.contains(sourceNode.Nodeid))
    {
        return false;
    }

    visited.add(sourceNode.Nodeid);
    if(sourceNode == destinationNode)
    {
        return true;
    }

    for(GraphNodes child : sourceNode.adjacent)
    {
        if(hasPathDFS(child, destinationNode, visited))
        {
            return true;
        }
    }
    return false;                
}

public boolean hasPathBFS(GraphNodes sourceNode, GraphNodes destinationNode)
{
    LinkedList<GraphNodes> nextToVisit = new LinkedList<GraphNodes>();
    HashSet<Integer> visited = new HashSet<Integer>();
    nextToVisit.add(sourceNode);

    while(!nextToVisit.isEmpty())
    {
        GraphNodes graphNodes = nextToVisit.remove();

        if(graphNodes == destinationNode)
        {
            return true;
        }

        if(visited.contains(graphNodes.Nodeid))
        {
            continue;
        }

        visited.add(graphNodes.Nodeid);

        for(GraphNodes child : graphNodes.adjacent)
        {
            nextToVisit.add(child);
        }
    }

    return false;
}
}



}

我要离开还是走正确的路？任何帮助都将是非常有用的，因为我一次键入一次击键（肢体残疾），并且感觉就像是一头鹿，因为这甚至是我在Java类入门中介绍的内容。本学期我已经在其他两种编程语言之间切换。我很生气，真的需要帮助，所以请不要对我太苛刻。

创建一个100,000个节点的图并运行BFS，DFS和Dijkstra的算法搜索

0 个答案: