图中有几个概念:无向图、有向图、带权图、顶点、边、度、入度、出度。还学习了图的两个主要的存储方式:邻接矩阵和邻接表。
邻接矩阵:
邻接矩阵的底层依赖一个二维数组。对于无向图来说,如果顶点 i 与顶点 j 之间有边,我们就将 A[i][j]和 A[j][i]标记为 1;对于有向图来说,如果顶点 i 到顶点 j 之间,有一条箭头从顶点 i 指向顶点 j 的边,那我们就将 A[i][j]标记为 1。同理,如果有一条箭头从顶点 j 指向顶点 i 的边,我们就将 A[j][i]标记为 1。对于带权图,数组中就存储相应的权重。
邻接表:
广度优先搜索(Breadth-First-Search),我们平常都把简称为 BFS。直观地讲,它其实就是一种“地毯式”层层推进的搜索策略,即先查找离起始顶点最近的,然后是次近的,依次往外搜索。
visited 是用来记录已经被访问的顶点,用来避免顶点被重复访问。如果顶点 q 被访问,那相应的 visited[q]会被设置为 true。
queue 是一个队列,用来存储已经被访问、但相连的顶点还没有被访问的顶点。
prev 用来记录搜索路径。
广度优先搜索的时间复杂度是 O(V+E)
深度优先搜索(Depth-First-Search),简称 DFS。
假设你站在迷宫的某个岔路口,然后想找到出口。你随意选择一个岔路口来走,走着走着发现走不通的时候,你就回退到上一个岔路口,重新选择一条路继续走,直到最终找到出口。这种走法就是一种深度优先搜索策略。
这里面实线箭头表示遍历,虚线箭头表示回退。
深度优先搜索算法的时间复杂度是 O(E),E 表示边的个数。空间复杂度是 O(V)。
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)
}
//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 := 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)
}
}
以上内容摘自《数据结构与算法之美》课程,来学习更多精彩内容吧。