Java 如何构造图？
我正在做一个项目，这个项目涉及通过数据文件进行解析并将其读入图形。在这个图中，我必须找到两个顶点之间的最短距离。事实上，我已经试了几天了，但我似乎都不知道怎么才能把这张图画出来 我尝试使用Dijkstra的算法，但我认为简单的BFS会更简单，更容易理解，但我不知道如何首先构造图Java 如何构造图？,java,graph,breadth-first-search,treenode,Java,Graph,Breadth First Search,Treenode,我正在做一个项目，这个项目涉及通过数据文件进行解析并将其读入图形。在这个图中，我必须找到两个顶点之间的最短距离。事实上，我已经试了几天了，但我似乎都不知道怎么才能把这张图画出来 我尝试使用Dijkstra的算法，但我认为简单的BFS会更简单，更容易理解，但我不知道如何首先构造图 import java.util.ArrayList; /* * Here we create an undirected graph */ public class Graph { publi
import java.util.ArrayList;
/*
* Here we create an undirected graph
*/
public class Graph
{
public int [][] adjmatrix;
public int vertices;
public Graph(int vertices)
{
// TODO Auto-generated constructor stub
adjmatrix = new int[vertices][vertices];
this.vertices = vertices;
}
public void addEdge(String actor, String actor2, String movie)
{
if(getVertex(actor) == -1)
{
}
}
public int[] neighbors(int vertex)
{
ArrayList<Integer> neighbors = new ArrayList<>();
for (int i = 0; i < vertices; i++) {
if(adjmatrix[vertex][i] == 0)
{
neighbors.add(i);
}
}
int size = neighbors.size();
int[] neighbor = new int[size];
for(int i = 0; i < size; i++){
neighbor[i] = neighbors.get(i);
}
return neighbor;
}
public void makePath(String actor, String actor2)
{
}
}
import java.util.ArrayList；
/*
*这里我们创建一个无向图
*/
公共类图
{
公共int[][]调整矩阵；
公共整数顶点；
公共图（int顶点）
{
//TODO自动生成的构造函数存根
adjmatrix=新整数[顶点][顶点]；
这个。顶点=顶点；
}
public void addEdge（字符串演员、字符串演员2、字符串电影）
{
if（getVertex（actor）=-1）
{
}
}
公共int[]邻域（int顶点）
{
ArrayList邻居=新的ArrayList（）；
对于（int i=0；i<顶点；i++）{
如果（调整矩阵[顶点][i]==0）
{
加入（i）；
}
}
int size=neights.size（）；
int[]邻居=新的int[size]；
对于（int i=0；i结果是创建一个图形并生成一个查找最短距离的函数。我不需要帮助找出最短距离，因为该函数对我来说很简单，但我首先需要帮助构造图。假设你有顶点的数量（只计算有多少个顶点），使用2D数组
int[][]边=新的int[顶点][顶点]；//地图的顶点边[BeginingVertex][EndingVertex]=交叉所需的重量或时间假设您拥有顶点的数量（仅计算有多少个顶点），请使用二维数组
int[][]边=新的int[顶点][顶点]；//地图的顶点
边[BeginingVertex][EndingVertex]=交叉所需的重量或时间我建议，要创建图形（有向图）并运行BFS算法，请使用以下代码：
Graph.java：
public class Graph {
private final boolean [][]MAT;
private final int NODE_NUMBER;
public Graph(int NODE_NUMBER) {
this.NODE_NUMBER = NODE_NUMBER;
this.MAT = new boolean [NODE_NUMBER][NODE_NUMBER];
}
public void addEdge(int nodeA , int nodeB){
this.MAT[nodeA][nodeB] = true;
}
public boolean hasEdge(int nodeA, int nodeB){
return MAT[nodeA][nodeB];
}
public final int getNodeSize(){
return NODE_NUMBER;
}
}
import java.util.ArrayList;
import java.util.List;
public class BfsResult {
private final int root;
private final boolean []visited;
private final int []distance;
private final int []parent;
public BfsResult(int root, boolean[] visited, int[] distance, int[] parent) {
this.root = root;
this.visited = visited;
this.distance = distance;
this.parent = parent;
}
public int getRoot() {
return root;
}
public int getParent(int node){
return parent[node];
}
public int getDistance(int node){
return distance[node];
}
public boolean isAccessible(int node){
return visited[node];
}
public int[] getPath(int node){
List<Integer> path = new ArrayList <>( );
int cur = node;
do{
path.add( cur );
cur = parent[cur];
}while ( cur != -1 );
int []pathArray = new int[path.size()];
for(int i = 0 ; i < path.size() ; ++i){
pathArray[i] = path.get( path.size() - (i + 1) );
}
return pathArray;
}
public String getPathString(int node) {
int[] path = getPath( node );
StringBuilder builder = new StringBuilder( );
for ( int i = 0; i < path.length; i++ ) {
builder.append( path[i] );
if(i + 1 < path.length){
builder.append( " -> " );
}
}
return builder.toString();
}
}
BfsResult.Java：
public class Graph {
private final boolean [][]MAT;
private final int NODE_NUMBER;
public Graph(int NODE_NUMBER) {
this.NODE_NUMBER = NODE_NUMBER;
this.MAT = new boolean [NODE_NUMBER][NODE_NUMBER];
}
public void addEdge(int nodeA , int nodeB){
this.MAT[nodeA][nodeB] = true;
}
public boolean hasEdge(int nodeA, int nodeB){
return MAT[nodeA][nodeB];
}
public final int getNodeSize(){
return NODE_NUMBER;
}
}
import java.util.ArrayList;
import java.util.List;
public class BfsResult {
private final int root;
private final boolean []visited;
private final int []distance;
private final int []parent;
public BfsResult(int root, boolean[] visited, int[] distance, int[] parent) {
this.root = root;
this.visited = visited;
this.distance = distance;
this.parent = parent;
}
public int getRoot() {
return root;
}
public int getParent(int node){
return parent[node];
}
public int getDistance(int node){
return distance[node];
}
public boolean isAccessible(int node){
return visited[node];
}
public int[] getPath(int node){
List<Integer> path = new ArrayList <>( );
int cur = node;
do{
path.add( cur );
cur = parent[cur];
}while ( cur != -1 );
int []pathArray = new int[path.size()];
for(int i = 0 ; i < path.size() ; ++i){
pathArray[i] = path.get( path.size() - (i + 1) );
}
return pathArray;
}
public String getPathString(int node) {
int[] path = getPath( node );
StringBuilder builder = new StringBuilder( );
for ( int i = 0; i < path.length; i++ ) {
builder.append( path[i] );
if(i + 1 < path.length){
builder.append( " -> " );
}
}
return builder.toString();
}
}
我建议，要创建图（有向图）并运行BFS算法，请使用以下代码：
Graph.java：
public class Graph {
private final boolean [][]MAT;
private final int NODE_NUMBER;
public Graph(int NODE_NUMBER) {
this.NODE_NUMBER = NODE_NUMBER;
this.MAT = new boolean [NODE_NUMBER][NODE_NUMBER];
}
public void addEdge(int nodeA , int nodeB){
this.MAT[nodeA][nodeB] = true;
}
public boolean hasEdge(int nodeA, int nodeB){
return MAT[nodeA][nodeB];
}
public final int getNodeSize(){
return NODE_NUMBER;
}
}
import java.util.ArrayList;
import java.util.List;
public class BfsResult {
private final int root;
private final boolean []visited;
private final int []distance;
private final int []parent;
public BfsResult(int root, boolean[] visited, int[] distance, int[] parent) {
this.root = root;
this.visited = visited;
this.distance = distance;
this.parent = parent;
}
public int getRoot() {
return root;
}
public int getParent(int node){
return parent[node];
}
public int getDistance(int node){
return distance[node];
}
public boolean isAccessible(int node){
return visited[node];
}
public int[] getPath(int node){
List<Integer> path = new ArrayList <>( );
int cur = node;
do{
path.add( cur );
cur = parent[cur];
}while ( cur != -1 );
int []pathArray = new int[path.size()];
for(int i = 0 ; i < path.size() ; ++i){
pathArray[i] = path.get( path.size() - (i + 1) );
}
return pathArray;
}
public String getPathString(int node) {
int[] path = getPath( node );
StringBuilder builder = new StringBuilder( );
for ( int i = 0; i < path.length; i++ ) {
builder.append( path[i] );
if(i + 1 < path.length){
builder.append( " -> " );
}
}
return builder.toString();
}
}
BfsResult.Java：
public class Graph {
private final boolean [][]MAT;
private final int NODE_NUMBER;
public Graph(int NODE_NUMBER) {
this.NODE_NUMBER = NODE_NUMBER;
this.MAT = new boolean [NODE_NUMBER][NODE_NUMBER];
}
public void addEdge(int nodeA , int nodeB){
this.MAT[nodeA][nodeB] = true;
}
public boolean hasEdge(int nodeA, int nodeB){
return MAT[nodeA][nodeB];
}
public final int getNodeSize(){
return NODE_NUMBER;
}
}
import java.util.ArrayList;
import java.util.List;
public class BfsResult {
private final int root;
private final boolean []visited;
private final int []distance;
private final int []parent;
public BfsResult(int root, boolean[] visited, int[] distance, int[] parent) {
this.root = root;
this.visited = visited;
this.distance = distance;
this.parent = parent;
}
public int getRoot() {
return root;
}
public int getParent(int node){
return parent[node];
}
public int getDistance(int node){
return distance[node];
}
public boolean isAccessible(int node){
return visited[node];
}
public int[] getPath(int node){
List<Integer> path = new ArrayList <>( );
int cur = node;
do{
path.add( cur );
cur = parent[cur];
}while ( cur != -1 );
int []pathArray = new int[path.size()];
for(int i = 0 ; i < path.size() ; ++i){
pathArray[i] = path.get( path.size() - (i + 1) );
}
return pathArray;
}
public String getPathString(int node) {
int[] path = getPath( node );
StringBuilder builder = new StringBuilder( );
for ( int i = 0; i < path.length; i++ ) {
builder.append( path[i] );
if(i + 1 < path.length){
builder.append( " -> " );
}
}
return builder.toString();
}
}
谢谢你的意见！！实际上，我的代码中有这些代码行，但是我不知道如何填写辅助函数，例如addedge和neights。没有上下文很难解释，因此我可以通过电子邮件向您发送一张我正在尝试做的事情的图片，这会让您更容易理解。要添加边，请执行边[BeginingVertex][EndingVertex]=交叉所需的重量或时间；例如，如果顶点1和2之间有一条路径，权重为10，则可以在addEdge（）函数中执行，边[1][2]=10
。请注意，实际上应该执行边[2][1]=10
也一样。我知道这对于创建基本图是有效的，但这里的技巧是，我正在创建一个基于Kevin Bacon 6度的图，我将2000多部电影的数据导入到这个图中，因此我对邻居函数如何工作以及makeEdge函数是否与基本图实现保持一致感到困惑“我可以通过电子邮件向您发送一张我正在尝试做的事情的图片，让您更容易理解”请在帖子中添加任何基本信息。简化的图形表示可能会有所帮助。我猜每个参与者都是一个节点（vertice）在图中，边实际上是一部电影。@c0实际上我已经完成了所有的事情，但是我的BFS算法执行起来太长了，我希望你能帮助优化它，为此你需要我使用的其他文件和材料：）这就是为什么我宁愿发电子邮件感谢你的输入！！我的代码中实际上有这些代码行但是，我不知道如何填写辅助函数，如addedge和Neights。如果没有上下文，很难解释，这样我就可以通过电子邮件向您发送一张图片，让您更容易理解我正在尝试执行的操作。要添加边，请执行边[BeginingVertex][EndingVertex]=交叉所需的权重或时间；例如，如果顶点1和2之间有一条路径，权重为10，则可以在addEdge（）函数中执行，边[1][2]=10
。请注意，实际上应该执行边[2][1]=10
也一样。我知道这对创建基本图形有效，但这里的技巧是，我正在创建一个基于Kevin Bacon 6度的图形，其中我将2000多部电影的数据导入到该图形中，因此我对邻居函数如何工作以及makeEdge函数是否与基本图形实现保持一致感到困惑。”我可以通过电子邮件给你发一张我想做的事情的图片，让你更容易理解“请在帖子中添加任何基本信息。简化的图形表示可能会有所帮助。我猜每个参与者都是一个节点（vertice）在图中，边实际上是一部电影。@c0实际上我已经完成了所有的事情，但是我的BFS算法执行起来太长了，我希望你能帮助优化它，为此你需要我使用的其他文件和材料：）这就是为什么我宁愿发电子邮件的原因