Add transponding

Makefile

@@ -12,7 +12,7 @@ race:
 
 .PHONY: bench
 bench: ## Бенчмарки
-	go test -benchtime=1000x -benchmem -bench=Benchmark ./... | grep allocs
+	go test -benchtime=10x -benchmem -bench=Benchmark ./... | grep allocs
 
 help: ## Print this help and exit
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

cut_the_tree/test_models.go

@@ -1,39 +0,0 @@
-package main
-
-import (
-	"github.com/google/uuid"
-	"maps"
-)
-
-type TestTree struct {
-	Tree    *Node
-	Weights map[string]uint16
-}
-
-func getTestTree(branches, depth int) TestTree {
-	if depth == 0 {
-		return TestTree{}
-	}
-	id := uuid.NewString()
-	node := &Node{
-		ID:   id,
-		Name: id,
-	}
-	tree := TestTree{
-		Tree:    node,
-		Weights: map[string]uint16{id: node.getNodeWeight()},
-	}
-
-	for i := 0; i < branches; i++ {
-		childTree := getTestTree(branches, depth-1)
-		if childTree.Tree != nil {
-			tree.Tree.Children = append(tree.Tree.Children, childTree.Tree)
-			maps.Copy(tree.Weights, childTree.Weights)
-		}
-	}
-	for _, child := range tree.Tree.Children {
-		tree.Weights[id] = tree.Weights[id] + tree.Weights[child.ID]
-	}
-
-	return tree
-}

weghting_the_tree/README.md

@@ -1,3 +1,3 @@
-## Алгоритм кумулятивного взвешивания и нарезки на ветви асинхронного дерева
+## Алгоритм кумулятивного взвешивания асинхронного дерева
 
 Стояла задача передавать огромное JSON дерево, которое целиком не пролезало в nginx. Исходя из предусловия, что дерево может быть сколь угодно большого размера, не стали полагаться на увеличение лимита и/или применение сжатия, было принято решение искать способ нарезать его на поддеревья, передать частями и на месте собрать.

weghting_the_tree/funcs.go

@@ -3,7 +3,7 @@ package main
 import (
 	"encoding/json"
 	"maps"
-	"tests/cut_the_tree/dll"
+	"tests/weghting_the_tree/dll"
 )
 
 type Node struct {
@@ -13,27 +13,35 @@ type Node struct {
 }
 
 type WeightedNode struct {
-	parent string
+	node     *Node
-	weight uint16
+	parent   *Node
+	children []*Node
+	weight   uint16
 }
 
-func (root Node) WeightingTreeWithRecursion() map[string]uint16 {
+func (root *Node) WeightingTreeWithRecursion(parent *Node) map[string]*WeightedNode {
 	weight := root.getNodeWeight()
-	var res = make(map[string]uint16)
+	var res = map[string]*WeightedNode{
-	for _, v := range root.Children {
+		root.ID: {
-		maps.Copy(res, v.WeightingTreeWithRecursion()) // Т.е. в go нет оптимизации хвостовой рекурсии, это породит неимоверное кол-во аллокаций.
+			node:   root,
-		weight = weight + res[v.ID]
+			parent: parent,
+		},
 	}
-	res[root.ID] = weight
+	for _, v := range root.Children {
+		maps.Copy(res, v.WeightingTreeWithRecursion(root))
+		//weight = weight + res[v.ID].weight
+		res[root.ID].children = append(res[root.ID].children, v)
+	}
+	res[root.ID].weight = weight
 	return res
 }
 
-func (root Node) WeightingTreeWithStack() map[string]uint16 {
+func (root *Node) WeightingTreeWithStack(parent *Node) map[string]*WeightedNode {
 	weight := root.getNodeWeight()
 	counter := map[string]*WeightedNode{root.ID: {
 		weight: weight,
 	}}
-	stack := []*Node{&root}
+	stack := []*Node{root}
 	for len(stack) > 0 {
 		current := stack[len(stack)-1]
 		stack = stack[:len(stack)-1]
@@ -43,31 +51,26 @@ func (root Node) WeightingTreeWithStack() map[string]uint16 {
 		// Прибавляем вес всем родительским нодам до корня
 		parentID := counter[current.ID].parent
 		for {
-			currentNode := counter[parentID]
+			if parentID == nil {
-			if parentID == "" {
 				break
 			}
+			currentNode := counter[parent.ID]
 			currentNode.weight = currentNode.weight + nodeWeight
 			parentID = currentNode.parent
 		}
 
 		for _, child := range current.Children {
 			counter[child.ID] = &WeightedNode{
-				parent: current.ID,
+				parent: current,
 			}
 			stack = append(stack, child)
 		}
 	}
 
-	var res = make(map[string]uint16)
+	return counter
-	for k, v := range counter {
-		res[k] = v.weight
-	}
-
-	return res
 }
 
-func (root Node) WeightingTreeWithDLL() map[string]uint16 {
+func (root *Node) WeightingTreeWithDLL(parent *Node) map[string]*WeightedNode {
 	weight := root.getNodeWeight()
 	counter := map[string]*WeightedNode{root.ID: {
 		weight: weight,
@@ -79,44 +82,36 @@ func (root Node) WeightingTreeWithDLL() map[string]uint16 {
 		current := dllist.Front()
 		dllist.Remove(current)
 
-		nodeWeight := current.Value.(Node).getNodeWeight()
+		nodeWeight := current.Value.(*Node).getNodeWeight()
 		counter[current.Value.(Node).ID].weight = nodeWeight
 		// Прибавляем вес всем родительским нодам до корня
-		parentID := counter[current.Value.(Node).ID].parent
+		parentNode := counter[current.Value.(Node).ID].parent
 		for {
-			currentNode := counter[parentID]
+			currentNode := counter[parentNode.ID]
-			if parentID == "" {
+			if parentNode == nil {
 				break
 			}
 			currentNode.weight = currentNode.weight + nodeWeight
-			parentID = currentNode.parent
+			parentNode = currentNode.parent
 		}
 
 		for _, child := range current.Value.(Node).Children {
 			counter[child.ID] = &WeightedNode{
-				parent: current.Value.(Node).ID,
+				parent: current.Value.(*Node),
 			}
 			dllist.PushFront(*child)
 		}
 	}
 
-	var res = make(map[string]uint16)
+	return counter
-	for k, v := range counter {
-		res[k] = v.weight
-	}
-
-	return res
 }
 
-func (root Node) DecomposeTree(weights map[string]uint16, limit int) ([]*Node, error) {
+//func DecomposeTree(tree map[string]*WeightedNode, limit int) ([]SubTree, error) {
+//
+//	return nil, nil
+//}
 
-	return nil, nil
+func (n *Node) getNodeWeight() uint16 {
-}
+	nodeBytes, _ := json.Marshal(n)
-
-func (n Node) getNodeWeight() uint16 {
-	nodeBytes, _ := json.Marshal(Node{
-		ID:   n.ID,
-		Name: n.Name,
-	})
 	return uint16(len(nodeBytes))
 }

weghting_the_tree/funcs_test.go

@@ -1,29 +1,32 @@
 package main
 
 import (
+"fmt"
+"sort"
+"testing"
 
 "github.com/stretchr/testify/assert"
-"testing"
 )
 
 
 func TestNode_WeighingTreeAllAlgo(t *testing.T) {
 	for name,tt := range map[string]TestTree{
-		"Ordinary VFS tree": getTestTree(4, 4),
+		"Ordinary VFS tree": getTestTree(3, 3, nil),
-		"VFS in the form of a pathological tree":getTestTree(1, 100),
+		//"VFS in the form of a pathological tree":getTestTree(1, 4, nil),
 	}{
 		t.Run(name,func(t *testing.T) {
-			assert.EqualValues(t, tt.Weights, tt.Tree.WeightingTreeWithRecursion())
+			weightTreeWithRecursion := tt.Tree.WeightingTreeWithRecursion(nil)
-			assert.EqualValues(t, tt.Weights, tt.Tree.WeightingTreeWithStack())
+			printExpectations(tt.Weights, weightTreeWithRecursion)
-			assert.EqualValues(t, tt.Weights, tt.Tree.WeightingTreeWithDLL())
+			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)
 		})
 	}
 }
 
-func TestNode_DecomposeTree(t *testing.T)  {
+/*
-
-}
-
 func Benchmark(b *testing.B)  {
 	b.StopTimer()
 	b.ResetTimer()
@@ -68,3 +71,18 @@ func Benchmark(b *testing.B)  {
 	}
 }
 
+*/
+
+func printExpectations(expected, actual map[string]*WeightedNode)  {
+	var expectedSlice, actualSlice []int
+	for _,v := range expected {
+		expectedSlice = append(expectedSlice, int(v.weight))
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(expectedSlice)))
+	for _,v := range actual {
+		actualSlice = append(actualSlice, int(v.weight))
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(actualSlice)))
+	fmt.Printf("expected: %+v\n", expectedSlice)
+	fmt.Printf("actual  : %+v\n", actualSlice)
+}

weghting_the_tree/test_models.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"github.com/google/uuid"
+	"maps"
+)
+
+type TestTree struct {
+	Tree    *Node
+	Weights map[string]*WeightedNode
+}
+
+func getTestTree(branches, depth int, parent *Node) TestTree {
+	if depth == 0 {
+		return TestTree{}
+	}
+	id := uuid.NewString()
+	node := &Node{
+		ID:       id,
+		Name:     id,
+		Children: []*Node{},
+	}
+	tree := TestTree{
+		Tree: node,
+		Weights: map[string]*WeightedNode{id: &WeightedNode{
+			node:     node,
+			parent:   parent,
+			children: nil,
+			weight:   node.getNodeWeight(),
+		}},
+	}
+	for i := 0; i < branches; i++ {
+		childTree := getTestTree(branches, depth-1, node)
+		if childTree.Tree != nil {
+			tree.Tree.Children = append(tree.Tree.Children, childTree.Tree)
+			tree.Weights[id].children = append(tree.Weights[id].children, childTree.Tree)
+			maps.Copy(tree.Weights, childTree.Weights)
+		}
+	}
+	for _, child := range tree.Tree.Children {
+		tree.Weights[id].weight = tree.Weights[id].weight + tree.Weights[child.ID].weight
+	}
+	return tree
+}