Merge pull request #182 from LYDongD/master

add graph seach algo: BFS & DFS

Author: wangzheng0822

go/31_graph/graph_search.go

@@ -0,0 +1,152 @@
+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)
+}
+
+//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)
+	}
+
+}
+
+//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()
+//}

go/32_string/string_bf.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+)
+
+//BF search pattern index, return the first match subs start index
+func bfSearch(main string, pattern string) int {
+
+	//defensive
+	if len(main) == 0 || len(pattern) == 0 || len(main) < len(pattern) {
+		return -1
+	}
+
+	for i := 0; i <= len(main)-len(pattern); i++ {
+		subStr := main[i : i+len(pattern)]
+		if subStr == pattern {
+			return i
+		}
+	}
+
+	return -1
+}
+
+func main() {
+
+	main := "abcd227fac"
+	pattern := "ac"
+	fmt.Println(bfSearch(main, pattern))
+}

go/32_string/string_bm.go

@@ -0,0 +1,140 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+//bc: pattern char index hash mapping
+func generateBC(pattern string) []int {
+
+	bc := make([]int, 256)
+
+	for index := range bc {
+		bc[index] = -1
+	}
+
+	for index, char := range pattern {
+		bc[int(char)] = index
+	}
+
+	return bc
+}
+
+//generate suffix and prefix array for pattern
+func generateGS(pattern string) ([]int, []bool) {
+	m := len(pattern)
+	suffix := make([]int, m)
+	prefix := make([]bool, m)
+
+	//init
+	for i := 0; i < m; i++ {
+		suffix[i] = -1
+		prefix[i] = false
+	}
+
+	for i := 0; i < m-1; i++ {
+		j := i
+		k := 0
+		for j >= 0 && pattern[j] == pattern[m-1-k] {
+			j--
+			k++
+			suffix[k] = j + 1
+		}
+
+		if j == -1 {
+			prefix[k] = true
+		}
+	}
+
+	return suffix, prefix
+}
+
+//todo
+func moveByGS(patternLength int, badCharStartIndex int, suffix []int, prefix []bool) int {
+
+	//length of good suffix
+	k := patternLength - badCharStartIndex - 1
+
+	//complete match
+	if suffix[k] != -1 {
+		return badCharStartIndex + 1 - suffix[k]
+	}
+
+	//partial match
+	for t := patternLength - 1; t > badCharStartIndex+1; t-- {
+		if prefix[t] {
+			return t
+		}
+	}
+
+	//no match
+	return patternLength
+
+}
+
+func bmSearch(main string, pattern string) int {
+	//defensive
+	if len(main) == 0 || len(pattern) == 0 || len(pattern) > len(main) {
+		return -1
+	}
+
+	bc := generateBC(pattern)
+	suffix, prefix := generateGS(pattern)
+
+	n := len(main)
+	m := len(pattern)
+
+	// i : start index of main string
+	step := 1
+	for i := 0; i <= n-m; i = i + step {
+		subStr := main[i : i+m]
+		k, j := findBadChar(subStr, pattern, bc)
+
+		stepForBC := j - k
+		//j is bad char occur index
+		if j == -1 {
+			return i
+		}
+
+		stepForGS := -1
+		if j < m-1 {
+			stepForGS = moveByGS(m, j, suffix, prefix)
+		}
+
+		//k is bad char index in pattern
+		step = int(math.Max(float64(stepForBC), float64(stepForGS)))
+	}
+
+	return -1
+}
+
+func findBadChar(subStr string, pattern string, bc []int) (int, int) {
+
+	j := -1
+	k := -1
+	badChar := rune(0)
+
+	for index := len(subStr) - 1; index >= 0; index-- {
+		if subStr[index] != pattern[index] {
+			j = index
+			badChar = rune(subStr[index])
+			break
+		}
+	}
+
+	//if bad character exist, then find it's index at pattern
+	if j > 0 {
+		k = bc[int(badChar)]
+	}
+
+	return k, j
+}
+
+func main() {
+
+	main := "abcacabcbcabcabc"
+	pattern := "cabcab"
+
+	fmt.Println(bmSearch(main, pattern))
+}