How to find span of control from a hierarchical data in Go programming language

Span of control refers to the number of people reporting to a manager both directly and indirectly(i.e., including the number of people reporting to the people reporting to him/her up until down below where the member has no one reporting to him/her) to know the full size of the team in his/her org structure.

I've put an implementation below. It gives the correct result But, I'm not sure if this is the best way really. I'm a novice. Can some one please recommend a better way to achieve this in Go language? Probably a more elegant approach, if possible. Thanks in advance!

package main

import "fmt"

func main() {

	orgData := []EmpRecord{
		{"E123", "Annapurna", "E456", "Ananya"},
		{"E789", "Arya", "E234", "Manisha"},
		{"E345", "Madhura", "E456", "Ananya"},
		{"E456", "Ananya", "E234", "Manisha"},
		{"E567", "Bharat", "E123", "Annapurna"},
		{"E678", "Shart", "E789", "Arya"},
		{"E101", "Akash", "E123", "Annapurna"},
		{"E102", "Anil", "E789", "Arya"},
		{"E103", "Vikas", "E123", "Annapurna"},
		{"E104", "Vivek", "E123", "Annapurna"},
		{"E105", "Ankita", "E456", "Ananya"},
		{"E106", "Atul", "E123", "Annapurna"},
		{"E107", "Priya", "E789", "Arya"},
		{"E234", "Manisha", "E999", "Albert"},
	}

	socList := make(map[string]int)
	var ix int = 0

	soc(orgData, socList, &ix)

	fmt.Println(socList)

}

type EmpRecord struct {
	EmpId   string
	EmpName string
	SupId   string
	SupName string
}

func soc(m []EmpRecord, socList map[string]int, rc *int) {
	for _, v := range m {
		_, ok := socList[v.SupId]
		if !ok {
			loopRecurive(v.SupId, m, rc)
			if *rc > 0 {
				socList[v.SupId] = *rc
				*rc = 0
			}
		}
	}

}

func loopRecurive(v string, er []EmpRecord, rc *int) {
	for _, x := range er {
		if v == x.SupId {
			*rc++
			loopRecurive(x.EmpId, er, rc)
		}
	}
}

The final output prints map[E123:5 E234:13 E456:8 E789:3 E999:14]

This is more of an algorithmic problem than language-specific. The hierarchical data follows a tree structure.

If you see the relationship's here will be something like Employee has one leader and leader can have more than one direct-reportees. If we build a tree-like structure this will be easier.

Tree Node Structure

type EmpRecord struct {
EmpId   string
EmpName string
reportees     *EmpRecord[]
}

Note that you will have to create the rootNode first that will be the CEO or head of the department.

Now in order to find all the direct reportees you can use Breadth-First approach to find employees by level or depth-first-approach to find all the direct-indirect reporters with no specific ordering.

Note: You will need to know the address of the node corresponding to a particular employee. You can use a hashmap s.t [empName] => [pointer to employeeRecord] or whichever key works.

Note:- If you want to search the other way. From employees to all his manager's you can create two-way tree structure. Where you will also keep pointer to the superior with the node.

> Can some one please recommend a better way...

"better way" can mean many things including:

• Quicker
• Lower memory use
• Easier to understand/maintain

As such your question is subjective; we can show you other ways of doing this but cannot really say that they are "better". Below is one alternative approach that I feel is easier to understand (playground).

package main
import "fmt"
type EmpRecord struct {
EmpId   string
EmpName string
SupId   string
SupName string
}
type EmpWithReports struct {
EmpRecord
Reports []*EmpWithReports
}
func main() {
orgData := []EmpRecord{
{"E123", "Annapurna", "E456", "Ananya"},
{"E789", "Arya", "E234", "Manisha"},
{"E345", "Madhura", "E456", "Ananya"},
{"E456", "Ananya", "E234", "Manisha"},
{"E567", "Bharat", "E123", "Annapurna"},
{"E678", "Shart", "E789", "Arya"},
{"E101", "Akash", "E123", "Annapurna"},
{"E102", "Anil", "E789", "Arya"},
{"E103", "Vikas", "E123", "Annapurna"},
{"E104", "Vivek", "E123", "Annapurna"},
{"E105", "Ankita", "E456", "Ananya"},
{"E106", "Atul", "E123", "Annapurna"},
{"E107", "Priya", "E789", "Arya"},
{"E234", "Manisha", "E999", "Albert"},
}
empMap := make(map[string]*EmpWithReports)
for _, emp := range orgData {
empMap[emp.EmpId] = &EmpWithReports{EmpRecord: emp}
}
// Add reports for each employee
for _, e := range empMap {
if boss := empMap[e.SupId]; boss != nil {
boss.Reports = append(boss.Reports, e)
} else if e.SupId != "E999" {
panic(fmt.Sprintf("Employee %s: Boss %s not found", e.EmpId, e.SupId))
}
}
// Get the counts
socList := make(map[string]int)
for _, e := range empMap {
s := soc(empMap, e)
if s > 0 {
socList[e.EmpId] = s
}
}
fmt.Println(socList)
}
func soc(empMap map[string]*EmpWithReports, emp *EmpWithReports) int {
var s int
for _, rep := range emp.Reports {
s += 1 + soc(empMap, rep)
}
return s
}

The results are map[E123:5 E234:13 E456:8 E789:3] (E999 is not included because they are not in the list; this would be simple to add if required).