算法整理05——Java图的概念和BFS&DFS

1、图是由顶点集合以及顶点间的关系集合组成的一种数据结构。Graph = (V,E)  V是顶点的又穷非空集合；E是顶点之间关系的有穷集合，也叫边集合。

2、图的表示方法

2.1、邻接矩阵和邻接表，这两种方法常在概念里面比较多，

2.2、实际笔试中，经常用一个多行三列的矩阵，每一行是一条边，经常是第一列代表该边的权值，第二列是边的起点，第三列是边的终点to。

2.3、生成图一般用四个类，节点类、边类、图类、生成图类。

节点类

import java.util.ArrayList;

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;
		in = 0;
		out = 0;
		nexts = new ArrayList<>();
		edges = new ArrayList<>();
	}
}

边类

public class Edge {
	public int weight;//权重
	public Node from;//
	public Node to;

	public Edge(int weight, Node from, Node to) {
		this.weight = weight;
		this.from = from;
		this.to = to;
	}

}

图类

import java.util.HashMap;
import java.util.HashSet;
//我的图就是所有点的集合和边的集合
public class Graph {
	public HashMap<Integer,Node> nodes;
	public HashSet<Edge> edges;

	public Graph() {
		nodes = new HashMap<>();
		edges = new HashSet<>();
	}
}

生成图类

public class GraphGenerator {

	public static Graph createGraph(Integer[][] matrix) {
		Graph graph = new Graph();
		for (int i = 0; i < matrix.length; i++) {
			Integer weight = matrix[i][0];//该边的权仲
			Integer from = matrix[i][1];//出点 的序列
			Integer to = matrix[i][2];//入点的序列
			if (!graph.nodes.containsKey(from)) {
				graph.nodes.put(from, new Node(from));
			}
			if (!graph.nodes.containsKey(to)) {
				graph.nodes.put(to, new Node(to));
			}
			Node fromNode = graph.nodes.get(from);
			Node toNode = graph.nodes.get(to);
			Edge newEdge = new Edge(weight, fromNode, toNode);
			fromNode.nexts.add(toNode);
			fromNode.out++;
			toNode.in++;
			fromNode.edges.add(newEdge);
			graph.edges.add(newEdge);
		}
		return graph;
	}

}

通过以上四个类，给我一个矩阵，我就能生成一个graph。

3、BFS

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;

public class Code_01_BFS {

	public static void bfs(Node node) {
		if (node == null) {
			return;
		}
		Queue<Node> queue = new LinkedList<>();
		HashSet<Node> set = new HashSet<>();//进过队列 set就保留，相当于注册一下。
		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)) {
					set.add(next);
					queue.add(next);
				}
			}
		}
	}

}

DFS

import java.util.HashSet;
import java.util.Stack;

public class Code_02_DFS {

	public static void dfs(Node node) {
		if (node == null) {
			return;
		}
		Stack<Node> stack = new Stack<>();
		HashSet<Node> set = new HashSet<>();//表示同样的东西不要重复进队列
		stack.add(node);
		set.add(node);
		System.out.println(node.value);
		while (!stack.isEmpty()) {
			Node cur = stack.pop();
			for (Node next : cur.nexts) {
				if (!set.contains(next)) {
					stack.push(cur);
					stack.push(next);
					set.add(next);
					System.out.println(next.value);
					break;
				}
			}
		}
	}