如何在内存中存储图这种数据结构
邻接矩阵(Adjacency Matrix)
邻接矩阵的底层依赖一个二维数组。
对于无向图来说,如果顶点 i 与顶点 j 之间有边,我们就将 A[i][j]和 A[j][i]标记为 1;
对于有向图来说,如果顶点 i 到顶点 j 之间,有一条箭头从顶点 i 指向顶点 j 的边,那我们就将 A[i][j]标记为 1。同理,如果有一条箭头从顶点 j 指向顶点 i 的边,我们就将 A[j][i]标记为 1。对于带权图,数组中就存储相应的权重。
缺点:浪费空间。无向图会浪费一半,如果是稀疏图(Sparse Matrix),顶点很多,但每个顶点的边并不多,那邻接矩阵的存储方法就更加浪费空间了。
比如:文件的目录结构存储;微信用户的存储(10亿微信用户,但好友通常只有几百个);
优点:基于数组,所以在获取两个顶点的关系时,就非常高效。其次是方便计算。这是因为,用邻接矩阵的方式存储图,可以将很多图的运算转换成矩阵之间的运算。
邻接表(Adjacency List)
每个顶点对应一条链表,链表中存储的是与这个顶点相连接的其他顶点。
邻接表存储起来比较节省空间,但是使用起来就比较耗时间。
优化:将邻接表中的链表改成平衡二叉查找树或者红黑树、跳表等数据结构。
储微博、微信等社交网络中的好友关系
邻接表中存储了用户的关注关系,逆邻接表中存储的是用户的被关注关系。
对应到图上,邻接表中,每个顶点的链表中,存储的就是这个顶点指向的顶点,逆邻接表中,每个顶点的链表中,存储的是指向这个顶点的顶点。
数据规模大的时候:
通过哈希算法等数据分片方式,将邻接表存储在不同的机器上,或者存储在数据库。
package graph
import (
"container/list"
"fmt"
)
//adjacency table, 无向图
type Graph struct {
adj []*list.List
v int
}
//init graphh according to capacity
func newGraph(v int) *Graph {
graphh := &Graph{}
graphh.v = v
graphh.adj = make([]*list.List, v)
for i := range graphh.adj {
graphh.adj[i] = list.New()
}
return graphh
}
//insert as add edge,一条边存2次
func (self *Graph) addEdge(s int, t int) {
self.adj[s].PushBack(t)
self.adj[t].PushBack(s)
}
/*
visited 是用来记录已经被访问的顶点,用来避免顶点被重复访问。
如果顶点 q 被访问,那相应的 visited[q]会被设置为 true。
queue 是一个队列,用来存储已经被访问、但相连的顶点还没有被访问的顶点。
因为广度优先搜索是逐层访问的,也就是说,我们只有把第 k 层的顶点都访问完成之后,才能访问第 k+1 层的顶点。
当我们访问到第 k 层的顶点的时候,我们需要把第 k 层的顶点记录下来,稍后才能通过第 k 层的顶点来找第 k+1 层的顶点。
所以,我们用这个队列来实现记录的功能。
prev 用来记录搜索路径。当我们从顶点 s 开始,广度优先搜索到顶点 t 后,prev 数组中存储的就是搜索的路径。
不过,这个路径是反向存储的。prev[w]存储的是,顶点 w 是从哪个前驱顶点遍历过来的。
比如,我们通过顶点 2 的邻接表访问到顶点 3,那 prev[3]就等于 2。
为了正向打印出路径,我们需要递归地来打印,你可以看下 print() 函数的实现方式。
*/
//search path by BFS
func (self *Graph) BFS(s int, t int) {
//todo
if s == t {
return
}
//init prev
prev := make([]int, self.v)
for index := range prev {
prev[index] = -1
}
//search by queue
var queue []int
visited := make([]bool, self.v)
queue = append(queue, s)
visited[s] = true
isFound := false
for len(queue) > 0 && !isFound {
top := queue[0]
queue = queue[1:]
linkedlist := self.adj[top]
for e := linkedlist.Front(); e != nil; e = e.Next() {
k := e.Value.(int)
if !visited[k] {
prev[k] = top
if k == t {
isFound = true
break
}
queue = append(queue, k)
visited[k] = true
}
}
}
if isFound {
printPrev(prev, s, t)
} else {
fmt.Printf("no path found from %d to %d\n", s, t)
}
}
//search by DFS
func (self *Graph) DFS(s int, t int) {
prev := make([]int, self.v)
for i := range prev {
prev[i] = -1
}
visited := make([]bool, self.v)
visited[s] = true
//isFound 我们已经找到终止顶点 t 之后,我们就不再递归地继续查找了。
isFound := false
self.recurse(s, t, prev, visited, isFound)
printPrev(prev, s, t)
}
//recursivly find path
func (self *Graph) recurse(s int, t int, prev []int, visited []bool, isFound bool) {
if isFound {
return
}
visited[s] = true
if s == t {
isFound = true
return
}
linkedlist := self.adj[s]
for e := linkedlist.Front(); e != nil; e = e.Next() {
k := e.Value.(int)
if !visited[k] {
prev[k] = s
self.recurse(k, t, prev, visited, false)
}
}
}
//print path recursively
func printPrev(prev []int, s int, t int) {
if t == s || prev[t] == -1 {
fmt.Printf("%d ", t)
} else {
printPrev(prev, s, prev[t])
fmt.Printf("%d ", t)
}
}
func main() {
graph := newGraph(8)
graph.addEdge(0, 1)
graph.addEdge(0, 3)
graph.addEdge(1, 2)
graph.addEdge(1, 4)
graph.addEdge(2, 5)
graph.addEdge(3, 4)
graph.addEdge(4, 5)
graph.addEdge(4, 6)
graph.addEdge(5, 7)
graph.addEdge(6, 7)
graph.BFS(0, 7)
fmt.Println()
graph.BFS(1, 3)
fmt.Println()
graph.DFS(0, 7)
fmt.Println()
graph.DFS(1, 3)
fmt.Println()
}