diff --git a/go-dsa/.vscode/launch.json b/go-dsa/.vscode/launch.json new file mode 100644 index 0000000..2a70a32 --- /dev/null +++ b/go-dsa/.vscode/launch.json @@ -0,0 +1,22 @@ +{ + "version": "0.2.0", + "configurations": [ + { + "name": "Launch Package", + "type": "go", + "request": "launch", + "mode": "debug", + "program": "${workspaceFolder}", + "dlvLoadConfig": { + "followPointers": true, + "maxVariableRecurse": 1, + "maxStringLen": 512, + "maxArrayValues": 64, + "maxStructFields": -1 + }, + "dlvFlags": [ + "--check-go-version=false" + ] + } + ] +} diff --git a/go-dsa/go.mod b/go-dsa/go.mod index 3006268..dc16c22 100644 --- a/go-dsa/go.mod +++ b/go-dsa/go.mod @@ -1,3 +1,5 @@ module go-dsa -go 1.21 +go 1.21.0 + +toolchain go1.22.3 diff --git a/go-dsa/go.sum b/go-dsa/go.sum new file mode 100644 index 0000000..e69de29 diff --git a/go-dsa/tree/bfs.go b/go-dsa/tree/bfs.go new file mode 100644 index 0000000..6ee1e47 --- /dev/null +++ b/go-dsa/tree/bfs.go @@ -0,0 +1,23 @@ +package tree + +func BFS(n *Node, f func(*Node)) { + if n == nil { + return + } + + q := []*Node{n} + for len(q) > 0 { + node := q[0] // Dequeue + q = q[1:] // Remove the head of the queue + + f(node) + + if node.Left != nil { + q = append(q, node.Left) // Enqueue + } + + if node.Right != nil { + q = append(q, node.Right) // Enqueue + } + } +} diff --git a/go-dsa/tree/bfs_test.go b/go-dsa/tree/bfs_test.go new file mode 100644 index 0000000..ec7c2c1 --- /dev/null +++ b/go-dsa/tree/bfs_test.go @@ -0,0 +1,35 @@ +package tree + +import ( + "reflect" + "testing" +) + +func TestBFS(t *testing.T) { + /* + Should print numbers in sequence: 1, 2, 3, 4, 5, 6 + Tree: + 1 + / \ + 2 3 + / \ \ + 4 5 6 + */ + + root := NewNode(1) + root.Left = NewNode(2) + root.Right = NewNode(3) + root.Left.Left = NewNode(4) + root.Left.Right = NewNode(5) + root.Right.Right = NewNode(6) + + var result []int + BFS(root, func(n *Node) { + result = append(result, n.Value) + }) + + expected := []int{1, 2, 3, 4, 5, 6} + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v but got %v", expected, result) + } +} diff --git a/go-dsa/tree/dfs_in_order.go b/go-dsa/tree/dfs_in_order.go new file mode 100644 index 0000000..ed905eb --- /dev/null +++ b/go-dsa/tree/dfs_in_order.go @@ -0,0 +1,11 @@ +package tree + +func DFSInOrder(n *Node, f func(*Node)) { + if n == nil { + return + } + + DFSInOrder(n.Left, f) + f(n) + DFSInOrder(n.Right, f) +} diff --git a/go-dsa/tree/dfs_in_order_test.go b/go-dsa/tree/dfs_in_order_test.go new file mode 100644 index 0000000..6dae417 --- /dev/null +++ b/go-dsa/tree/dfs_in_order_test.go @@ -0,0 +1,35 @@ +package tree + +import ( + "reflect" + "testing" +) + +func TestDFSInOrder(t *testing.T) { + /* + Should print numbers in sequence: 1, 2, 3, 4, 5, 6 + Tree: + 4 + / \ + 2 5 + / \ \ + 1 3 6 + */ + + root := NewNode(4) + root.Left = NewNode(2) + root.Right = NewNode(5) + root.Left.Left = NewNode(1) + root.Left.Right = NewNode(3) + root.Right.Right = NewNode(6) + + var result []int + DFSInOrder(root, func(n *Node) { + result = append(result, n.Value) + }) + + expected := []int{1, 2, 3, 4, 5, 6} + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v but got %v", expected, result) + } +} diff --git a/go-dsa/tree/dfs_post_order.go b/go-dsa/tree/dfs_post_order.go new file mode 100644 index 0000000..3846c14 --- /dev/null +++ b/go-dsa/tree/dfs_post_order.go @@ -0,0 +1,11 @@ +package tree + +func DFSPostOrder(n *Node, f func(*Node)) { + if n == nil { + return + } + + DFSPostOrder(n.Left, f) + DFSPostOrder(n.Right, f) + f(n) +} diff --git a/go-dsa/tree/dfs_post_order_test.go b/go-dsa/tree/dfs_post_order_test.go new file mode 100644 index 0000000..b2d3361 --- /dev/null +++ b/go-dsa/tree/dfs_post_order_test.go @@ -0,0 +1,35 @@ +package tree + +import ( + "reflect" + "testing" +) + +func TestDFSPostOrder(t *testing.T) { + /* + Should print numbers in sequence: 1, 2, 3, 4, 5, 6 + Tree: + 6 + / \ + 3 5 + / \ \ + 1 2 4 + */ + + root := NewNode(6) + root.Left = NewNode(3) + root.Right = NewNode(5) + root.Left.Left = NewNode(1) + root.Left.Right = NewNode(2) + root.Right.Right = NewNode(4) + + var result []int + DFSPostOrder(root, func(n *Node) { + result = append(result, n.Value) + }) + + expected := []int{1, 2, 3, 4, 5, 6} + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v but got %v", expected, result) + } +} diff --git a/go-dsa/tree/dfs_pre_order.go b/go-dsa/tree/dfs_pre_order.go new file mode 100644 index 0000000..7b823fd --- /dev/null +++ b/go-dsa/tree/dfs_pre_order.go @@ -0,0 +1,11 @@ +package tree + +func DFSPreOrder(n *Node, f func(*Node)) { + if n == nil { + return + } + + f(n) + DFSPreOrder(n.Left, f) + DFSPreOrder(n.Right, f) +} diff --git a/go-dsa/tree/dfs_pre_order_test.go b/go-dsa/tree/dfs_pre_order_test.go new file mode 100644 index 0000000..ae1c71f --- /dev/null +++ b/go-dsa/tree/dfs_pre_order_test.go @@ -0,0 +1,34 @@ +package tree + +import ( + "reflect" + "testing" +) + +func TestDFSPreOrder(t *testing.T) { + /* + Should print numbers in sequence: 1, 2, 3, 4, 5, 6 + Tree: + 1 + / \ + 2 5 + / \ \ + 3 4 6 + */ + root := NewNode(1) + root.Left = NewNode(2) + root.Right = NewNode(5) + root.Left.Left = NewNode(3) + root.Left.Right = NewNode(4) + root.Right.Right = NewNode(6) + + var result []int + DFSPreOrder(root, func(n *Node) { + result = append(result, n.Value) + }) + + expected := []int{1, 2, 3, 4, 5, 6} + if !reflect.DeepEqual(result, expected) { + t.Errorf("Expected %v but got %v", expected, result) + } +} diff --git a/go-dsa/tree/image.png b/go-dsa/tree/image.png new file mode 100644 index 0000000..4348d8f Binary files /dev/null and b/go-dsa/tree/image.png differ diff --git a/go-dsa/tree/tree.go b/go-dsa/tree/tree.go new file mode 100644 index 0000000..0f46a82 --- /dev/null +++ b/go-dsa/tree/tree.go @@ -0,0 +1,29 @@ +package tree + +type Node struct { + Value int + Left *Node + Right *Node +} + +func NewNode(value int) *Node { + return &Node{ + Value: value, + } +} + +func (n *Node) Insert(value int) { + if value < n.Value { + if n.Left == nil { + n.Left = NewNode(value) + } else { + n.Left.Insert(value) + } + } else { + if n.Right == nil { + n.Right = NewNode(value) + } else { + n.Right.Insert(value) + } + } +}