From 10006400b9572a1aa6d17f3f963eb2bf9a9f46ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B9=20=D0=98=D0=B2=D0=B0?=
 =?UTF-8?q?=D0=BD=D0=BE=D0=B2?= <andre.ivanov@vk.team>
Date: Thu, 26 Sep 2024 15:33:19 +0300
Subject: [PATCH] Fix recursion algo

---
 weghting_the_tree/funcs.go      | 27 ++++++++++++++++++++-------
 weghting_the_tree/funcs_test.go | 24 ++++++++++++++++--------
 2 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/weghting_the_tree/funcs.go b/weghting_the_tree/funcs.go
index d3df830..5637965 100644
--- a/weghting_the_tree/funcs.go
+++ b/weghting_the_tree/funcs.go
@@ -20,16 +20,22 @@ type WeightedNode struct {
 }
 
 func (root *Node) WeightingTreeWithRecursion(parent *Node) map[string]*WeightedNode {
-	weight := root.getNodeWeight()
+	weightedNode := &Node{
+		ID:       root.ID,
+		Name:     root.Name,
+		Children: []*Node{},
+	}
+	weight := weightedNode.getNodeWeight()
 	var res = map[string]*WeightedNode{
 		root.ID: {
 			node:   root,
 			parent: parent,
+			weight: weight,
 		},
 	}
 	for _, v := range root.Children {
 		maps.Copy(res, v.WeightingTreeWithRecursion(root))
-		//weight = weight + res[v.ID].weight
+		weight = weight + res[v.ID].weight
 		res[root.ID].children = append(res[root.ID].children, v)
 	}
 	res[root.ID].weight = weight
@@ -49,16 +55,18 @@ func (root *Node) WeightingTreeWithStack(parent *Node) map[string]*WeightedNode
 		nodeWeight := current.getNodeWeight()
 		counter[current.ID].weight = nodeWeight
 		// Прибавляем вес всем родительским нодам до корня
-		parentID := counter[current.ID].parent
 		for {
-			if parentID == nil {
+			if parent == nil {
 				break
 			}
 			currentNode := counter[parent.ID]
 			currentNode.weight = currentNode.weight + nodeWeight
-			parentID = currentNode.parent
+			parent = currentNode.parent
+		}
+		counter[current.ID].node = current
+		if len(current.Children) > 0 {
+			counter[current.ID].children = current.Children
 		}
-
 		for _, child := range current.Children {
 			counter[child.ID] = &WeightedNode{
 				parent: current,
@@ -112,6 +120,11 @@ func (root *Node) WeightingTreeWithDLL(parent *Node) map[string]*WeightedNode {
 //}
 
 func (n *Node) getNodeWeight() uint16 {
-	nodeBytes, _ := json.Marshal(n)
+	weighted := &Node{
+		ID:       n.ID,
+		Name:     n.Name,
+		Children: []*Node{},
+	}
+	nodeBytes, _ := json.Marshal(weighted)
 	return uint16(len(nodeBytes))
 }
diff --git a/weghting_the_tree/funcs_test.go b/weghting_the_tree/funcs_test.go
index 0164091..15bf546 100644
--- a/weghting_the_tree/funcs_test.go
+++ b/weghting_the_tree/funcs_test.go
@@ -12,16 +12,24 @@ import (
 func TestNode_WeighingTreeAllAlgo(t *testing.T) {
 	for name,tt := range map[string]TestTree{
 		"Ordinary VFS tree": getTestTree(3, 3, nil),
-		//"VFS in the form of a pathological tree":getTestTree(1, 4, nil),
+		"VFS in the form of a pathological tree":getTestTree(1, 7, nil),
 	}{
 		t.Run(name,func(t *testing.T) {
-			weightTreeWithRecursion := tt.Tree.WeightingTreeWithRecursion(nil)
-			printExpectations(tt.Weights, weightTreeWithRecursion)
-			assert.EqualValues(t, tt.Weights, weightTreeWithRecursion)
-			//weightTreeWithStack := tt.Tree.WeightingTreeWithStack(nil)
-			//assert.EqualValues(t, tt.Weights, weightTreeWithStack)
-			//weightTreeWithDLL := tt.Tree.WeightingTreeWithDLL(nil)
-			//assert.EqualValues(t, tt.Weights, weightTreeWithDLL)
+			t.Run("WeightingTreeWithRecursion", func(t *testing.T) {
+				weightTreeWithRecursion := tt.Tree.WeightingTreeWithRecursion(nil)
+				printExpectations(tt.Weights, weightTreeWithRecursion)
+				assert.EqualValues(t, tt.Weights, weightTreeWithRecursion)
+			})
+			t.Run("WeightingTreeWithStack", func(t *testing.T) {
+				weightTreeWithStack := tt.Tree.WeightingTreeWithStack(nil)
+				printExpectations(tt.Weights, weightTreeWithStack)
+				assert.EqualValues(t, tt.Weights, weightTreeWithStack)
+			})
+			//t.Run("WeightingTreeWithDLL", func(t *testing.T) {
+			//	weightTreeWithDLL := tt.Tree.WeightingTreeWithDLL(nil)
+			//	printExpectations(tt.Weights, weightTreeWithDLL)
+			//	assert.EqualValues(t, tt.Weights, weightTreeWithDLL)
+			//})
 		})
 	}
 }