「java连通图」简单图和连通图
今天给各位分享java连通图的知识，其中也会对简单图和连通图进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、Java编写四个class，目的是删除已经建立的图中的vertex。有没有哪位大侠可以帮忙
- 2、java代码怎么实现计算图像二值连通区域的质心
- 3、JAVA如何生成一个随机的有向连通图
- 4、求代码，java实验，题目如图
Java编写四个class，目的是删除已经建立的图中的vertex。有没有哪位大侠可以帮忙
不好意思刚才看错了。其实你这个问题很简单。其本思路是：
使用一个SetPoint在开始检查时，把图里面的所有点都放入一个SetPoint中
然后，取图中的任意一点进行遍历图，记住注意递归图时别产生无限循环,也就是在已访问的节点设置一个标识值。
最后得出的结果是：Set is empty:图为连通图。
Set is not empty:图中有部分节点不连通。
在实现上可以使用另一个SetPoint记录已访问的节点，如果存在则。然后，可以使用遍历图的算法进行遍历,当访问到当前节点时就从records中删除当前节点,并记住向accessed添加point节点。方法定义如下：
class Point{
private ListPoint relatives;//相连的节点
}
public void checkGraphics(SetPoint accessed,SetPoint records,Point start){
if(!accessed.contains(start)){
///进行下一步遍历，记住下一步遍历时，先进行标识,晕，说着，说着实现完了，干脆帮你写完吧。
accessed.add(start);
records.remove(start);
for(Point p:start.relatives){
checkGraphics(accessed,records,p);
}
}
}
最后记得判断records集合是否为空。 核心算法已完成
java代码怎么实现计算图像二值连通区域的质心
一：几何距(Geometric
Moments)知识与质心寻找原理
1.
Image
Moments是图像处理中非常有用的算法，可以用来计算区域图像的质心，方向等几何特性，同时Mpq的高阶具有旋转不变性，可以用来实现图像比较分类，正是因为Moments有这些特性，很多手绘油画效果也会基于该算法来模拟实现。它的数学表达为：
它的低阶M00，M01,
M10可以用来计算质心，中心化以后M11,M02,M20可以用来计算区域的方向/角度
2.
什么是质心
就是通过该点，区域达到一种质量上的平衡状态，可能物理学上讲的比较多，简单点的说就是规则几何物体的中心，不规则的可以通过挂绳子的方法来寻找。
二：算法流程
1.
输入图像转换为二值图像
2.
通过连通组件标记算法找到所有的连通区域，并分别标记
3.
对每个连通区域运用计算几何距算法得到质心
4.
用不同颜色绘制连通区域与质心，输出处理后图像
三：算法效果
左边为原图，
右边蓝色为连通组件标记算法处理以后结果，白色点为质心
四：关键代码解析
1.
计算几何距算法代码
doublem00
=
moments(pixels,
width,
height,
0,
0);
doublexCr
=
moments(pixels,
width,
height,
1,
0)
/
m00;//
row
doubleyCr
=
moments(pixels,
width,
height,
0,
1)
/
m00;//
column
return
new
double[]{xCr,
yCr};
JAVA如何生成一个随机的有向连通图
很简单，全部的边存在就是强连通的（要去掉一部分也可以） 也可以把所有点组成一个有向圈 再随机加点边就是了
把矩阵所有的成员都赋一个大于零的随机数
求代码，java实验，题目如图
import java.util.Scanner;
import java.util.Stack;
public class DFS
{
// 存储节点信息
private char[] vertices;
// 存储边信息（邻接矩阵）
private int[][] arcs;
// 图的节点数
private int vexnum;
// 记录节点是否已被遍历
private boolean[] visited;
// 初始化
public DFS(int n)
{
vexnum = n;
vertices = new char[n];
arcs = new int[n][n];
visited = new boolean[n];
for(int i = 0; i vexnum; i++)
{
for(int j = 0; j vexnum; j++)
{
arcs[i][j] = 0;
}
}
}
// 添加边(无向图)
public void addEdge(int i, int j)
{
// 边的头尾不能为同一节点
if(i == j)
return;
arcs[i - 1][j - 1] = 1;
arcs[j - 1][i - 1] = 1;
}
// 设置节点集
public void setVertices(char[] vertices)
{
this.vertices = vertices;
}
// 设置节点访问标记
public void setVisited(boolean[] visited)
{
this.visited = visited;
}
// 打印遍历节点
public void visit(int i)
{
System.out.print(vertices[i] + " ");
}
// 从第i个节点开始深度优先遍历
private void traverse(int i)
{
// 标记第i个节点已遍历
visited[i] = true;
// 打印当前遍历的节点
visit(i);
// 遍历邻接矩阵中第i个节点的直接联通关系
for(int j = 0; j vexnum; j++)
{
// 目标节点与当前节点直接联通，并且该节点还没有被访问，递归
if(arcs[i][j] == 1 visited[j] == false)
{
traverse(j);
}
}
}
// 图的深度优先遍历（递归）
public void DFSTraverse(int start)
{
// 初始化节点遍历标记
for(int i = 0; i vexnum; i++)
{
visited[i] = false;
}
// 从没有被遍历的节点开始深度遍历
for(int i = start - 1; i vexnum; i++)
{
if(visited[i] == false)
{
// 若是连通图，只会执行一次
traverse(i);
}
}
}
// 图的深度优先遍历（非递归）
public void DFSTraverse2(int start)
{
// 初始化节点遍历标记
for(int i = 0; i vexnum; i++)
{
visited[i] = false;
}
StackInteger s = new StackInteger();
for(int i = start - 1; i vexnum; i++)
{
if(!visited[i])
{
// 连通子图起始节点
s.add(i);
do
{
// 出栈
int curr = s.pop();
// 如果该节点还没有被遍历，则遍历该节点并将子节点入栈
if(visited[curr] == false)
{
// 遍历并打印
visit(curr);
visited[curr] = true;
// 没遍历的子节点入栈
for(int j = vexnum - 1; j = 0; j--)
{
if(arcs[curr][j] == 1 visited[j] == false)
{
s.add(j);
}
}
}
} while(!s.isEmpty());
}
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int N, M, S;
while(true)
{
System.out.println("输入N M S，分别表示图G的结点数，边数，搜索的起点：");
String line = sc.nextLine();
if(!line.matches("^\\s*([1-9]\\d?|100)(\\s+([1-9]\\d?|100)){2}\\s*$"))
{
System.out.print("输入错误，");
continue;
}
String[] arr = line.trim().split("\\s+");
N = Integer.parseInt(arr[0]);
M = Integer.parseInt(arr[1]);
S = Integer.parseInt(arr[2]);
break;
}
DFS g = new DFS(N);
char[] vertices = new char[N];
for(int i = 0; i N; i++)
{
vertices[i] = (i + 1 + "").charAt(0);
}
g.setVertices(vertices);
for(int m = 0; m M; m++)
{
System.out.println("输入图G的第" + (m + 1) + "条边，格式为“i j”，其中i，j为结点编号（范围是1~N）");
String line = sc.nextLine();
if(!line.matches("^\\s*([1-9]\\d?|100)\\s+([1-9]\\d?|100)\\s*$"))
{
System.out.print("输入错误，");
m--;
continue;
}
String[] arr = line.trim().split("\\s+");
int i = Integer.parseInt(arr[0]);
int j = Integer.parseInt(arr[1]);
g.addEdge(i, j);
}
sc.close();
System.out.print("深度优先遍历（递归）：");
g.DFSTraverse(S);
System.out.println();
System.out.print("深度优先遍历（非递归）：");
g.DFSTraverse2(S);
}
}
关于java连通图和简单图和连通图的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。