Correct BFS algorithm and tests (#279)

* Revise BFS algorithm implementation.

* Test for BFS

* Fix: Edit package name and structure
Fix: Improve documenting

* Fix: rename function and file name (Breadthfirstsearch -> BFS)

* Fix: revert renaming function and file name (BFS -> BreadthFirstSearch)

Author: kAvEh--

graphs/breathfirstsearch/breathfirstsearch.go

@@ -0,0 +1,33 @@
+// Package search Graph search algorithms
+// reference: https://en.wikipedia.org/wiki/Tree_traversal
+package search
+
+/*BreadthFirstSearch is an algorithm for traversing and searching graph data structures.
+	It starts at an arbitrary node of a graph, and explores all of the neighbor nodes
+	at the present depth prior to moving on to the nodes at the next depth level.
+	Worst-case performance	 		O(|V|+|E|)=O(b^{d})}O(|V|+|E|)=O(b^{d})
+	Worst-case space complexity	 	O(|V|)=O(b^{d})}O(|V|)=O(b^{d})
+reference: https://en.wikipedia.org/wiki/Breadth-first_search
+*/
+func BreadthFirstSearch(start, end, nodes int, edges [][]int) (isConnected bool, distance int) {
+	queue := make([]int, 0)
+	discovered := make([]int, nodes)
+	discovered[start] = 1
+	queue = append(queue, start)
+	for len(queue) > 0 {
+		v := queue[0]
+		if len(queue) > 0 {
+			queue = queue[1:]
+		}
+		for i := 0; i < len(edges[v]); i++ {
+			if discovered[i] == 0 && edges[v][i] > 0 {
+				if i == end {
+					return true, discovered[v]
+				}
+				discovered[i] = discovered[v] + 1
+				queue = append(queue, i)
+			}
+		}
+	}
+	return false, 0
+}

graphs/search/breadthFirstSearch.go

@@ -0,0 +1,78 @@
+package search
+
+import (
+	"testing"
+)
+
+func TestBreadthFirstSearch(t *testing.T) {
+	var bfsTestData = []struct {
+		description string
+		start       int
+		end         int
+		nodes       int
+		edges       [][]int
+		expected1   bool
+		expected2   int
+	}{
+		{
+			"test 1 connected with distance 2",
+			0,
+			5,
+			6,
+			[][]int{
+				{0, 1, 1, 0, 0, 0},
+				{1, 0, 0, 1, 0, 1},
+				{1, 0, 0, 1, 0, 0},
+				{0, 1, 1, 0, 1, 0},
+				{0, 0, 0, 1, 0, 0},
+				{0, 1, 0, 0, 0, 0},
+			},
+			true,
+			2,
+		},
+		{
+			"test 2 connected with distance 4",
+			0,
+			5,
+			6,
+			[][]int{
+				{0, 1, 1, 0, 0, 0},
+				{1, 0, 0, 1, 0, 0},
+				{1, 0, 0, 1, 0, 0},
+				{0, 1, 1, 0, 1, 0},
+				{0, 0, 0, 1, 0, 1},
+				{0, 0, 0, 0, 1, 0},
+			},
+			true,
+			4,
+		},
+		{
+			"test 2 not connected",
+			0,
+			5,
+			6,
+			[][]int{
+				{0, 1, 1, 0, 0, 0},
+				{1, 0, 0, 1, 0, 0},
+				{1, 0, 0, 1, 0, 0},
+				{0, 1, 1, 0, 1, 0},
+				{0, 0, 0, 1, 0, 0},
+				{0, 0, 0, 0, 0, 0},
+			},
+			false,
+			0,
+		},
+	}
+	for _, test := range bfsTestData {
+		t.Run(test.description, func(t *testing.T) {
+			r1, r2 := BreadthFirstSearch(test.start, test.end,
+				test.nodes, test.edges)
+			if r1 != test.expected1 || r2 != test.expected2 {
+				t.Logf("FAIL: %s", test.description)
+				t.Fatalf("Nodes '%v' and Edges '%v' start from '%d' and end in '%d' "+
+					"was expecting '%v' with distance '%d' but result was '%v','%d'",
+					test.nodes, test.edges, test.start, test.end, test.expected1, test.expected2, r1, r2)
+			}
+		})
+	}
+}