标签：大致 ict oschina array 数值 mat find 数组 结构
如图就是一张图，其实之前介绍的树、链表都可以看做一个简单的图。
图描述的是一种多对多的关系，由顶点(vertex)和连接顶点间的边(edge)组成。每个顶点可以有零个或多个前驱、也可以有零个或多个后继。
注：图可以没有边，但至少有一个顶点。
因此图可以表示成G=(V,E)。V即顶点的集合、E为边的集合。
G = (V,E)。 其中，VE={<v,w>|v,w\(\in\)V且P(v,w)}。
<v,w>是从v到w的一条边，有方向的，与<w,v>不一样的。P(v,w)是定义在<v,w>上的权值信息(即赋予的有意义的数值或信息)。
假使图中有n个顶点，e条边。
若有e=n(n-1)/2条无向边，则是无向完全图。
若有e=n(n-1)条有向边，则是有向完全图。
若e<nlogn则称作稀疏图，否则为稠密图。
如下图，右边的就是左边图的邻接矩阵表示。即记录每个顶点与其他所有点是否存在边，存在则标1，否则为0。
标志信息也可以根据实际情况表示，如权值等。
无向图该矩阵是对称的，有向图则不一定。
如下图所示，每个顶点指向了一个链表，链表里记录了所有存在边的顶点在数组中的位置。
图的遍历都以这个有向图为例进行说明的。
从图中某个顶点V0出发，访问V0，然后依次以v0相连的顶点为出发点向后访问。依次类推，直到所有与V0顶点相连的所有结点都被访问到。 如果图中仍有未访问的顶点，则该图为非连通图，在图中未访问的顶点选择一个顶点为起点，并重复上述过程，直到访问完图中的所有顶点为止。
下面分别是使用邻接矩阵和邻接表表示的图 实现的深度优先的demo，可以大致看看了解下。
邻接矩阵表示的图
注意，邻接矩阵表示 使用的非递归方法实现，通过栈来实现的
import java.util.ArrayList;
import java.util.Stack;
//深度优先：使用邻接矩阵存储方式
public class DFSArrayTest {
static ArrayList<Node> nodes = new ArrayList<>();
static class Node {
char data;//数据
boolean visited;//是否访问过标志
Node(char data) {
this.data = data;
}
}
//查找某顶点在邻接矩阵中的邻接点
public ArrayList<Node> findNeighbours(int adjacency_matrix[][], Node x) {
int nodeIndex = -1;
ArrayList<Node> neighbours = new ArrayList<>();
for (int i = 0; i < nodes.size(); i++) {
if (nodes.get(i).equals(x)) {
nodeIndex = i;
break;
}
}
if (nodeIndex != -1) {
for (int j = 0; j < adjacency_matrix[nodeIndex].length; j++) {
if (adjacency_matrix[nodeIndex][j] == 1) {
neighbours.add(nodes.get(j));
}
}
}
return neighbours;
}
//使用栈实现深度优先
public void dfsUseStack(int adjacency_matrix[][], Node node) {
Stack<Node> stack = new Stack<>();
stack.add(node);
while (!stack.isEmpty()) {
Node element = stack.pop();
if (!element.visited) {
System.out.print(element.data + " ");
element.visited = true;
}
ArrayList<Node> neighbours = findNeighbours(adjacency_matrix, element);
for (int i = 0; i < neighbours.size(); i++) {
Node n = neighbours.get(i);
if (n != null && !n.visited) {
stack.add(n);
}
}
}
}
public static void clearVisitedFlags() {
for (int i = 0; i < nodes.size(); i++) {
nodes.get(i).visited = false;
}
}
public static void main(String arg[]) {
Node nodeA = new Node(‘A‘);
Node nodeB = new Node(‘B‘);
Node nodeC = new Node(‘C‘);
Node nodeD = new Node(‘D‘);
Node nodeE = new Node(‘E‘);
int adjacency_matrix[][] = {
//A B C D E
{ 0, 1, 0, 0, 1 }, // A
{ 0, 0, 0, 1, 0 }, // B
{ 1, 0, 0, 0, 0 }, // C
{ 0, 0, 1, 0, 0 }, // D
{ 0, 0, 0, 1, 0 } // E
};
nodes.add(nodeA);nodes.add(nodeB);nodes.add(nodeC);nodes.add(nodeD);nodes.add(nodeE);
DFSArrayTest dfsArrayTest = new DFSArrayTest();
System.out.println("DFSArray(以C为开始顶点):");
dfsArrayTest.dfsUseStack(adjacency_matrix, nodeC);
System.out.println();
clearVisitedFlags();
System.out.println("DFSArray(以A为开始顶点):");
dfsArrayTest.dfsUseStack(adjacency_matrix, nodeA);
}
}
结果如下：
DFSArray(以C为开始顶点):
C A E D B
DFSArray(以A为开始顶点):
A E D C B
邻接表 表示的图
注意，邻接表表示 使用的是递归方法实现
import java.util.ArrayList;
import java.util.LinkedList;
//深度优先：使用邻接表存储方式
class DFSLinkedTest {
static class Node {
char data;//数据
boolean visited;//是否访问过的标志
LinkedList<Node> neighbours;//所有邻接点
Node(char data) {
this.data = data;
this.neighbours = new LinkedList<>();
}
}
//深度遍历，node为开始顶点
private void dfsUtil(Node node) {
node.visited = true;
System.out.print(node.data + " ");
for (int i = 0; i < node.neighbours.size(); i++) {
Node neighbourNode = node.neighbours.get(i);
if (neighbourNode != null && !neighbourNode.visited) {
dfsUtil(neighbourNode);
}
}
}
//恢复所有顶点标志到未访问
private void clearVisitedFlags(ArrayList<Node> nodes) {
for (int i = 0; i < nodes.size(); i++) {
nodes.get(i).visited = false;
}
}
public static void main(String args[]) {
DFSLinkedTest dfsLinkedTest = new DFSLinkedTest();
ArrayList<Node> nodes = new ArrayList<>();
Node nodeA = new Node(‘A‘);
Node nodeB = new Node(‘B‘);
Node nodeC = new Node(‘C‘);
Node nodeD = new Node(‘D‘);
Node nodeE = new Node(‘E‘);
nodeA.neighbours.add(nodeB);
nodeA.neighbours.add(nodeE);
nodeB.neighbours.add(nodeD);
nodeC.neighbours.add(nodeA);
nodeD.neighbours.add(nodeC);
nodeE.neighbours.add(nodeD);
nodes.add(nodeA);nodes.add(nodeB);nodes.add(nodeC);nodes.add(nodeD);nodes.add(nodeE);
dfsLinkedTest.clearVisitedFlags(nodes);
System.out.println("DFSLinked(以C为开始顶点):");
dfsLinkedTest.dfsUtil(nodeC);
System.out.println();
dfsLinkedTest.clearVisitedFlags(nodes);
System.out.println("DFSLinked(以A为开始顶点):");
dfsLinkedTest.dfsUtil(nodeA);
}
}
结果如下：
DFSLinked(以C为开始顶点):
C A B D E
DFSLinked(以A为开始顶点):
A B D C E
从图中的某个顶点V0开始，访问V0,然后依次访问V0的所有未访问的邻接点，然后以访问这些顶点的顺序访问它们的邻接点，直到所有顶点在都被访问到。如果图中仍有未访问的顶点，则该图为非连通图，在图中未访问的顶点选择一个顶点为起点，并重复上述过程，直到访问完图中的所有顶点为止。
同样 下面分别是使用邻接矩阵和邻接表表示的图 实现的广度优先的demo，可以大致看看了解下。
邻接矩阵表示的图
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
//广度优先：使用邻接矩阵存储方式
public class BFSArrayTest {
private Queue<Node> queue;
static ArrayList<Node> nodes = new ArrayList<Node>();
//顶点定义
static class Node {
char data;
boolean visited;
Node(char data) {
this.data = data;
}
}
public BFSArrayTest() {
queue = new LinkedList<Node>();
}
//查找某顶点在邻接矩阵中的邻接点
public ArrayList<Node> findNeighbours(int adjacency_matrix[][], Node x) {
int nodeIndex = -1;
ArrayList<Node> neighbours = new ArrayList<Node>();
for (int i = 0; i < nodes.size(); i++) {
if (nodes.get(i).equals(x)) {
nodeIndex = i;
break;
}
}
if (nodeIndex != -1) {
for (int j = 0; j < adjacency_matrix[nodeIndex].length; j++) {
if (adjacency_matrix[nodeIndex][j] == 1) {
neighbours.add(nodes.get(j));
}
}
}
return neighbours;
}
public void bfsUtil(int adjacency_matrix[][], Node node) {
queue.add(node);
node.visited = true;
while (!queue.isEmpty()) {
Node element = queue.remove();
System.out.print(element.data + " ");
ArrayList<Node> neighbours = findNeighbours(adjacency_matrix, element);
for (int i = 0; i < neighbours.size(); i++) {
Node n = neighbours.get(i);
if (n != null && !n.visited) {
queue.add(n);
n.visited = true;
}
}
}
}
public void clearVisitedFlags() {
for (int i = 0; i < nodes.size(); i++) {
nodes.get(i).visited = false;
}
}
public static void main(String arg[]) {
Node nodeA = new Node(‘A‘);
Node nodeB = new Node(‘B‘);
Node nodeC = new Node(‘C‘);
Node nodeD = new Node(‘D‘);
Node nodeE = new Node(‘E‘);
int adjacency_matrix[][] = {
//A B C D E
{ 0, 1, 0, 0, 1 }, // A
{ 0, 0, 0, 1, 0 }, // B
{ 1, 0, 0, 0, 0 }, // C
{ 0, 0, 1, 0, 0 }, // D
{ 0, 0, 0, 1, 0 } // E
};
nodes.add(nodeA);nodes.add(nodeB);nodes.add(nodeC);nodes.add(nodeD);nodes.add(nodeE);
BFSArrayTest bfsArrayTest = new BFSArrayTest();
System.out.println("BFSArray(以C为开始顶点):");
bfsArrayTest.bfsUtil(adjacency_matrix, nodeC);
System.out.println();
bfsArrayTest.clearVisitedFlags();
System.out.println("BFSArray(以A为开始顶点):");
bfsArrayTest.bfsUtil(adjacency_matrix, nodeA);
}
}
结果如下：
BFSArray(以C为开始顶点):
C A B E D
BFSArray(以A为开始顶点):
A B E D C
邻接表表示的图
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
//广度优先：使用邻接表存储方式
public class BFSLinkedTest {
private Queue<Node> queue;
static ArrayList<Node> nodes = new ArrayList<Node>();
static class Node {
char data;
boolean visited;
LinkedList<Node> neighbours;
Node(char data) {
this.data = data;
this.neighbours = new LinkedList<>();
}
}
public BFSLinkedTest() {
queue = new LinkedList<Node>();
}
public void bfsUtil(Node node) {
queue.add(node);
node.visited = true;
while (!queue.isEmpty()) {
Node element = queue.remove();
System.out.print(element.data + " ");
for (int i = 0; i < element.neighbours.size(); i++) {
Node n = element.neighbours.get(i);
if (n != null && !n.visited) {
queue.add(n);
n.visited = true;
}
}
}
}
private void clearVisitedFlags(ArrayList<Node> nodes) {
for (int i = 0; i < nodes.size(); i++) {
nodes.get(i).visited = false;
}
}
public static void main(String arg[]) {
ArrayList<Node> nodes = new ArrayList<>();
Node nodeA = new Node(‘A‘);
Node nodeB = new Node(‘B‘);
Node nodeC = new Node(‘C‘);
Node nodeD = new Node(‘D‘);
Node nodeE = new Node(‘E‘);
nodeA.neighbours.add(nodeB);
nodeA.neighbours.add(nodeE);
nodeB.neighbours.add(nodeD);
nodeC.neighbours.add(nodeA);
nodeD.neighbours.add(nodeC);
nodeE.neighbours.add(nodeD);
BFSLinkedTest bfsLinkedTest = new BFSLinkedTest();
nodes.add(nodeA);nodes.add(nodeB);nodes.add(nodeC);nodes.add(nodeD);nodes.add(nodeE);
bfsLinkedTest.clearVisitedFlags(nodes);
System.out.println("BFSLinked(以C为开始顶点):");
bfsLinkedTest.bfsUtil(nodeC);
System.out.println();
bfsLinkedTest.clearVisitedFlags(nodes);
System.out.println("BFSLinked(以A为开始顶点):");
bfsLinkedTest.bfsUtil(nodeA);
}
}
结果如下：
BFSLinked(以C为开始顶点):
C A B E D
BFSLinked(以A为开始顶点):
A B E D C
标签：大致 ict oschina array 数值 mat find 数组 结构
原文地址：https://www.cnblogs.com/fanglongxiang/p/13180568.html
