tree转数组，两种方式
- 递归
- 循环（注意，循环不能使用迭代器方法，只能使用for循环）
js版本
/**
* 数组
*/
let arr = [{name: "李四", id: 2, pid: 0},// []
{name: "王五", id: 3, pid: 0}, // []
{name: "赵六", id: 4, pid: 3}, // []
{name: "吗六", id: 9, pid: 3}, // []
{name: "张三", id: 7, pid: 9}, // []
{name: "张五", id: 10, pid: 4}, // []
]
/**
* 数组转tree，递归模式
* @param arr
* @param pid
* @returns {*[]}
* @constructor
*/
function ArrayToTree(arr, pid = 0) {
// 判断 arr 是否是数组
if (!Array.isArray(arr) || !arr.length) return []
let newArr = []
arr.forEach(v => {
// 判断 pid 是否相同 相同就插入进去，切递归一下children，有值就继续递归，没值就返回[]
if (v.pid == pid) {
newArr.push({
...v, children: ArrayToTree(arr, v.id)
})
}
})
// 返回值
return newArr
}
let tree = ArrayToTree(arr)
/**
* tree转数组，循环模式，每次增加循环的变量
* 【注意：】只能使用for 循环，不能使用es6的迭代器
* @param tree
* @returns {{length}|*}
* @constructor
*/
function TreeToArrayFor(tree) {
if (!Array.isArray(tree) || !tree.length) throw new Error("请传入数组")
for (let i = 0; i < tree.length; i++) {
if (tree[i].children) {
// 每次children有值，就把值合并到原始数据tree上去，增加原始tree，for 循环 的长度也会增加 依次处理...
tree = tree.concat(tree[i].children)
}
}
return tree
}
/**
* tree转数组，递归模式
* @param tree
* @returns {*[]}
* @constructor
*/
function TreeToArray(tree) {
// 判断 tree 是否有值，无返回 []
if (!Array.isArray(tree) || !tree.length) return []
let res = []
tree.forEach(v => {
// tree的每个元素都 放入到 res里面
res.push(v)
if (v.children) {
// 有children 就把 children数据递归 返回 依次放到 res里面
res.push(...TreeToArray(v.children))
}
})
return res
}
go 版本
package main
import "fmt"
// List 结构体
type List struct {
Name string `json:"name"`
Id int `json:"id"`
Pid int `json:"pid"`
Children []List `json:"children"`
}
// 数据
var data = []List{
{Name: "李四", Id: 2, Pid: 0}, // []
{Name: "王五", Id: 3, Pid: 0}, // []
{Name: "赵六", Id: 4, Pid: 3}, // []
{Name: "吗六", Id: 9, Pid: 3}, // []
{Name: "张三", Id: 7, Pid: 9}, // []
{Name: "张五", Id: 10, Pid: 4}, // []
}
/**
* 递归模式，数组转tree
* @param arr 目标数组
* @param pid 第一级 目标id
* @returns {*[]} tree
* @constructor
*/
func ArrayToTrees(arr []List, pid int) []List {
var newArr []List
for _, v := range arr {
// 判断 pid 是否相同 相同就插入进去，切递归一下children，有值就继续递归，没值就返回[]
if v.Pid == pid {
v.Children = ArrayToTrees(arr, v.Id)
newArr = append(newArr, v)
}
}
return newArr
}
/**
* tree转数组，递归模式
* @param tree
* @returns {*[]}
* @constructor
*/
func ArrayToTree(tree []List) []List {
var res []List
for _, list := range tree {
// tree的每个元素都 放入到 res里面
res = append(res, list)
if list.Children != nil {
// 有children 就把 children数据递归 返回 依次放到 res里面
res = append(res, ArrayToTree(list.Children)...)
}
}
return res
}
/**
* tree转数组，循环模式，每次增加循环的变量
* 【注意：】只能使用for 循环，不能使用es6的迭代器
* @param tree
* @returns {{length}|*}
* @constructor
*/
func TreeToArrayFor(tree []List) []List {
for i := 0; i < len(tree); i++ {
if tree[i].Children != nil {
// 每次children有值，就把值合并到原始数据tree上去，增加原始tree，for 循环 的长度也会增加 依次处理...
tree = append(tree, tree[i].Children...)
}
}
return tree
}
func main() {
var tree = ArrayToTrees(data, 0)
var newTree = ArrayToTree(tree)
fmt.Println(1111, newTree, len(newTree))
}