golang生成分组树状结构

已于 2022-04-24 09:38:21 修改
阅读量1.0k 收藏 4
点赞数 1
分类专栏： golang整理 文章标签： golang
于 2022-04-22 16:49:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38923792/article/details/124349475
版权

1.需求: 获取分组导航树

在这里插入图片描述

2.实现

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Group struct {
	Id              int      `json:"id"`
	Alias           string   `json:"alias"`
	FullAlias       string   `json:"fullAlias"`
	ParentId        int      `json:"parentId"`
	ParentAlias     string   `json:"parentAlias"`
	ParentFullAlias string   `json:"parentFullAlias"`
	Children        []*Group `json:"children"`
}

func getTreeRecursive(list []*Group, parentId int, parentAlias string) []*Group {
	res := make([]*Group, 0)
	for _, v := range list {
		if v.ParentId == parentId {
			if parentAlias != "" {
				v.FullAlias = parentAlias + "/" + v.Alias
			} else {
				v.FullAlias = v.Alias
			}
			v.ParentFullAlias = parentAlias
			fullList := strings.Split(v.FullAlias, "/")
			if len(fullList) >= 2 {
				v.ParentAlias = fullList[len(fullList)-2]
			} else {
				v.ParentAlias = parentAlias
			}
			v.Children = getTreeRecursive(list, v.Id, v.FullAlias)
			// 用 alias 排序，alias相等的元素保持原始顺序
			sort.SliceStable(v.Children, func(i, j int) bool {
				return v.Children[i].Alias < v.Children[j].Alias
			})
			res = append(res, v)
		}
	}
	// 用 alias 排序，alias相等的元素保持原始顺序
	sort.SliceStable(res, func(i, j int) bool {
		return res[i].Alias < res[j].Alias
	})
	return res
}


func main() {
	list := []*Group{
		{1, "FPF引擎", "", 0, "", "", []*Group{}},
		{2, "IDP引擎", "", 0, "", "", []*Group{}},
		{3, "桂妃山", "", 1, "", "", []*Group{}},
		{4, "南沙", "", 1, "", "", []*Group{}},
		{5, "大边", "", 1, "", "", []*Group{}},
		{6, "一场", "", 3, "", "", []*Group{}},
		{9, "一线", "", 6, "", "", []*Group{}},
		{7, "二场", "", 3, "", "", []*Group{}},
		{10, "一线", "", 7, "", "", []*Group{}},
		{8, "洗消中心", "", 5, "", "", []*Group{}},
	}
	res := getTreeRecursive(list, 0, "")

	bytes, _ := json.MarshalIndent(res, "", "    ")
	fmt.Printf("%s\n", bytes)

}

结果示例：

[
    {
        "id": 1,
        "alias": "FPF引擎",
        "fullAlias": "FPF引擎",
        "parentId": 0,
        "parentAlias": "",
        "parentFullAlias": "",
        "children": [
            {
                "id": 3,
                "alias": "桂妃山",
                "fullAlias": "FPF引擎/桂妃山",
                "parentId": 1,
                "parentAlias": "FPF引擎",
                "parentFullAlias": "FPF引擎",
                "children": [
                    {
                        "id": 6,
                        "alias": "一场",
                        "fullAlias": "FPF引擎/桂妃山/一场",
                        "parentId": 3,
                        "parentAlias": "桂妃山",
                        "parentFullAlias": "FPF引擎/桂妃山",
                        "children": [
                            {
                                "id": 9,
                                "alias": "一线",
                                "fullAlias": "FPF引擎/桂妃山/一场/一线",
                                "parentId": 6,
                                "parentAlias": "一场",
                                "parentFullAlias": "FPF引擎/桂妃山/一场",
                                "children": []
                            }
                        ]
                    },
                    {
                        "id": 7,
                        "alias": "二场",
                        "fullAlias": "FPF引擎/桂妃山/二场",
                        "parentId": 3,
                        "parentAlias": "桂妃山",
                        "parentFullAlias": "FPF引擎/桂妃山",
                        "children": [
                            {
                                "id": 10,
                                "alias": "一线",
                                "fullAlias": "FPF引擎/桂妃山/二场/一线",
                                "parentId": 7,
                                "parentAlias": "二场",
                                "parentFullAlias": "FPF引擎/桂妃山/二场",
                                "children": []
                            }
                        ]
                    }
                ]
            },
            {
                "id": 4,
                "alias": "南沙",
                "fullAlias": "FPF引擎/南沙",
                "parentId": 1,
                "parentAlias": "FPF引擎",
                "parentFullAlias": "FPF引擎",
                "children": []
            },
            {
                "id": 5,
                "alias": "大边",
                "fullAlias": "FPF引擎/大边",
                "parentId": 1,
                "parentAlias": "FPF引擎",
                "parentFullAlias": "FPF引擎",
                "children": [
                    {
                        "id": 8,
                        "alias": "洗消中心",
                        "fullAlias": "FPF引擎/大边/洗消中心",
                        "parentId": 5,
                        "parentAlias": "大边",
                        "parentFullAlias": "FPF引擎/大边",
                        "children": []
                    }
                ]
            }
        ]
    },
    {
        "id": 2,
        "alias": "IDP引擎",
        "fullAlias": "IDP引擎",
        "parentId": 0,
        "parentAlias": "",
        "parentFullAlias": "",
        "children": []
    }
]

3. 额外获取每个分组对应的父分组信息及分组的层级名称全称

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Group struct {
	Id              int      `json:"id"`
	Alias           string   `json:"alias"`
	FullAlias       string   `json:"fullAlias"`
	ParentId        int      `json:"parentId"`
	ParentAlias     string   `json:"parentAlias"`
	ParentFullAlias string   `json:"parentFullAlias"`
	Children        []*Group `json:"children"`
}

func getTreeRecursive(list []*Group, parentId int, parentAlias string) []*Group {
	res := make([]*Group, 0)
	for _, v := range list {
		if v.ParentId == parentId {
			if parentAlias != "" {
				v.FullAlias = parentAlias + "/" + v.Alias
			} else {
				v.FullAlias = v.Alias
			}
			v.ParentFullAlias = parentAlias
			fullList := strings.Split(v.FullAlias, "/")
			if len(fullList) >= 2 {
				v.ParentAlias = fullList[len(fullList)-2]
			} else {
				v.ParentAlias = parentAlias
			}
			v.Children = getTreeRecursive(list, v.Id, v.FullAlias)
			// 用 alias 排序，alias相等的元素保持原始顺序
			sort.SliceStable(v.Children, func(i, j int) bool {
				return v.Children[i].Alias < v.Children[j].Alias
			})
			res = append(res, v)
		}
	}
	// 用 alias 排序，alias相等的元素保持原始顺序
	sort.SliceStable(res, func(i, j int) bool {
		return res[i].Alias < res[j].Alias
	})
	return res
}

func getGroupMapper(group []*Group, re map[int]map[string]interface{}) map[int]map[string]interface{} {
	for _, v := range group {
		temp := map[string]interface{}{
			"alias":           v.Alias,
			"fullAlias":       v.FullAlias,
			"parentFullAlias": v.ParentFullAlias,
			"parentId":        v.ParentId,
			"parentAlias":     v.ParentAlias,
		}
		re[v.Id] = temp
		if len(v.Children) > 0 {
			getGroupMapper(v.Children, re)
		}
	}
	return re
}

// 检查指定父分组下是否有重名的子分组名称
func findChildAlias(alias string, parentId int, tree []*Group) bool {
	var res bool
	for _, v := range tree {
		if v.ParentId == parentId {
			if v.Alias == alias {
				res = true
				break
			} else {
				continue
			}
		}else{
			res = findChildAlias(alias, parentId, v.Children)
		}
	}
	return res
}

func main() {
	list := []*Group{
		{1, "FPF引擎", "", 0, "", "", []*Group{}},
		{2, "IDP引擎", "", 0, "", "", []*Group{}},
		{3, "桂妃山", "", 1, "", "", []*Group{}},
		{4, "南沙", "", 1, "", "", []*Group{}},
		{5, "大边", "", 1, "", "", []*Group{}},
		{6, "一场", "", 3, "", "", []*Group{}},
		{9, "一线", "", 6, "", "", []*Group{}},
		{7, "二场", "", 3, "", "", []*Group{}},
		{10, "一线", "", 7, "", "", []*Group{}},
		{8, "洗消中心", "", 5, "", "", []*Group{}},
	}
	res := getTreeRecursive(list, 0, "")

	bytes, _ := json.MarshalIndent(res, "", "    ")
	fmt.Printf("%s\n", bytes)

	cacheMap := getGroupMapper(res, map[int]map[string]interface{}{})
	bytes2, _ := json.MarshalIndent(cacheMap, "", "    ")
	fmt.Printf("%s\n", bytes2)
}
	fmt.Println(findChildAlias("FPF引擎",0, tree))  // true
	fmt.Println(findChildAlias("桂妃山",1, tree))  // true
	fmt.Println(findChildAlias("桂妃山1",1, tree))  // false
	fmt.Println(findChildAlias("一场",3, tree))  // true
	fmt.Println(findChildAlias("一场1",3, tree))  // false
	fmt.Println(findChildAlias("一线",6, tree))  // true
	fmt.Println(findChildAlias("一线1",6, tree))  // false

结果示例：

{
    "1": {
        "alias": "FPF引擎",
        "fullAlias": "FPF引擎",
        "parentAlias": "",
        "parentFullAlias": "",
        "parentId": 0
    },
    "10": {
        "alias": "一线",
        "fullAlias": "FPF引擎/桂妃山/二场/一线",
        "parentAlias": "二场",
        "parentFullAlias": "FPF引擎/桂妃山/二场",
        "parentId": 7
    },
    "2": {
        "alias": "IDP引擎",
        "fullAlias": "IDP引擎",
        "parentAlias": "",
        "parentFullAlias": "",
        "parentId": 0
    },
    "3": {
        "alias": "桂妃山",
        "fullAlias": "FPF引擎/桂妃山",
        "parentAlias": "FPF引擎",
        "parentFullAlias": "FPF引擎",
        "parentId": 1
    },
    "4": {
        "alias": "南沙",
        "fullAlias": "FPF引擎/南沙",
        "parentAlias": "FPF引擎",
        "parentFullAlias": "FPF引擎",
        "parentId": 1
    },
    "5": {
        "alias": "大边",
        "fullAlias": "FPF引擎/大边",
        "parentAlias": "FPF引擎",
        "parentFullAlias": "FPF引擎",
        "parentId": 1
    },
    "6": {
        "alias": "一场",
        "fullAlias": "FPF引擎/桂妃山/一场",
        "parentAlias": "桂妃山",
        "parentFullAlias": "FPF引擎/桂妃山",
        "parentId": 3
    },
    "7": {
        "alias": "二场",
        "fullAlias": "FPF引擎/桂妃山/二场",
        "parentAlias": "桂妃山",
        "parentFullAlias": "FPF引擎/桂妃山",
        "parentId": 3
    },
    "8": {
        "alias": "洗消中心",
        "fullAlias": "FPF引擎/大边/洗消中心",
        "parentAlias": "大边",
        "parentFullAlias": "FPF引擎/大边",
        "parentId": 5
    },
    "9": {
        "alias": "一线",
        "fullAlias": "FPF引擎/桂妃山/一场/一线",
        "parentAlias": "一场",
        "parentFullAlias": "FPF引擎/桂妃山/一场",
        "parentId": 6
    }
}
生有涯，知无涯
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tree命令详解
从头再来
11-26 1万+
命令：tree 命令说明：以树状格式列出目录的内容, 查看文件系统的结构 命令用法：tree [选项]… [文件]… 参数说明： 参数 参数说明 备注 -a 打印所有文件,包括隐藏文件、目录 -C 在文件和目录清单上加上色彩，便于区分文件类型 -d 仅列出目录名称，而非内容 -D 列出文件或目录更改时间 -L 目录树的最大显示深度 -p 打印结构同时打印文件权限 -l 跟随目录的符号链接，就像它们是目录一样。 避免了导致递归循环的链接 -f 打印每个
数据结构与算法 — 树的常见操作（Golang）
Mr_XiMu的博客
03-13 1696
树的常见操作 — 基于Golang语言的实现
[译] Golang 数据结构：树
weixin_33827731的博客
03-17 1211
原文地址：Golang Datastructures: Trees 原文作者：Ilija Eftimov 译文出自：掘金翻译计划 本文永久链接：github.com/xitu/gold-m… 译者：steinliber 校对者：Endone，LeoooY 在你编程生涯的大部分时间中你都不用接触到树这个数据结构，或者即使并不理解这个结构，你也可以轻易地避开使用它们（这就是我过去一直在做的事）...
数据结构与算法 — 树的常见操作（Golang）_golang 树结构(1)
最新发布
2401_84253894的博客
04-16 695
对于一个有n个节点的二叉树，按层级顺序编号，则所有节点的编号为从1到n。如果这个树的所有节点和同样深度的满二叉树的编号为从1到n的节点位置相同，则这个二叉树为完全二叉树。1、根节点先进入队列，然后根节点出队，在根节点出队后，若根节点有左孩子节点和右孩子结点，再将根节点的根节点有左孩子节点和右孩子结点放入队列。两个孩子节点的顺序是固定的，不能颠倒或混淆。换句话说：完全二叉树是比满二叉树少了一些叶子节点，且节点的位置完全与满二叉树节点的位置完全相同。2、重复循环1，知道左孩子节点和右孩子节点没有孩子节点位置。
go 无限极分类实现 返回树状排列数据 或 树状层级数据
leo_jk的博客
03-25 1845
根据从数据表中查询的多条数据得到树状数据。 数据表中根据 id 与 pid进行区分上下级 具体实现如下： 1.分类排列： // Menu 菜单 type Menu struct { Id int Pid int CateName string Desc string CreateTime int Children []Menu } // TreeList 菜单 type TreeList struct { Id int Pid int CateName string Desc
Go-gotree是一个垂直分布式框架gotree的目标是轻松开发分布式服务
08-14
特性 熔断 fork 热更新 rpc 通信(c50k) 定时器 SQL 慢查询监控 SQL 冗余监控 分层 强制垂直分库 基于 gseq 串行的全网日志 单元测试 督程 一致性哈希、主从、随机、均衡等负载方式 oop 设计模式
golang 生成二维码海报的实现代码
09-18
在本文中，我们将深入探讨如何使用Golang生成带有头像的二维码海报。Golang是一种高效、简洁的编程语言，特别适合处理图像处理和生成任务。以下是对提供的代码段的详细解释，以及关于如何生成二维码海报的相关知识。...
golang生成指定位数的随机数的方法
01-03
golang中产生随机数主要有两个包，分别是“math/rand”和“crypto/rand”。 “math/rand”的rand包实现了伪随机数生成器。 “crypto/rand”的rand包实现了用于加解密的更安全的随机数生成器。 3.生成指定位数随机数 ...
golang struct 自动生成工具
04-29
②修改生成工具代码（支持linux或mac或windows）如果生成出来的结构不是我们所需要的可以修改automatic.go文件 命令：go run automatic.go -d dbname -path ./models 二，生成单个多个表结构体： 命令（支持linux...
Golang 如何解析和生成json
09-16
Golang的标准库`encoding/json`提供了方便的API来解析和生成JSON。下面我们将详细讨论这两个过程。 1. **解析JSON** 解析JSON意味着将JSON字符串转换为Go语言中的数据结构。在示例代码中，我们首先定义了一个`...
Go 将无限分类扁平化数据转换为树状结构 ,可用于RBAC权限控制等
太阳上的雨天
05-23 129
Go 将无限分类扁平化数据转换为树状结构 ,可用于RBAC权限控制等。
Golang树形结构（实现菜单树）
MELF晓宇的博客
04-13 4098
Golang实现菜单树
golang 无限级树状结构
努力的夏目_41552670
07-05 4003
package main import( "encoding/json" "fmt" ) type Datanode struct { Id int `json:"id"` ParentId int `json:"pid"` Name string `json:"name"` Child []*Datanode `json:"chi...
go 学习3 tree
点滴生活
09-09 109
node.go package tree import "fmt" type Node struct { Value int Left, Right *Node } func (node Node) Print() { fmt.Print(node.Value, " ") } func (node *Node) SetValue(value int) { if node == nil { fmt.Println("Setting Value to nil " + "
go 递归tree关系_统一的树可视化形式描述语法 – GoTree
weixin_39946429的博客
12-29 617
树可视化是可视化领域长期以来的研究热点。近40年来，研究者利用不同的视觉映射方式发展了超过300种树可视化形式(https://treevis.net/)，并且广泛应用在日常生活中，例如展示电脑文件目录结构的缩进列表，反映股市中公司市值以及股价升降的Treemap。针对树可视化快速构建的问题，北京大学可视化与可视分析实验室袁晓如团队近期提出针对树可视化形式的描述性语法GoTree，支持用户从坐标系...
xgboost算法_一文带你读懂决策树 ——浅析决策树算法发展脉络
weixin_39734646的博客
11-18 515
0.前言作为一种非常著名的机器学习算法，相信大家对决策树都很熟悉，它不仅是初级面试必问的基础算法，更是仍然活跃于各大工业实践的利器。最近在家整理了一下决策树的相关资料，尝试用一篇短文梳理决策树的发展脉络，帮助大家建立各类决策树算法的基本认知，涉及到的理论与算法包括但不限于：决策树基本思想、ID3、C4.5、CART、adaboost、GBDT、RF、XGB、LGB等。本文作为科普实则门槛稍高，有些...
Golang返回树状结构数据（3层）
qq_42565292的博客
01-27 587
type ResultCarSku struct { Colour string `json:"colour"` // 车辆颜色 ColourChildren []*colourChildren `json:"children"` } type colourChildren struct { Type string `json:"type"` // 车辆类型 TypeChildren []typeChildren `json:"
golang别再使用递归将切片组成树形结构辣！戳辣！
Deng_Xian_Sheng的博客
05-20 172
递归的健壮性很低，容易导致无限递归。
golang数据结构篇之二叉树
清风
11-23 855
二叉树二叉树遍历递归遍历前序非递归中序非递归后续非递归DFS 深搜-从上到下DFS 深搜-从下向上（分治法）BFS 层次遍历 二叉树遍历 前序遍历：先访问根节点，再前序遍历左子树，再前序遍历右子树 中序遍历：先中序遍历左子树，再访问根节点，再中序遍历右子树 后序遍历：先后序遍历左子树，再后序遍历右子树，再访问根节点 以根访问顺序决定是什么遍历 左子树都是优先右子树 递归遍历 前中后序递归遍历换换位置即可 func preorderTraversal(root *TreeNode) { if root
golang mongodb分组查询
10-08
可以使用mgo库来在Golang中进行MongoDB的分组查询。下面是一个示例代码，演示了如何使用mgo库进行分组查询： ```go package main import ( "fmt" "log" "gopkg.in/mgo.v2" "gopkg.in/mgo.v2/bson" ) type ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值