一、图结构
图有很多种存储方式,主要有邻接表和邻接矩阵两种。邻接表以点集为单位,邻接矩阵以边集为单位。
可以平时用自己熟悉的图结构来实现图的算法,因为算法都是一样的,所以考试时可以写接口将不同的图结构转换成自己熟悉的图结构,来实现算法。
//图的大结构
public class Graph {
public HashMap<Integer,Node> nodes; //点集
public HashSet<Edge> edges; //边集
public Graph(){
nodes = new HashMap<>();
edges = new HashSet<>();
}
}
//点结构
public class Node {
public int value;
public int in;
public int out;
public ArrayList<Node> nexts;
public ArrayList<Edge> edges;
public Node(int value){
this.value = value;
this.in = 0;
this.out = 0;
this.nexts = new ArrayList<>();
this.edges = new ArrayList<>();
}
}
//边结构
public class Edges {
public int value;
public Node from;
public Node to;
public Edge(int weight, Node from, Node to){
this.value = weight;
this.from = from;
this.to = to;
}
}
//转换接口例子:用一个二维数组来表示图,格式为: 权值 = matrix[0][0] from点 = matrix[0][1] to点 = matrix[0][2]
public class Graph createGraph(Integer[][] matrix){
Graph graph = new Graph();
for(int i = 0; i < matrix.length; i++){
//先从数组中获得form点、to点、权值的值
Integer weight = matrix[i][0];
Integer from = matrix[i][1];
Integer to = matrix[i][2];
//将from点和to点加到图里
if(!graph.nodes.containskey(from)){
graph.nodes.put(from,new Node(from));
}
if(!graph.nodes.containsket(from)){
graph.nodes.put(to,new Node(to));
}
//获取from点和to点
Node fromNode = graph.nodes.get(from);
Node toNode = graph.nodes.get(to);
//form点、to点和权重组成一条边
Edge newEdge = new Edge(weight,fromNode,toNode);
//from点的邻接点集加入to点
fromNode.nexts.add(toNode);
//from点出度加一
formNode.out++;
//to点出度加一
toNode.in++;
//将这条边加入form点属于的边集里
formNode.edges.add(newEdge);
//将这条边加入图的边集里
graph.edges.add(newEdge);
}
return graph;
}
二、图的宽度优先遍历
// 1.利用队列实现
// 2.从源节点开始一次按照宽度进队,然后弹出
// 3.每弹出一个点,就把该节点所有的没有进过队列的直接邻接节点放进队列
// 4.一直弹出直到队列为空
public static void bfs(Node node){
if(head == null){
return;
}
Queue<Node> queue = new LinkedList<>();
HashSet<Node> set = new HashSet<>();
queue.add(node);
set.add(node);
while(!queue.isEmpty()){
Node cur = queue.poll();
System.out.println(cur.value);
for(Node next : cur.nexts){
if(!set.contains(next){
queue.add(next);
set.add(next);
}
}
}
}
三、图的深度优先遍历
// 1.利用栈实现
// 2.从源节点开始把节点按照深度方式放进栈中,打印,然后弹出
// 3.每弹出一个节点,把该节点下一个没有进过栈的邻接节点放进栈中,打印,弹出
// 4.重复上述过程,直到栈变空
public static void dfs(Node node){
if(node == null){
return;
}
Stack<Node> stack = new Stack<>();
HashSet<Node> set = new HashSer<>();
stack.add(node);
set.add(node);
System.out.println(node.value);
while(!stack.isEmpty()){
//弹出栈顶节点
Node.cur = stack.pop