左神算法笔记之图——图结构、图的宽度优先遍历、图的深度优先遍历、图的拓扑排序算法、图生成最小生成树（k算法和p算法）、图中求单元最短路径（Dijkstra算法）、前缀树_左神算法网盘

一、图结构

图有很多种存储方式，主要有邻接表和邻接矩阵两种。邻接表以点集为单位，邻接矩阵以边集为单位。
可以平时用自己熟悉的图结构来实现图的算法，因为算法都是一样的，所以考试时可以写接口将不同的图结构转换成自己熟悉的图结构，来实现算法。

//图的大结构
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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

二、图的宽度优先遍历

// 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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

三、图的深度优先遍历

// 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20