From 1f62e5f566ddfdb98e643af20dba2d85a0084225 Mon Sep 17 00:00:00 2001
From: Johnathan Fercher <johnathanfercher22@gmail.com>
Date: Sun, 24 Sep 2023 22:38:09 -0300
Subject: [PATCH 1/2] Improve Node ID handling

---
 cmd/main.go          |  14 +--
 tree/example_test.go |  73 +++++++---------
 tree/node.go         |  10 +--
 tree/node_test.go    | 201 +++++++++----------------------------------
 tree/tree_test.go    |  66 +++++++-------
 5 files changed, 119 insertions(+), 245 deletions(-)

diff --git a/cmd/main.go b/cmd/main.go
index bbbb746..7a3f5fa 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -10,16 +10,16 @@ import (
 func main() {
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0.0"))
+	tr.AddRoot(tree.NewNode("0.0").WithID(0))
 
-	tr.Add(0, tree.NewNodeWithID(1, "0.1"))
-	tr.Add(0, tree.NewNodeWithID(2, "0.2"))
+	tr.Add(0, tree.NewNode("0.1").WithID(1))
+	tr.Add(0, tree.NewNode("0.2").WithID(2))
 
-	tr.Add(1, tree.NewNodeWithID(3, "1.3"))
-	tr.Add(1, tree.NewNodeWithID(4, "1.4"))
+	tr.Add(1, tree.NewNode("1.3").WithID(3))
+	tr.Add(1, tree.NewNode("1.4").WithID(4))
 
-	tr.Add(2, tree.NewNodeWithID(5, "2.5"))
-	tr.Add(2, tree.NewNodeWithID(6, "2.6"))
+	tr.Add(2, tree.NewNode("2.5").WithID(5))
+	tr.Add(2, tree.NewNode("2.6").WithID(6))
 
 	root, ok := tr.GetRoot()
 	fmt.Println(ok)             // true
diff --git a/tree/example_test.go b/tree/example_test.go
index 134268a..e24af9c 100644
--- a/tree/example_test.go
+++ b/tree/example_test.go
@@ -11,7 +11,7 @@ func ExampleNew() {
 	tr := tree.New[string]()
 
 	// Add nodes do tree
-	tr.AddRoot(tree.NewNodeWithID(0, "root"))
+	tr.AddRoot(tree.NewNode("root"))
 
 	// Do more things
 }
@@ -20,7 +20,7 @@ func ExampleNew() {
 func ExampleTree_AddRoot() {
 	tr := tree.New[int]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, 42))
+	tr.AddRoot(tree.NewNode(42))
 
 	// Do more things
 }
@@ -28,7 +28,7 @@ func ExampleTree_AddRoot() {
 // ExampleTree_GetRoot demonstrates how to retrieve root node from tree.
 func ExampleTree_GetRoot() {
 	tr := tree.New[float64]()
-	tr.AddRoot(tree.NewNodeWithID(0, 3.14))
+	tr.AddRoot(tree.NewNode(3.14))
 
 	node, ok := tr.GetRoot()
 	if !ok {
@@ -42,9 +42,9 @@ func ExampleTree_GetRoot() {
 // ExampleTree_Add demonstrates how to add node to tree.
 func ExampleTree_Add() {
 	tr := tree.New[bool]()
-	tr.AddRoot(tree.NewNodeWithID(0, true))
+	tr.AddRoot(tree.NewNode(true))
 
-	tr.Add(0, tree.NewNodeWithID(1, false))
+	tr.Add(0, tree.NewNode(false))
 
 	// Do more things
 }
@@ -52,7 +52,7 @@ func ExampleTree_Add() {
 // ExampleTree_Get demonstrates how to retrieve node from tree.
 func ExampleTree_Get() {
 	tr := tree.New[uint]()
-	tr.AddRoot(tree.NewNodeWithID(0, uint(42)))
+	tr.AddRoot(tree.NewNode(uint(42)))
 
 	node, ok := tr.Get(0)
 	if !ok {
@@ -66,10 +66,10 @@ func ExampleTree_Get() {
 // ExampleTree_Backtrack demonstrates how to retrieve path of nodes from node to root.
 func ExampleTree_Backtrack() {
 	tr := tree.New[string]()
-	tr.AddRoot(tree.NewNodeWithID(0, "root"))
-	tr.Add(0, tree.NewNodeWithID(1, "level1"))
-	tr.Add(1, tree.NewNodeWithID(2, "level2"))
-	tr.Add(2, tree.NewNodeWithID(3, "leaf"))
+	tr.AddRoot(tree.NewNode("root"))
+	tr.Add(0, tree.NewNode("level1"))
+	tr.Add(1, tree.NewNode("level2"))
+	tr.Add(2, tree.NewNode("leaf"))
 
 	nodes, ok := tr.Backtrack(3)
 	if !ok {
@@ -85,10 +85,10 @@ func ExampleTree_Backtrack() {
 // ExampleTree_GetStructure demonstrates how to retrieve tree structure.
 func ExampleTree_GetStructure() {
 	tr := tree.New[string]()
-	tr.AddRoot(tree.NewNodeWithID(0, "root"))
-	tr.Add(0, tree.NewNodeWithID(1, "level1"))
-	tr.Add(1, tree.NewNodeWithID(2, "level2"))
-	tr.Add(2, tree.NewNodeWithID(3, "leaf"))
+	tr.AddRoot(tree.NewNode("root"))
+	tr.Add(0, tree.NewNode("level1"))
+	tr.Add(1, tree.NewNode("level2"))
+	tr.Add(2, tree.NewNode("leaf"))
 
 	structure, ok := tr.GetStructure()
 	if !ok {
@@ -101,16 +101,7 @@ func ExampleTree_GetStructure() {
 	// Do more things
 }
 
-// NewNodeWithID demonstrates how to create a node with ID.
-func ExampleNewNodeWithID() {
-	n := tree.NewNodeWithID(0, "node")
-
-	n.GetData()
-
-	// Do more things
-}
-
-// ExampleNewNode demonstrates how to create a node.
+// NewNode demonstrates how to create a node with ID.
 func ExampleNewNode() {
 	n := tree.NewNode("node")
 
@@ -121,7 +112,7 @@ func ExampleNewNode() {
 
 // ExampleNode_GetData demonstrates how to retrieve data from node.
 func ExampleNode_GetData() {
-	n := tree.NewNodeWithID(0, 3.14)
+	n := tree.NewNode(3.14)
 
 	data := n.GetData()
 	fmt.Println(data)
@@ -131,7 +122,7 @@ func ExampleNode_GetData() {
 
 // ExampleNode_GetID demonstrates how to retrieve id from node.
 func ExampleNode_GetID() {
-	n := tree.NewNodeWithID(0, 3.14)
+	n := tree.NewNode(3.14).WithID(1)
 
 	id := n.GetID()
 	fmt.Println(id)
@@ -141,8 +132,8 @@ func ExampleNode_GetID() {
 
 // ExampleNode_GetNexts demonstrates how to retrieve next nodes from node.
 func ExampleNode_GetNexts() {
-	root := tree.NewNodeWithID(0, "root")
-	leaf := tree.NewNodeWithID(1, "leaf")
+	root := tree.NewNode("root")
+	leaf := tree.NewNode("leaf")
 
 	root.AddNext(leaf)
 	nexts := root.GetNexts()
@@ -153,8 +144,8 @@ func ExampleNode_GetNexts() {
 
 // ExampleNode_GetPrevious demonstrates how to retrieve next nodes from node.
 func ExampleNode_GetPrevious() {
-	root := tree.NewNodeWithID(0, "root")
-	leaf := tree.NewNodeWithID(1, "leaf")
+	root := tree.NewNode("root")
+	leaf := tree.NewNode("leaf")
 
 	root.AddNext(leaf)
 	previous := leaf.GetPrevious()
@@ -165,7 +156,7 @@ func ExampleNode_GetPrevious() {
 
 // ExampleNode_IsRoot demonstrates how to retrieve info if node is root.
 func ExampleNode_IsRoot() {
-	n := tree.NewNodeWithID(0, 'b')
+	n := tree.NewNode('b')
 
 	root := n.IsRoot()
 	fmt.Println(root)
@@ -175,8 +166,8 @@ func ExampleNode_IsRoot() {
 
 // ExampleNode_IsLeaf demonstrates how to retrieve info if node is leaf.
 func ExampleNode_IsLeaf() {
-	n1 := tree.NewNodeWithID(0, 'a')
-	n2 := tree.NewNodeWithID(0, 'b')
+	n1 := tree.NewNode('a')
+	n2 := tree.NewNode('b')
 
 	n1.AddNext(n2)
 
@@ -188,9 +179,9 @@ func ExampleNode_IsLeaf() {
 
 // ExampleNode_Backtrack demonstrates how to retrieve the path between node to root.
 func ExampleNode_Backtrack() {
-	n1 := tree.NewNodeWithID(0, 'a')
-	n2 := tree.NewNodeWithID(0, 'b')
-	n3 := tree.NewNodeWithID(0, 'c')
+	n1 := tree.NewNode('a')
+	n2 := tree.NewNode('b')
+	n3 := tree.NewNode('c')
 
 	n1.AddNext(n2)
 	n2.AddNext(n3)
@@ -205,9 +196,9 @@ func ExampleNode_Backtrack() {
 
 // ExampleNode_GetStructure demonstrates how to retrieve the tree structure from node.
 func ExampleNode_GetStructure() {
-	n1 := tree.NewNodeWithID(0, 'a')
-	n2 := tree.NewNodeWithID(0, 'b')
-	n3 := tree.NewNodeWithID(0, 'c')
+	n1 := tree.NewNode('a')
+	n2 := tree.NewNode('b')
+	n3 := tree.NewNode('c')
 
 	n1.AddNext(n2)
 	n2.AddNext(n3)
@@ -222,8 +213,8 @@ func ExampleNode_GetStructure() {
 
 // ExampleNode_AddNext demonstrates how to add a node to a parent.
 func ExampleNode_AddNext() {
-	n1 := tree.NewNodeWithID(0, 'a')
-	n2 := tree.NewNodeWithID(0, 'b')
+	n1 := tree.NewNode('a')
+	n2 := tree.NewNode('b')
 
 	n1.AddNext(n2)
 
diff --git a/tree/node.go b/tree/node.go
index 0982ebb..13d843e 100644
--- a/tree/node.go
+++ b/tree/node.go
@@ -20,12 +20,10 @@ func NewNode[T any](data T) *Node[T] {
 	}
 }
 
-// NewNodeWithID creates a new node with ID.
-func NewNodeWithID[T any](id int, data T) *Node[T] {
-	return &Node[T]{
-		id:   id,
-		data: data,
-	}
+// WithID retrieves data from node.
+func (n *Node[T]) WithID(id int) *Node[T] {
+	n.id = id
+	return n
 }
 
 // GetData retrieves data from node.
diff --git a/tree/node_test.go b/tree/node_test.go
index a7422f3..719dec7 100644
--- a/tree/node_test.go
+++ b/tree/node_test.go
@@ -44,56 +44,21 @@ func TestNewNode(t *testing.T) {
 	}
 }
 
-func TestNewNodeWithID(t *testing.T) {
+func TestNode_GetData(t *testing.T) {
 	// Arrange
-	elements := []interface{}{
-		true,
-		42,
-		3.14,
-		"string1",
-		&anyType{Value: "string2"},
-	}
-
-	types := []interface{}{
-		"bool",
-		"int",
-		"float64",
-		"string",
-		"*tree_test.anyType",
-	}
-
-	for i, element := range elements {
-		// Act
-		sut := tree.NewNodeWithID(0, element)
-		id := sut.GetID()
-		data := sut.GetData()
-
-		// Assert
-		assert.NotNil(t, sut)
-		assert.Equal(t, "*tree.Node[interface {}]", fmt.Sprintf("%T", sut))
-		assert.Equal(t, 0, id)
-		assert.Equal(t, element, data)
-		assert.Equal(t, types[i], fmt.Sprintf("%T", data))
-	}
-}
-
-func TestNode_Get(t *testing.T) {
-	// Arrange
-	sut := tree.NewNodeWithID(0, 42)
+	sut := tree.NewNode(42)
 
 	// Act
-	id := sut.GetID()
 	data := sut.GetData()
 
 	// Assert
-	assert.Equal(t, 0, id)
 	assert.Equal(t, 42, data)
 }
 
 func TestNode_GetNexts(t *testing.T) {
 	// Arrange
-	sut := tree.NewNodeWithID(0, 42)
-	leaf := tree.NewNodeWithID(1, 43)
+	sut := tree.NewNode(42)
+	leaf := tree.NewNode(43)
 	sut.AddNext(leaf)
 
 	// Act
@@ -101,33 +66,29 @@ func TestNode_GetNexts(t *testing.T) {
 
 	// Assert
 	assert.Equal(t, 1, len(nexts))
-	id := nexts[0].GetID()
 	data := nexts[0].GetData()
 	assert.Equal(t, 43, data)
-	assert.Equal(t, 1, id)
 }
 
 func TestNode_GetPrevious(t *testing.T) {
 	// Arrange
-	root := tree.NewNodeWithID(0, 42)
-	sut := tree.NewNodeWithID(1, 43)
+	root := tree.NewNode(42)
+	sut := tree.NewNode(43)
 	root.AddNext(sut)
 
 	// Act
 	previous := sut.GetPrevious()
 
 	// Assert
-	id := previous.GetID()
 	data := previous.GetData()
 	assert.Equal(t, 42, data)
-	assert.Equal(t, 0, id)
 }
 
 func TestNode_IsRoot(t *testing.T) {
 	// Arrange
-	root := tree.NewNodeWithID(0, 42)
-	anyNode := tree.NewNodeWithID(1, 43)
-	leaf := tree.NewNodeWithID(2, 44)
+	root := tree.NewNode(42)
+	anyNode := tree.NewNode(43)
+	leaf := tree.NewNode(44)
 
 	root.AddNext(anyNode)
 	anyNode.AddNext(leaf)
@@ -145,9 +106,9 @@ func TestNode_IsRoot(t *testing.T) {
 
 func TestNode_IsLeaf(t *testing.T) {
 	// Arrange
-	root := tree.NewNodeWithID(0, 42)
-	anyNode := tree.NewNodeWithID(1, 43)
-	leaf := tree.NewNodeWithID(2, 44)
+	root := tree.NewNode(42)
+	anyNode := tree.NewNode(43)
+	leaf := tree.NewNode(44)
 
 	root.AddNext(anyNode)
 	anyNode.AddNext(leaf)
@@ -165,9 +126,9 @@ func TestNode_IsLeaf(t *testing.T) {
 
 func TestNode_Backtrack_WhenBuildManually_ShouldReturnCorrectly(t *testing.T) {
 	// Arrange
-	root := tree.NewNodeWithID(0, 42)
-	anyNode := tree.NewNodeWithID(1, 43)
-	leaf := tree.NewNodeWithID(2, 44)
+	root := tree.NewNode(42)
+	anyNode := tree.NewNode(43)
+	leaf := tree.NewNode(44)
 
 	root.AddNext(anyNode)
 	anyNode.AddNext(leaf)
@@ -187,242 +148,166 @@ func TestNode_Backtrack_WhenBuildByTree_ShouldReturnCorrectly(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0.0"))
-	tr.Add(0, tree.NewNodeWithID(1, "1.0"))
-	tr.Add(0, tree.NewNodeWithID(2, "1.1"))
-	tr.Add(0, tree.NewNodeWithID(3, "1.2"))
-	tr.Add(1, tree.NewNodeWithID(4, "2.0"))
-	tr.Add(1, tree.NewNodeWithID(5, "2.1"))
-	tr.Add(1, tree.NewNodeWithID(6, "2.2"))
-	tr.Add(2, tree.NewNodeWithID(7, "2.0"))
-	tr.Add(2, tree.NewNodeWithID(8, "2.1"))
-	tr.Add(2, tree.NewNodeWithID(9, "2.2"))
-	tr.Add(3, tree.NewNodeWithID(10, "3.0"))
-	tr.Add(3, tree.NewNodeWithID(11, "3.1"))
-	tr.Add(3, tree.NewNodeWithID(12, "3.2"))
-	tr.Add(4, tree.NewNodeWithID(13, "4.0"))
+	tr.AddRoot(tree.NewNode("0.0").WithID(0))
+	tr.Add(0, tree.NewNode("1.0").WithID(1))
+	tr.Add(0, tree.NewNode("1.1").WithID(2))
+	tr.Add(0, tree.NewNode("1.2").WithID(3))
+	tr.Add(1, tree.NewNode("2.0").WithID(4))
+	tr.Add(1, tree.NewNode("2.1").WithID(5))
+	tr.Add(1, tree.NewNode("2.2").WithID(6))
+	tr.Add(2, tree.NewNode("2.0").WithID(7))
+	tr.Add(2, tree.NewNode("2.1").WithID(8))
+	tr.Add(2, tree.NewNode("2.2").WithID(9))
+	tr.Add(3, tree.NewNode("3.0").WithID(10))
+	tr.Add(3, tree.NewNode("3.1").WithID(11))
+	tr.Add(3, tree.NewNode("3.2").WithID(12))
+	tr.Add(4, tree.NewNode("4.0").WithID(13))
 
 	// Act & Assert
 	// Case 0
 	anyNode, _ := tr.Get(0)
 	backtracked := anyNode.Backtrack()
 	assert.Equal(t, 1, len(backtracked))
-	id := backtracked[0].GetID()
 	data := backtracked[0].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 1
 	anyNode, _ = tr.Get(1)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 2, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 1, id)
 	assert.Equal(t, "1.0", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 2
 	anyNode, _ = tr.Get(2)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 2, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 2, id)
 	assert.Equal(t, "1.1", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 3
 	anyNode, _ = tr.Get(3)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 2, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 3, id)
 	assert.Equal(t, "1.2", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 4
 	anyNode, _ = tr.Get(4)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 4, id)
 	assert.Equal(t, "2.0", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 1, id)
 	assert.Equal(t, "1.0", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 5
 	anyNode, _ = tr.Get(5)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 5, id)
 	assert.Equal(t, "2.1", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 1, id)
 	assert.Equal(t, "1.0", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 6
 	anyNode, _ = tr.Get(6)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 6, id)
 	assert.Equal(t, "2.2", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 1, id)
 	assert.Equal(t, "1.0", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 7
 	anyNode, _ = tr.Get(7)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 7, id)
 	assert.Equal(t, "2.0", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 2, id)
 	assert.Equal(t, "1.1", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 8
 	anyNode, _ = tr.Get(8)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 8, id)
 	assert.Equal(t, "2.1", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 2, id)
 	assert.Equal(t, "1.1", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 9
 	anyNode, _ = tr.Get(9)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 9, id)
 	assert.Equal(t, "2.2", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 2, id)
 	assert.Equal(t, "1.1", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 10
 	anyNode, _ = tr.Get(10)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 10, id)
 	assert.Equal(t, "3.0", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 3, id)
 	assert.Equal(t, "1.2", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 11
 	anyNode, _ = tr.Get(11)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 11, id)
 	assert.Equal(t, "3.1", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 3, id)
 	assert.Equal(t, "1.2", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 12
 	anyNode, _ = tr.Get(12)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 3, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 12, id)
 	assert.Equal(t, "3.2", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 3, id)
 	assert.Equal(t, "1.2", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 
 	// Case 13
 	anyNode, _ = tr.Get(13)
 	backtracked = anyNode.Backtrack()
 	assert.Equal(t, 4, len(backtracked))
-	id = backtracked[0].GetID()
 	data = backtracked[0].GetData()
-	assert.Equal(t, 13, id)
 	assert.Equal(t, "4.0", data)
-	id = backtracked[1].GetID()
 	data = backtracked[1].GetData()
-	assert.Equal(t, 4, id)
 	assert.Equal(t, "2.0", data)
-	id = backtracked[2].GetID()
 	data = backtracked[2].GetData()
-	assert.Equal(t, 1, id)
 	assert.Equal(t, "1.0", data)
-	id = backtracked[3].GetID()
 	data = backtracked[3].GetData()
-	assert.Equal(t, 0, id)
 	assert.Equal(t, "0.0", data)
 }
 
@@ -430,20 +315,20 @@ func TestNode_GetStructure(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0.0"))
-	tr.Add(0, tree.NewNodeWithID(1, "1.0"))
-	tr.Add(0, tree.NewNodeWithID(2, "1.1"))
-	tr.Add(0, tree.NewNodeWithID(3, "1.2"))
-	tr.Add(1, tree.NewNodeWithID(4, "2.0"))
-	tr.Add(1, tree.NewNodeWithID(5, "2.1"))
-	tr.Add(1, tree.NewNodeWithID(6, "2.2"))
-	tr.Add(2, tree.NewNodeWithID(7, "2.0"))
-	tr.Add(2, tree.NewNodeWithID(8, "2.1"))
-	tr.Add(2, tree.NewNodeWithID(9, "2.2"))
-	tr.Add(3, tree.NewNodeWithID(10, "3.0"))
-	tr.Add(3, tree.NewNodeWithID(11, "3.1"))
-	tr.Add(3, tree.NewNodeWithID(12, "3.2"))
-	tr.Add(4, tree.NewNodeWithID(13, "4.0"))
+	tr.AddRoot(tree.NewNode("0.0").WithID(0))
+	tr.Add(0, tree.NewNode("1.0").WithID(1))
+	tr.Add(0, tree.NewNode("1.1").WithID(2))
+	tr.Add(0, tree.NewNode("1.2").WithID(3))
+	tr.Add(1, tree.NewNode("2.0").WithID(4))
+	tr.Add(1, tree.NewNode("2.1").WithID(5))
+	tr.Add(1, tree.NewNode("2.2").WithID(6))
+	tr.Add(2, tree.NewNode("2.0").WithID(7))
+	tr.Add(2, tree.NewNode("2.1").WithID(8))
+	tr.Add(2, tree.NewNode("2.2").WithID(9))
+	tr.Add(3, tree.NewNode("3.0").WithID(10))
+	tr.Add(3, tree.NewNode("3.1").WithID(11))
+	tr.Add(3, tree.NewNode("3.2").WithID(12))
+	tr.Add(4, tree.NewNode("4.0").WithID(13))
 
 	node, _ := tr.Get(0)
 
diff --git a/tree/tree_test.go b/tree/tree_test.go
index 650c6fc..739fbb1 100644
--- a/tree/tree_test.go
+++ b/tree/tree_test.go
@@ -22,7 +22,7 @@ func TestTree_AddRoot_WhenTreeIsEmpty_ShouldReturnTrue(t *testing.T) {
 	sut := tree.New[int]()
 
 	// Act
-	added := sut.AddRoot(tree.NewNodeWithID(0, 42))
+	added := sut.AddRoot(tree.NewNode(42))
 
 	// Assert
 	assert.True(t, added)
@@ -33,8 +33,8 @@ func TestTree_AddRoot_WhenTreeIsNotEmpty_ShouldReturnFalse(t *testing.T) {
 	sut := tree.New[int]()
 
 	// Act
-	_ = sut.AddRoot(tree.NewNodeWithID(0, 42))
-	added := sut.AddRoot(tree.NewNodeWithID(0, 43))
+	_ = sut.AddRoot(tree.NewNode(42))
+	added := sut.AddRoot(tree.NewNode(43))
 
 	// Assert
 	assert.False(t, added)
@@ -55,7 +55,7 @@ func TestTree_GetRoot_WhenThereIsNotRoot_ShouldReturnFalse(t *testing.T) {
 func TestTree_GetRoot_WhenThereIsRoot_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	sut := tree.New[int]()
-	sut.AddRoot(tree.NewNodeWithID(0, 42))
+	sut.AddRoot(tree.NewNode(42))
 
 	// Act
 	root, hasRoot := sut.GetRoot()
@@ -70,7 +70,7 @@ func TestTree_Add_WhenThereIsNoRoot_ShouldReturnFalse(t *testing.T) {
 	tr := tree.New[int]()
 
 	// Act
-	added := tr.Add(0, tree.NewNodeWithID(0, 42))
+	added := tr.Add(0, tree.NewNode(42))
 
 	// Assert
 	assert.False(t, added)
@@ -81,8 +81,8 @@ func TestTree_Add_WhenRootIsNotRight_ShouldReturnTrue(t *testing.T) {
 	tr := tree.New[int]()
 
 	// Act
-	_ = tr.AddRoot(tree.NewNodeWithID(0, 42))
-	added := tr.Add(3, tree.NewNodeWithID(1, 42))
+	_ = tr.AddRoot(tree.NewNode(42))
+	added := tr.Add(3, tree.NewNode(42))
 
 	// Assert
 	assert.False(t, added)
@@ -93,8 +93,8 @@ func TestTree_Add_WhenThereIsRootAndRootIsRight_ShouldReturnTrue(t *testing.T) {
 	tr := tree.New[int]()
 
 	// Act
-	_ = tr.AddRoot(tree.NewNodeWithID(0, 42))
-	added := tr.Add(0, tree.NewNodeWithID(1, 42))
+	_ = tr.AddRoot(tree.NewNode(42))
+	added := tr.Add(0, tree.NewNode(42))
 
 	// Assert
 	assert.True(t, added)
@@ -116,8 +116,8 @@ func TestTree_Get_WhenThereIsNoId_ShouldReturnFalse(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0"))
-	tr.Add(0, tree.NewNodeWithID(1, "1.0"))
+	tr.AddRoot(tree.NewNode("0"))
+	tr.Add(0, tree.NewNode("1.0"))
 
 	// Act
 	node, found := tr.Get(8)
@@ -131,7 +131,7 @@ func TestTree_Get_WhenThereIsIdOnRoot_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0"))
+	tr.AddRoot(tree.NewNode("0"))
 
 	// Act
 	node, found := tr.Get(0)
@@ -145,8 +145,8 @@ func TestTree_Get_WhenThereIsId_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0"))
-	tr.Add(0, tree.NewNodeWithID(1, "1.0"))
+	tr.AddRoot(tree.NewNode("0").WithID(0))
+	tr.Add(0, tree.NewNode("1.0").WithID(1))
 
 	// Act
 	node, found := tr.Get(1)
@@ -160,7 +160,7 @@ func TestTree_Backtrack_WhenIdNotFound_ShouldReturnFalse(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0.0"))
+	tr.AddRoot(tree.NewNode("0.0"))
 
 	// Act
 	n, found := tr.Backtrack(1)
@@ -174,10 +174,10 @@ func TestTree_Backtrack_WhenIdFound_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0.0"))
-	tr.Add(0, tree.NewNodeWithID(1, "1.0"))
-	tr.Add(1, tree.NewNodeWithID(2, "2.0"))
-	tr.Add(2, tree.NewNodeWithID(3, "3.0"))
+	tr.AddRoot(tree.NewNode("0.0").WithID(0))
+	tr.Add(0, tree.NewNode("1.0").WithID(1))
+	tr.Add(1, tree.NewNode("2.0").WithID(2))
+	tr.Add(2, tree.NewNode("3.0").WithID(3))
 
 	// Act
 	n, found := tr.Backtrack(3)
@@ -203,20 +203,20 @@ func TestTree_GetStructure_WhenThereIsRoot_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNodeWithID(0, "0.0"))
-	tr.Add(0, tree.NewNodeWithID(1, "1.0"))
-	tr.Add(0, tree.NewNodeWithID(2, "1.1"))
-	tr.Add(0, tree.NewNodeWithID(3, "1.2"))
-	tr.Add(1, tree.NewNodeWithID(4, "2.0"))
-	tr.Add(1, tree.NewNodeWithID(5, "2.1"))
-	tr.Add(1, tree.NewNodeWithID(6, "2.2"))
-	tr.Add(2, tree.NewNodeWithID(7, "2.0"))
-	tr.Add(2, tree.NewNodeWithID(8, "2.1"))
-	tr.Add(2, tree.NewNodeWithID(9, "2.2"))
-	tr.Add(3, tree.NewNodeWithID(10, "3.0"))
-	tr.Add(3, tree.NewNodeWithID(11, "3.1"))
-	tr.Add(3, tree.NewNodeWithID(12, "3.2"))
-	tr.Add(4, tree.NewNodeWithID(13, "4.0"))
+	tr.AddRoot(tree.NewNode("0.0"))
+	tr.Add(0, tree.NewNode("1.0"))
+	tr.Add(0, tree.NewNode("1.1"))
+	tr.Add(0, tree.NewNode("1.2"))
+	tr.Add(1, tree.NewNode("2.0"))
+	tr.Add(1, tree.NewNode("2.1"))
+	tr.Add(1, tree.NewNode("2.2"))
+	tr.Add(2, tree.NewNode("2.0"))
+	tr.Add(2, tree.NewNode("2.1"))
+	tr.Add(2, tree.NewNode("2.2"))
+	tr.Add(3, tree.NewNode("3.0"))
+	tr.Add(3, tree.NewNode("3.1"))
+	tr.Add(3, tree.NewNode("3.2"))
+	tr.Add(4, tree.NewNode("4.0"))
 
 	// Act
 	structure, found := tr.GetStructure()

From ef3c32dab98f6f809cc32b2b9171256e89e3ad5c Mon Sep 17 00:00:00 2001
From: Johnathan Fercher <johnathanfercher22@gmail.com>
Date: Sun, 24 Sep 2023 22:48:39 -0300
Subject: [PATCH 2/2] Separate node and tree packages

---
 cmd/main.go                 | 15 +++---
 {tree => node}/node.go      |  6 +--
 {tree => node}/node_test.go | 93 +++++++++++++++++++------------------
 tree/example_test.go        | 67 +++++++++++++-------------
 tree/tree.go                | 30 ++++++------
 tree/tree_test.go           | 67 +++++++++++++-------------
 6 files changed, 142 insertions(+), 136 deletions(-)
 rename {tree => node}/node.go (95%)
 rename {tree => node}/node_test.go (78%)

diff --git a/cmd/main.go b/cmd/main.go
index 7a3f5fa..b081d99 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"github.com/johnfercher/go-tree/node"
 
 	"github.com/johnfercher/go-tree/tree"
 )
@@ -10,16 +11,16 @@ import (
 func main() {
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0.0").WithID(0))
+	tr.AddRoot(node.New("0.0").WithID(0))
 
-	tr.Add(0, tree.NewNode("0.1").WithID(1))
-	tr.Add(0, tree.NewNode("0.2").WithID(2))
+	tr.Add(0, node.New("0.1").WithID(1))
+	tr.Add(0, node.New("0.2").WithID(2))
 
-	tr.Add(1, tree.NewNode("1.3").WithID(3))
-	tr.Add(1, tree.NewNode("1.4").WithID(4))
+	tr.Add(1, node.New("1.3").WithID(3))
+	tr.Add(1, node.New("1.4").WithID(4))
 
-	tr.Add(2, tree.NewNode("2.5").WithID(5))
-	tr.Add(2, tree.NewNode("2.6").WithID(6))
+	tr.Add(2, node.New("2.5").WithID(5))
+	tr.Add(2, node.New("2.6").WithID(6))
 
 	root, ok := tr.GetRoot()
 	fmt.Println(ok)             // true
diff --git a/tree/node.go b/node/node.go
similarity index 95%
rename from tree/node.go
rename to node/node.go
index 13d843e..d1014ee 100644
--- a/tree/node.go
+++ b/node/node.go
@@ -1,4 +1,4 @@
-package tree
+package node
 
 import (
 	"fmt"
@@ -13,8 +13,8 @@ type Node[T any] struct {
 	nexts    []*Node[T]
 }
 
-// NewNode creates a new node.
-func NewNode[T any](data T) *Node[T] {
+// New creates a new node.
+func New[T any](data T) *Node[T] {
 	return &Node[T]{
 		data: data,
 	}
diff --git a/tree/node_test.go b/node/node_test.go
similarity index 78%
rename from tree/node_test.go
rename to node/node_test.go
index 719dec7..8acdc7a 100644
--- a/tree/node_test.go
+++ b/node/node_test.go
@@ -1,7 +1,8 @@
-package tree_test
+package node_test
 
 import (
 	"fmt"
+	"github.com/johnfercher/go-tree/node"
 	"testing"
 
 	"github.com/johnfercher/go-tree/tree"
@@ -28,17 +29,17 @@ func TestNewNode(t *testing.T) {
 		"int",
 		"float64",
 		"string",
-		"*tree_test.anyType",
+		"*node_test.anyType",
 	}
 
 	for i, element := range elements {
 		// Act
-		sut := tree.NewNode(element)
+		sut := node.New(element)
 		data := sut.GetData()
 
 		// Assert
 		assert.NotNil(t, sut)
-		assert.Equal(t, "*tree.Node[interface {}]", fmt.Sprintf("%T", sut))
+		assert.Equal(t, "*node.Node[interface {}]", fmt.Sprintf("%T", sut))
 		assert.Equal(t, element, data)
 		assert.Equal(t, types[i], fmt.Sprintf("%T", data))
 	}
@@ -46,7 +47,7 @@ func TestNewNode(t *testing.T) {
 
 func TestNode_GetData(t *testing.T) {
 	// Arrange
-	sut := tree.NewNode(42)
+	sut := node.New(42)
 
 	// Act
 	data := sut.GetData()
@@ -57,8 +58,8 @@ func TestNode_GetData(t *testing.T) {
 
 func TestNode_GetNexts(t *testing.T) {
 	// Arrange
-	sut := tree.NewNode(42)
-	leaf := tree.NewNode(43)
+	sut := node.New(42)
+	leaf := node.New(43)
 	sut.AddNext(leaf)
 
 	// Act
@@ -72,8 +73,8 @@ func TestNode_GetNexts(t *testing.T) {
 
 func TestNode_GetPrevious(t *testing.T) {
 	// Arrange
-	root := tree.NewNode(42)
-	sut := tree.NewNode(43)
+	root := node.New(42)
+	sut := node.New(43)
 	root.AddNext(sut)
 
 	// Act
@@ -86,9 +87,9 @@ func TestNode_GetPrevious(t *testing.T) {
 
 func TestNode_IsRoot(t *testing.T) {
 	// Arrange
-	root := tree.NewNode(42)
-	anyNode := tree.NewNode(43)
-	leaf := tree.NewNode(44)
+	root := node.New(42)
+	anyNode := node.New(43)
+	leaf := node.New(44)
 
 	root.AddNext(anyNode)
 	anyNode.AddNext(leaf)
@@ -106,9 +107,9 @@ func TestNode_IsRoot(t *testing.T) {
 
 func TestNode_IsLeaf(t *testing.T) {
 	// Arrange
-	root := tree.NewNode(42)
-	anyNode := tree.NewNode(43)
-	leaf := tree.NewNode(44)
+	root := node.New(42)
+	anyNode := node.New(43)
+	leaf := node.New(44)
 
 	root.AddNext(anyNode)
 	anyNode.AddNext(leaf)
@@ -126,9 +127,9 @@ func TestNode_IsLeaf(t *testing.T) {
 
 func TestNode_Backtrack_WhenBuildManually_ShouldReturnCorrectly(t *testing.T) {
 	// Arrange
-	root := tree.NewNode(42)
-	anyNode := tree.NewNode(43)
-	leaf := tree.NewNode(44)
+	root := node.New(42)
+	anyNode := node.New(43)
+	leaf := node.New(44)
 
 	root.AddNext(anyNode)
 	anyNode.AddNext(leaf)
@@ -148,20 +149,20 @@ func TestNode_Backtrack_WhenBuildByTree_ShouldReturnCorrectly(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0.0").WithID(0))
-	tr.Add(0, tree.NewNode("1.0").WithID(1))
-	tr.Add(0, tree.NewNode("1.1").WithID(2))
-	tr.Add(0, tree.NewNode("1.2").WithID(3))
-	tr.Add(1, tree.NewNode("2.0").WithID(4))
-	tr.Add(1, tree.NewNode("2.1").WithID(5))
-	tr.Add(1, tree.NewNode("2.2").WithID(6))
-	tr.Add(2, tree.NewNode("2.0").WithID(7))
-	tr.Add(2, tree.NewNode("2.1").WithID(8))
-	tr.Add(2, tree.NewNode("2.2").WithID(9))
-	tr.Add(3, tree.NewNode("3.0").WithID(10))
-	tr.Add(3, tree.NewNode("3.1").WithID(11))
-	tr.Add(3, tree.NewNode("3.2").WithID(12))
-	tr.Add(4, tree.NewNode("4.0").WithID(13))
+	tr.AddRoot(node.New("0.0").WithID(0))
+	tr.Add(0, node.New("1.0").WithID(1))
+	tr.Add(0, node.New("1.1").WithID(2))
+	tr.Add(0, node.New("1.2").WithID(3))
+	tr.Add(1, node.New("2.0").WithID(4))
+	tr.Add(1, node.New("2.1").WithID(5))
+	tr.Add(1, node.New("2.2").WithID(6))
+	tr.Add(2, node.New("2.0").WithID(7))
+	tr.Add(2, node.New("2.1").WithID(8))
+	tr.Add(2, node.New("2.2").WithID(9))
+	tr.Add(3, node.New("3.0").WithID(10))
+	tr.Add(3, node.New("3.1").WithID(11))
+	tr.Add(3, node.New("3.2").WithID(12))
+	tr.Add(4, node.New("4.0").WithID(13))
 
 	// Act & Assert
 	// Case 0
@@ -315,20 +316,20 @@ func TestNode_GetStructure(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0.0").WithID(0))
-	tr.Add(0, tree.NewNode("1.0").WithID(1))
-	tr.Add(0, tree.NewNode("1.1").WithID(2))
-	tr.Add(0, tree.NewNode("1.2").WithID(3))
-	tr.Add(1, tree.NewNode("2.0").WithID(4))
-	tr.Add(1, tree.NewNode("2.1").WithID(5))
-	tr.Add(1, tree.NewNode("2.2").WithID(6))
-	tr.Add(2, tree.NewNode("2.0").WithID(7))
-	tr.Add(2, tree.NewNode("2.1").WithID(8))
-	tr.Add(2, tree.NewNode("2.2").WithID(9))
-	tr.Add(3, tree.NewNode("3.0").WithID(10))
-	tr.Add(3, tree.NewNode("3.1").WithID(11))
-	tr.Add(3, tree.NewNode("3.2").WithID(12))
-	tr.Add(4, tree.NewNode("4.0").WithID(13))
+	tr.AddRoot(node.New("0.0").WithID(0))
+	tr.Add(0, node.New("1.0").WithID(1))
+	tr.Add(0, node.New("1.1").WithID(2))
+	tr.Add(0, node.New("1.2").WithID(3))
+	tr.Add(1, node.New("2.0").WithID(4))
+	tr.Add(1, node.New("2.1").WithID(5))
+	tr.Add(1, node.New("2.2").WithID(6))
+	tr.Add(2, node.New("2.0").WithID(7))
+	tr.Add(2, node.New("2.1").WithID(8))
+	tr.Add(2, node.New("2.2").WithID(9))
+	tr.Add(3, node.New("3.0").WithID(10))
+	tr.Add(3, node.New("3.1").WithID(11))
+	tr.Add(3, node.New("3.2").WithID(12))
+	tr.Add(4, node.New("4.0").WithID(13))
 
 	node, _ := tr.Get(0)
 
diff --git a/tree/example_test.go b/tree/example_test.go
index e24af9c..16a9896 100644
--- a/tree/example_test.go
+++ b/tree/example_test.go
@@ -2,6 +2,7 @@ package tree_test
 
 import (
 	"fmt"
+	"github.com/johnfercher/go-tree/node"
 
 	"github.com/johnfercher/go-tree/tree"
 )
@@ -11,7 +12,7 @@ func ExampleNew() {
 	tr := tree.New[string]()
 
 	// Add nodes do tree
-	tr.AddRoot(tree.NewNode("root"))
+	tr.AddRoot(node.New("root"))
 
 	// Do more things
 }
@@ -20,7 +21,7 @@ func ExampleNew() {
 func ExampleTree_AddRoot() {
 	tr := tree.New[int]()
 
-	tr.AddRoot(tree.NewNode(42))
+	tr.AddRoot(node.New(42))
 
 	// Do more things
 }
@@ -28,7 +29,7 @@ func ExampleTree_AddRoot() {
 // ExampleTree_GetRoot demonstrates how to retrieve root node from tree.
 func ExampleTree_GetRoot() {
 	tr := tree.New[float64]()
-	tr.AddRoot(tree.NewNode(3.14))
+	tr.AddRoot(node.New(3.14))
 
 	node, ok := tr.GetRoot()
 	if !ok {
@@ -42,9 +43,9 @@ func ExampleTree_GetRoot() {
 // ExampleTree_Add demonstrates how to add node to tree.
 func ExampleTree_Add() {
 	tr := tree.New[bool]()
-	tr.AddRoot(tree.NewNode(true))
+	tr.AddRoot(node.New(true))
 
-	tr.Add(0, tree.NewNode(false))
+	tr.Add(0, node.New(false))
 
 	// Do more things
 }
@@ -52,7 +53,7 @@ func ExampleTree_Add() {
 // ExampleTree_Get demonstrates how to retrieve node from tree.
 func ExampleTree_Get() {
 	tr := tree.New[uint]()
-	tr.AddRoot(tree.NewNode(uint(42)))
+	tr.AddRoot(node.New(uint(42)))
 
 	node, ok := tr.Get(0)
 	if !ok {
@@ -66,10 +67,10 @@ func ExampleTree_Get() {
 // ExampleTree_Backtrack demonstrates how to retrieve path of nodes from node to root.
 func ExampleTree_Backtrack() {
 	tr := tree.New[string]()
-	tr.AddRoot(tree.NewNode("root"))
-	tr.Add(0, tree.NewNode("level1"))
-	tr.Add(1, tree.NewNode("level2"))
-	tr.Add(2, tree.NewNode("leaf"))
+	tr.AddRoot(node.New("root"))
+	tr.Add(0, node.New("level1"))
+	tr.Add(1, node.New("level2"))
+	tr.Add(2, node.New("leaf"))
 
 	nodes, ok := tr.Backtrack(3)
 	if !ok {
@@ -85,10 +86,10 @@ func ExampleTree_Backtrack() {
 // ExampleTree_GetStructure demonstrates how to retrieve tree structure.
 func ExampleTree_GetStructure() {
 	tr := tree.New[string]()
-	tr.AddRoot(tree.NewNode("root"))
-	tr.Add(0, tree.NewNode("level1"))
-	tr.Add(1, tree.NewNode("level2"))
-	tr.Add(2, tree.NewNode("leaf"))
+	tr.AddRoot(node.New("root"))
+	tr.Add(0, node.New("level1"))
+	tr.Add(1, node.New("level2"))
+	tr.Add(2, node.New("leaf"))
 
 	structure, ok := tr.GetStructure()
 	if !ok {
@@ -101,9 +102,9 @@ func ExampleTree_GetStructure() {
 	// Do more things
 }
 
-// NewNode demonstrates how to create a node with ID.
+// New demonstrates how to create a node with ID.
 func ExampleNewNode() {
-	n := tree.NewNode("node")
+	n := node.New("node")
 
 	n.GetData()
 
@@ -112,7 +113,7 @@ func ExampleNewNode() {
 
 // ExampleNode_GetData demonstrates how to retrieve data from node.
 func ExampleNode_GetData() {
-	n := tree.NewNode(3.14)
+	n := node.New(3.14)
 
 	data := n.GetData()
 	fmt.Println(data)
@@ -122,7 +123,7 @@ func ExampleNode_GetData() {
 
 // ExampleNode_GetID demonstrates how to retrieve id from node.
 func ExampleNode_GetID() {
-	n := tree.NewNode(3.14).WithID(1)
+	n := node.New(3.14).WithID(1)
 
 	id := n.GetID()
 	fmt.Println(id)
@@ -132,8 +133,8 @@ func ExampleNode_GetID() {
 
 // ExampleNode_GetNexts demonstrates how to retrieve next nodes from node.
 func ExampleNode_GetNexts() {
-	root := tree.NewNode("root")
-	leaf := tree.NewNode("leaf")
+	root := node.New("root")
+	leaf := node.New("leaf")
 
 	root.AddNext(leaf)
 	nexts := root.GetNexts()
@@ -144,8 +145,8 @@ func ExampleNode_GetNexts() {
 
 // ExampleNode_GetPrevious demonstrates how to retrieve next nodes from node.
 func ExampleNode_GetPrevious() {
-	root := tree.NewNode("root")
-	leaf := tree.NewNode("leaf")
+	root := node.New("root")
+	leaf := node.New("leaf")
 
 	root.AddNext(leaf)
 	previous := leaf.GetPrevious()
@@ -156,7 +157,7 @@ func ExampleNode_GetPrevious() {
 
 // ExampleNode_IsRoot demonstrates how to retrieve info if node is root.
 func ExampleNode_IsRoot() {
-	n := tree.NewNode('b')
+	n := node.New('b')
 
 	root := n.IsRoot()
 	fmt.Println(root)
@@ -166,8 +167,8 @@ func ExampleNode_IsRoot() {
 
 // ExampleNode_IsLeaf demonstrates how to retrieve info if node is leaf.
 func ExampleNode_IsLeaf() {
-	n1 := tree.NewNode('a')
-	n2 := tree.NewNode('b')
+	n1 := node.New('a')
+	n2 := node.New('b')
 
 	n1.AddNext(n2)
 
@@ -179,9 +180,9 @@ func ExampleNode_IsLeaf() {
 
 // ExampleNode_Backtrack demonstrates how to retrieve the path between node to root.
 func ExampleNode_Backtrack() {
-	n1 := tree.NewNode('a')
-	n2 := tree.NewNode('b')
-	n3 := tree.NewNode('c')
+	n1 := node.New('a')
+	n2 := node.New('b')
+	n3 := node.New('c')
 
 	n1.AddNext(n2)
 	n2.AddNext(n3)
@@ -196,9 +197,9 @@ func ExampleNode_Backtrack() {
 
 // ExampleNode_GetStructure demonstrates how to retrieve the tree structure from node.
 func ExampleNode_GetStructure() {
-	n1 := tree.NewNode('a')
-	n2 := tree.NewNode('b')
-	n3 := tree.NewNode('c')
+	n1 := node.New('a')
+	n2 := node.New('b')
+	n3 := node.New('c')
 
 	n1.AddNext(n2)
 	n2.AddNext(n3)
@@ -213,8 +214,8 @@ func ExampleNode_GetStructure() {
 
 // ExampleNode_AddNext demonstrates how to add a node to a parent.
 func ExampleNode_AddNext() {
-	n1 := tree.NewNode('a')
-	n2 := tree.NewNode('b')
+	n1 := node.New('a')
+	n2 := node.New('b')
 
 	n1.AddNext(n2)
 
diff --git a/tree/tree.go b/tree/tree.go
index 57ee8f9..afadf25 100644
--- a/tree/tree.go
+++ b/tree/tree.go
@@ -1,9 +1,11 @@
 package tree
 
+import "github.com/johnfercher/go-tree/node"
+
 // nolint:structcheck,gocritic
 // Tree represents the main entity of the package.
 type Tree[T any] struct {
-	root *Node[T]
+	root *node.Node[T]
 }
 
 // New creates a new Tree.
@@ -12,9 +14,9 @@ func New[T any]() *Tree[T] {
 }
 
 // AddRoot adds a root node to Tree.
-func (t *Tree[T]) AddRoot(node *Node[T]) (addedRoot bool) {
+func (t *Tree[T]) AddRoot(n *node.Node[T]) (addedRoot bool) {
 	if t.root == nil {
-		t.root = node
+		t.root = n
 		return true
 	}
 
@@ -22,7 +24,7 @@ func (t *Tree[T]) AddRoot(node *Node[T]) (addedRoot bool) {
 }
 
 // GetRoot retrieves the root node from Tree.
-func (t *Tree[T]) GetRoot() (root *Node[T], hasRoot bool) {
+func (t *Tree[T]) GetRoot() (root *node.Node[T], hasRoot bool) {
 	if t.root == nil {
 		return nil, false
 	}
@@ -31,7 +33,7 @@ func (t *Tree[T]) GetRoot() (root *Node[T], hasRoot bool) {
 }
 
 // Add adds a node into a parent node.
-func (t *Tree[T]) Add(parentID int, node *Node[T]) (addedNode bool) {
+func (t *Tree[T]) Add(parentID int, node *node.Node[T]) (addedNode bool) {
 	if t.root == nil {
 		return false
 	}
@@ -40,12 +42,12 @@ func (t *Tree[T]) Add(parentID int, node *Node[T]) (addedNode bool) {
 }
 
 // Get retrieves node from Tree.
-func (t *Tree[T]) Get(id int) (node *Node[T], found bool) {
+func (t *Tree[T]) Get(id int) (node *node.Node[T], found bool) {
 	if t.root == nil {
 		return nil, false
 	}
 
-	if t.root.id == id {
+	if t.root.GetID() == id {
 		return t.root, true
 	}
 
@@ -53,7 +55,7 @@ func (t *Tree[T]) Get(id int) (node *Node[T], found bool) {
 }
 
 // Backtrack retrieves a path from node to root.
-func (t *Tree[T]) Backtrack(id int) ([]*Node[T], bool) {
+func (t *Tree[T]) Backtrack(id int) ([]*node.Node[T], bool) {
 	n, found := t.Get(id)
 	if !found {
 		return nil, found
@@ -71,13 +73,13 @@ func (t *Tree[T]) GetStructure() ([]string, bool) {
 	return t.root.GetStructure(), true
 }
 
-func (t *Tree[T]) add(parentID int, parentNode *Node[T], newNode *Node[T]) bool {
-	if parentID == parentNode.id {
+func (t *Tree[T]) add(parentID int, parentNode *node.Node[T], newNode *node.Node[T]) bool {
+	if parentID == parentNode.GetID() {
 		parentNode.AddNext(newNode)
 		return true
 	}
 
-	for _, next := range parentNode.nexts {
+	for _, next := range parentNode.GetNexts() {
 		added := t.add(parentID, next, newNode)
 		if added {
 			return true
@@ -87,9 +89,9 @@ func (t *Tree[T]) add(parentID int, parentNode *Node[T], newNode *Node[T]) bool
 	return false
 }
 
-func (t *Tree[T]) get(id int, parent *Node[T]) (*Node[T], bool) {
-	for _, next := range parent.nexts {
-		if next.id == id {
+func (t *Tree[T]) get(id int, parent *node.Node[T]) (*node.Node[T], bool) {
+	for _, next := range parent.GetNexts() {
+		if next.GetID() == id {
 			return next, true
 		}
 
diff --git a/tree/tree_test.go b/tree/tree_test.go
index 739fbb1..7a1caf9 100644
--- a/tree/tree_test.go
+++ b/tree/tree_test.go
@@ -2,6 +2,7 @@ package tree_test
 
 import (
 	"fmt"
+	"github.com/johnfercher/go-tree/node"
 	"testing"
 
 	"github.com/johnfercher/go-tree/tree"
@@ -22,7 +23,7 @@ func TestTree_AddRoot_WhenTreeIsEmpty_ShouldReturnTrue(t *testing.T) {
 	sut := tree.New[int]()
 
 	// Act
-	added := sut.AddRoot(tree.NewNode(42))
+	added := sut.AddRoot(node.New(42))
 
 	// Assert
 	assert.True(t, added)
@@ -33,8 +34,8 @@ func TestTree_AddRoot_WhenTreeIsNotEmpty_ShouldReturnFalse(t *testing.T) {
 	sut := tree.New[int]()
 
 	// Act
-	_ = sut.AddRoot(tree.NewNode(42))
-	added := sut.AddRoot(tree.NewNode(43))
+	_ = sut.AddRoot(node.New(42))
+	added := sut.AddRoot(node.New(43))
 
 	// Assert
 	assert.False(t, added)
@@ -55,7 +56,7 @@ func TestTree_GetRoot_WhenThereIsNotRoot_ShouldReturnFalse(t *testing.T) {
 func TestTree_GetRoot_WhenThereIsRoot_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	sut := tree.New[int]()
-	sut.AddRoot(tree.NewNode(42))
+	sut.AddRoot(node.New(42))
 
 	// Act
 	root, hasRoot := sut.GetRoot()
@@ -70,7 +71,7 @@ func TestTree_Add_WhenThereIsNoRoot_ShouldReturnFalse(t *testing.T) {
 	tr := tree.New[int]()
 
 	// Act
-	added := tr.Add(0, tree.NewNode(42))
+	added := tr.Add(0, node.New(42))
 
 	// Assert
 	assert.False(t, added)
@@ -81,8 +82,8 @@ func TestTree_Add_WhenRootIsNotRight_ShouldReturnTrue(t *testing.T) {
 	tr := tree.New[int]()
 
 	// Act
-	_ = tr.AddRoot(tree.NewNode(42))
-	added := tr.Add(3, tree.NewNode(42))
+	_ = tr.AddRoot(node.New(42))
+	added := tr.Add(3, node.New(42))
 
 	// Assert
 	assert.False(t, added)
@@ -93,8 +94,8 @@ func TestTree_Add_WhenThereIsRootAndRootIsRight_ShouldReturnTrue(t *testing.T) {
 	tr := tree.New[int]()
 
 	// Act
-	_ = tr.AddRoot(tree.NewNode(42))
-	added := tr.Add(0, tree.NewNode(42))
+	_ = tr.AddRoot(node.New(42))
+	added := tr.Add(0, node.New(42))
 
 	// Assert
 	assert.True(t, added)
@@ -116,8 +117,8 @@ func TestTree_Get_WhenThereIsNoId_ShouldReturnFalse(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0"))
-	tr.Add(0, tree.NewNode("1.0"))
+	tr.AddRoot(node.New("0"))
+	tr.Add(0, node.New("1.0"))
 
 	// Act
 	node, found := tr.Get(8)
@@ -131,7 +132,7 @@ func TestTree_Get_WhenThereIsIdOnRoot_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0"))
+	tr.AddRoot(node.New("0"))
 
 	// Act
 	node, found := tr.Get(0)
@@ -145,8 +146,8 @@ func TestTree_Get_WhenThereIsId_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0").WithID(0))
-	tr.Add(0, tree.NewNode("1.0").WithID(1))
+	tr.AddRoot(node.New("0").WithID(0))
+	tr.Add(0, node.New("1.0").WithID(1))
 
 	// Act
 	node, found := tr.Get(1)
@@ -160,7 +161,7 @@ func TestTree_Backtrack_WhenIdNotFound_ShouldReturnFalse(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0.0"))
+	tr.AddRoot(node.New("0.0"))
 
 	// Act
 	n, found := tr.Backtrack(1)
@@ -174,10 +175,10 @@ func TestTree_Backtrack_WhenIdFound_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0.0").WithID(0))
-	tr.Add(0, tree.NewNode("1.0").WithID(1))
-	tr.Add(1, tree.NewNode("2.0").WithID(2))
-	tr.Add(2, tree.NewNode("3.0").WithID(3))
+	tr.AddRoot(node.New("0.0").WithID(0))
+	tr.Add(0, node.New("1.0").WithID(1))
+	tr.Add(1, node.New("2.0").WithID(2))
+	tr.Add(2, node.New("3.0").WithID(3))
 
 	// Act
 	n, found := tr.Backtrack(3)
@@ -203,20 +204,20 @@ func TestTree_GetStructure_WhenThereIsRoot_ShouldReturnTrue(t *testing.T) {
 	// Arrange
 	tr := tree.New[string]()
 
-	tr.AddRoot(tree.NewNode("0.0"))
-	tr.Add(0, tree.NewNode("1.0"))
-	tr.Add(0, tree.NewNode("1.1"))
-	tr.Add(0, tree.NewNode("1.2"))
-	tr.Add(1, tree.NewNode("2.0"))
-	tr.Add(1, tree.NewNode("2.1"))
-	tr.Add(1, tree.NewNode("2.2"))
-	tr.Add(2, tree.NewNode("2.0"))
-	tr.Add(2, tree.NewNode("2.1"))
-	tr.Add(2, tree.NewNode("2.2"))
-	tr.Add(3, tree.NewNode("3.0"))
-	tr.Add(3, tree.NewNode("3.1"))
-	tr.Add(3, tree.NewNode("3.2"))
-	tr.Add(4, tree.NewNode("4.0"))
+	tr.AddRoot(node.New("0.0"))
+	tr.Add(0, node.New("1.0"))
+	tr.Add(0, node.New("1.1"))
+	tr.Add(0, node.New("1.2"))
+	tr.Add(1, node.New("2.0"))
+	tr.Add(1, node.New("2.1"))
+	tr.Add(1, node.New("2.2"))
+	tr.Add(2, node.New("2.0"))
+	tr.Add(2, node.New("2.1"))
+	tr.Add(2, node.New("2.2"))
+	tr.Add(3, node.New("3.0"))
+	tr.Add(3, node.New("3.1"))
+	tr.Add(3, node.New("3.2"))
+	tr.Add(4, node.New("4.0"))
 
 	// Act
 	structure, found := tr.GetStructure()