具有父子关系的结构处理

在工作过程中遇到一个实现三级标签的问题，是同事写的，单说实现其实算不上有难度，但这是我第一次见到算法的实际产出应用，因为公司的代码需要保密，所以将其实现场景做了改变，只保留核心逻辑

问题

有一个结构体数组，其中包含以下属性：

id    当前标识 
cotet 内容 
parId 父标识 

根据其中连接关系对其进行排序输出，可能存在多组

解决

1. 将标签数组转换为二维 map，其格式为 map[parId]map[id]*lable
2. 将得到的 map 根据 parId 进行子内容的查询，对根据子内容的 id 作为 parId 递归查询，将所有的标签连接起来
3. 处理输出即可

package work

import "fmt"

type lable struct {
	id       int
	name     string
	parentId int
	son      []*lable
}

var lables = [...]*lable{{
	id:       1,
	name:     " 爷爷 ",
	parentId: 0,
}, {
	id:       2,
	name:     " 姥姥 ",
	parentId: 0,
}, {
	id:       3,
	name:     " 父亲 ",
	parentId: 1,
}, {
	id:       4,
	name:     " 母亲 ",
	parentId: 2,
}, {
	id:       5,
	name:     " 大儿子 ",
	parentId: 3,
}, {
	id:       6,
	name:     " 二儿子 ",
	parentId: 4,
}}

func buildLabelData(list []*lable) map[int]map[int]*lable {
	var data = make(map[int]map[int]*lable)
	for _, val := range list {
		id := val.id
		parentId := val.parentId
		if _, ok := data[parentId]; !ok {
			data[parentId] = make(map[int]*lable)
		}
		data[parentId][id] = val
	}
	return data
}

func makeTreeLabel(index int, data map[int]map[int]*lable) []*lable {
	tmp := make([]*lable, 0)
	for id, item := range data[index] {
		if data[id] != nil {
			item.son = makeTreeLabel(id, data)
		} else {
			item.son = []*lable{}
		}
		tmp = append(tmp, item)
	}
	return tmp
}

func lastOperate(labs []*lable) [][]string {
	var lastData [][]string
	for _, f := range labs {
		for _, s := range f.son {
			for _, t := range s.son {
				tmpData := []string{
					f.name,
					s.name,
					t.name,
				}
				lastData = append(lastData, tmpData)
			}
		}
	}
	return lastData
}

func Entrance() {
	data := buildLabelData(lables[:])
	labs := makeTreeLabel(0, data)
	lastData := lastOperate(labs)
	for _, slices := range lastData {
		for _, dada := range slices {
			fmt.Printf("%s\t", dada)
		}
		fmt.Println()
	}
}

result
爷爷 父亲 大儿子
姥姥 母亲 二儿子