ฉันมีพวงของวัตถุในโครงสร้างแบน วัตถุเหล่านี้มีIDและParentIDคุณสมบัติเพื่อให้สามารถจัดเรียงในต้นไม้ พวกเขาไม่อยู่ในลำดับที่เฉพาะเจาะจง แต่ละParentIDคุณสมบัติไม่จำเป็นต้องตรงกับIDในโครงสร้าง ดังนั้นต้นไม้ของพวกเขาอาจจะโผล่ออกมาจากวัตถุเหล่านี้

คุณจะประมวลผลวัตถุเหล่านี้เพื่อสร้างต้นไม้ที่ได้อย่างไร

ฉันไม่ได้อยู่ไกลจากการแก้ปัญหา แต่ฉันแน่ใจว่ามันอยู่ไกลจากที่ดีที่สุด ...

ฉันต้องสร้างต้นไม้เหล่านี้เพื่อแทรกข้อมูลลงในฐานข้อมูลตามลำดับที่ถูกต้อง

ไม่มีการอ้างอิงแบบวงกลม โหนดเป็น RootNode เมื่อ ParentID == null หรือเมื่อไม่สามารถพบ ParentID ในวัตถุอื่น ๆ ได้

เก็บ ID ของวัตถุในการแมปตารางแฮชกับวัตถุเฉพาะ ระบุผ่านวัตถุทั้งหมดและค้นหาพาเรนต์ถ้ามีอยู่และอัพเดตตัวชี้พาเรนต์ตามลำดับ

class MyObject
{ // The actual object
    public int ParentID { get; set; }
    public int ID { get; set; }
}

class Node
{
    public List<Node> Children = new List<Node>();
    public Node Parent { get; set; }
    public MyObject AssociatedObject { get; set; }
}

IEnumerable<Node> BuildTreeAndGetRoots(List<MyObject> actualObjects)
{
    Dictionary<int, Node> lookup = new Dictionary<int, Node>();
    actualObjects.ForEach(x => lookup.Add(x.ID, new Node { AssociatedObject = x }));
    foreach (var item in lookup.Values) {
        Node proposedParent;
        if (lookup.TryGetValue(item.AssociatedObject.ParentID, out proposedParent)) {
            item.Parent = proposedParent;
            proposedParent.Children.Add(item);
        }
    }
    return lookup.Values.Where(x => x.Parent == null);
}

ตามคำตอบของ Mehrdad Afshari และความคิดเห็นของ Andrew Hanlon สำหรับการเร่งความเร็วนี่คือสิ่งที่ฉันใช้

ความแตกต่างที่สำคัญกับงานดั้งเดิม: โหนดรูทมี ID == parentID

class MyObject
{   // The actual object
    public int ParentID { get; set; }
    public int ID { get; set; }
}

class Node
{
    public List<Node> Children = new List<Node>();
    public Node Parent { get; set; }
    public MyObject Source { get; set; }
}

List<Node> BuildTreeAndGetRoots(List<MyObject> actualObjects)
{
    var lookup = new Dictionary<int, Node>();
    var rootNodes = new List<Node>();

    foreach (var item in actualObjects)
    {
        // add us to lookup
        Node ourNode;
        if (lookup.TryGetValue(item.ID, out ourNode))
        {   // was already found as a parent - register the actual object
            ourNode.Source = item;
        }
        else
        {
            ourNode = new Node() { Source = item };
            lookup.Add(item.ID, ourNode);
        }

        // hook into parent
        if (item.ParentID == item.ID)
        {   // is a root node
            rootNodes.Add(ourNode);
        }
        else
        {   // is a child row - so we have a parent
            Node parentNode;
            if (!lookup.TryGetValue(item.ParentID, out parentNode))
            {   // unknown parent, construct preliminary parent
                parentNode = new Node();
                lookup.Add(item.ParentID, parentNode);
            }
            parentNode.Children.Add(ourNode);
            ourNode.Parent = parentNode;
        }
    }

    return rootNodes;
}

นี่คืออัลกอริทึม JavaScript ง่ายๆในการแยกตารางแบนเป็นโครงสร้างต้นไม้แม่ / ลูกที่ทำงานในเวลา N:

var table = [
    {parent_id: 0, id: 1, children: []},
    {parent_id: 0, id: 2, children: []},
    {parent_id: 0, id: 3, children: []},
    {parent_id: 1, id: 4, children: []},
    {parent_id: 1, id: 5, children: []},
    {parent_id: 1, id: 6, children: []},
    {parent_id: 2, id: 7, children: []},
    {parent_id: 7, id: 8, children: []},
    {parent_id: 8, id: 9, children: []},
    {parent_id: 3, id: 10, children: []}
];

var root = {id:0, parent_id: null, children: []};
var node_list = { 0 : root};

for (var i = 0; i < table.length; i++) {
    node_list[table[i].id] = table[i];
    node_list[table[i].parent_id].children.push(node_list[table[i].id]);
}

console.log(root);

โซลูชั่น Python

def subtree(node, relationships):
    return {
        v: subtree(v, relationships) 
        for v in [x[0] for x in relationships if x[1] == node]
    }

ตัวอย่างเช่น:

# (child, parent) pairs where -1 means no parent    
flat_tree = [
     (1, -1),
     (4, 1),
     (10, 4),
     (11, 4),
     (16, 11),
     (17, 11),
     (24, 17),
     (25, 17),
     (5, 1),
     (8, 5),
     (9, 5),
     (7, 9),
     (12, 9),
     (22, 12),
     (23, 12),
     (2, 23),
     (26, 23),
     (27, 23),
     (20, 9),
     (21, 9)
    ]

subtree(-1, flat_tree)

ผลิต:

{
    "1": {
        "4": {
            "10": {}, 
            "11": {
                "16": {}, 
                "17": {
                    "24": {}, 
                    "25": {}
                }
            }
        }, 
        "5": {
            "8": {}, 
            "9": {
                "20": {}, 
                "12": {
                    "22": {}, 
                    "23": {
                        "2": {}, 
                        "27": {}, 
                        "26": {}
                    }
                }, 
                "21": {}, 
                "7": {}
            }
        }
    }
}

เวอร์ชัน JS ที่ส่งคืนหนึ่งรูทหรืออาร์เรย์ของรูทซึ่งแต่ละอันจะมีคุณสมบัติอาร์เรย์เด็กที่มีลูกที่เกี่ยวข้อง ไม่ได้ขึ้นอยู่กับอินพุตที่ได้รับคำสั่งขนาดกะทัดรัดพอสมควรและไม่ใช้การเรียกซ้ำ สนุก!

// creates a tree from a flat set of hierarchically related data
var MiracleGrow = function(treeData, key, parentKey)
{
    var keys = [];
    treeData.map(function(x){
        x.Children = [];
        keys.push(x[key]);
    });
    var roots = treeData.filter(function(x){return keys.indexOf(x[parentKey])==-1});
    var nodes = [];
    roots.map(function(x){nodes.push(x)});
    while(nodes.length > 0)
    {

        var node = nodes.pop();
        var children =  treeData.filter(function(x){return x[parentKey] == node[key]});
        children.map(function(x){
            node.Children.push(x);
            nodes.push(x)
        });
    }
    if (roots.length==1) return roots[0];
    return roots;
}


// demo/test data
var treeData = [

    {id:9, name:'Led Zep', parent:null},
    {id:10, name:'Jimmy', parent:9},
    {id:11, name:'Robert', parent:9},
    {id:12, name:'John', parent:9},

    {id:8, name:'Elec Gtr Strings', parent:5},
    {id:1, name:'Rush', parent:null},
    {id:2, name:'Alex', parent:1},
    {id:3, name:'Geddy', parent:1},
    {id:4, name:'Neil', parent:1},
    {id:5, name:'Gibson Les Paul', parent:2},
    {id:6, name:'Pearl Kit', parent:4},
    {id:7, name:'Rickenbacker', parent:3},

    {id:100, name:'Santa', parent:99},
    {id:101, name:'Elf', parent:100},

];
var root = MiracleGrow(treeData, "id", "parent")
console.log(root)

พบเวอร์ชัน JavaScript ที่ยอดเยี่ยมที่นี่: http://oskarhane.com/create-a-nested-array-recursively-in-javascript/

สมมติว่าคุณมีอาร์เรย์ดังนี้:

const models = [
    {id: 1, title: 'hello', parent: 0},
    {id: 2, title: 'hello', parent: 0},
    {id: 3, title: 'hello', parent: 1},
    {id: 4, title: 'hello', parent: 3},
    {id: 5, title: 'hello', parent: 4},
    {id: 6, title: 'hello', parent: 4},
    {id: 7, title: 'hello', parent: 3},
    {id: 8, title: 'hello', parent: 2}
];

และคุณต้องการให้วัตถุซ้อนกันเช่นนี้

const nestedStructure = [
    {
        id: 1, title: 'hello', parent: 0, children: [
            {
                id: 3, title: 'hello', parent: 1, children: [
                    {
                        id: 4, title: 'hello', parent: 3, children: [
                            {id: 5, title: 'hello', parent: 4},
                            {id: 6, title: 'hello', parent: 4}
                        ]
                    },
                    {id: 7, title: 'hello', parent: 3}
                ]
            }
        ]
    },
    {
        id: 2, title: 'hello', parent: 0, children: [
            {id: 8, title: 'hello', parent: 2}
        ]
    }
];

นี่คือฟังก์ชั่นวนซ้ำที่ทำให้เกิดขึ้น

function getNestedChildren(models, parentId) {
    const nestedTreeStructure = [];
    const length = models.length;

    for (let i = 0; i < length; i++) { // for-loop for perf reasons, huge difference in ie11
        const model = models[i];

        if (model.parent == parentId) {
            const children = getNestedChildren(models, model.id);

            if (children.length > 0) {
                model.children = children;
            }

            nestedTreeStructure.push(model);
        }
    }

    return nestedTreeStructure;
}

Usuage:

const models = [
    {id: 1, title: 'hello', parent: 0},
    {id: 2, title: 'hello', parent: 0},
    {id: 3, title: 'hello', parent: 1},
    {id: 4, title: 'hello', parent: 3},
    {id: 5, title: 'hello', parent: 4},
    {id: 6, title: 'hello', parent: 4},
    {id: 7, title: 'hello', parent: 3},
    {id: 8, title: 'hello', parent: 2}
];
const nestedStructure = getNestedChildren(models, 0);

สำหรับผู้ที่สนใจโซลูชันของ Eugene รุ่น C # โปรดทราบว่าnode_listถูกเข้าถึงเป็นแผนที่ดังนั้นให้ใช้ Dictionary แทน

เก็บไว้ในใจว่าการแก้ปัญหานี้จะทำงานเฉพาะในกรณีที่โต๊ะเรียงตามparent_id

var table = new[]
{
    new Node { parent_id = 0, id = 1 },
    new Node { parent_id = 0, id = 2 },
    new Node { parent_id = 0, id = 3 },
    new Node { parent_id = 1, id = 4 },
    new Node { parent_id = 1, id = 5 },
    new Node { parent_id = 1, id = 6 },
    new Node { parent_id = 2, id = 7 },
    new Node { parent_id = 7, id = 8 },
    new Node { parent_id = 8, id = 9 },
    new Node { parent_id = 3, id = 10 },
};

var root = new Node { id = 0 };
var node_list = new Dictionary<int, Node>{
    { 0, root }
};

foreach (var item in table)
{
    node_list.Add(item.id, item);
    node_list[item.parent_id].children.Add(node_list[item.id]);
}

โหนดถูกกำหนดดังนี้

class Node
{
    public int id { get; set; }
    public int parent_id { get; set; }
    public List<Node> children = new List<Node>();
}

ฉันเขียนคำตอบทั่วไปใน C # โดยอิงตาม @Mehrdad Afshari คำตอบ:

void Example(List<MyObject> actualObjects)
{
  List<TreeNode<MyObject>> treeRoots = actualObjects.BuildTree(obj => obj.ID, obj => obj.ParentID, -1);
}

public class TreeNode<T>
{
  public TreeNode(T value)
  {
    Value = value;
    Children = new List<TreeNode<T>>();
  }

  public T Value { get; private set; }
  public List<TreeNode<T>> Children { get; private set; }
}

public static class TreeExtensions
{
  public static List<TreeNode<TValue>> BuildTree<TKey, TValue>(this IEnumerable<TValue> objects, Func<TValue, TKey> keySelector, Func<TValue, TKey> parentKeySelector, TKey defaultKey = default(TKey))
  {
    var roots = new List<TreeNode<TValue>>();
    var allNodes = objects.Select(overrideValue => new TreeNode<TValue>(overrideValue)).ToArray();
    var nodesByRowId = allNodes.ToDictionary(node => keySelector(node.Value));

    foreach (var currentNode in allNodes)
    {
      TKey parentKey = parentKeySelector(currentNode.Value);
      if (Equals(parentKey, defaultKey))
      {
        roots.Add(currentNode);
      }
      else
      {
        nodesByRowId[parentKey].Children.Add(currentNode);
      }
    }

    return roots;
  }
}

นี่คือโซลูชัน java ของคำตอบโดย Mehrdad Afshari

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class Tree {

    Iterator<Node> buildTreeAndGetRoots(List<MyObject> actualObjects) {
        Map<Integer, Node> lookup = new HashMap<>();
        actualObjects.forEach(x -> lookup.put(x.id, new Node(x)));
        //foreach (var item in lookup.Values)
        lookup.values().forEach(item ->
                {
                    Node proposedParent;
                    if (lookup.containsKey(item.associatedObject.parentId)) {
                        proposedParent = lookup.get(item.associatedObject.parentId);
                        item.parent = proposedParent;
                        proposedParent.children.add(item);
                    }
                }
        );
        //return lookup.values.Where(x =>x.Parent ==null);
        return lookup.values().stream().filter(x -> x.parent == null).iterator();
    }

}

class MyObject { // The actual object
    public int parentId;
    public int id;
}

class Node {
    public List<Node> children = new ArrayList<Node>();
    public Node parent;
    public MyObject associatedObject;

    public Node(MyObject associatedObject) {
        this.associatedObject = associatedObject;
    }
}

คลุมเครือเหมือนคำถามที่ฉันคิดว่าฉันอาจจะสร้างแผนที่จาก ID ไปยังวัตถุจริง ใน pseudo-java (ฉันไม่ได้ตรวจสอบว่ามันทำงาน / คอมไพล์) มันอาจจะเป็นสิ่งที่ชอบ:

Map<ID, FlatObject> flatObjectMap = new HashMap<ID, FlatObject>();

for (FlatObject object: flatStructure) {
    flatObjectMap.put(object.ID, object);
}

และค้นหาผู้ปกครองแต่ละคน:

private FlatObject getParent(FlatObject object) {
    getRealObject(object.ParentID);
}

private FlatObject getRealObject(ID objectID) {
    flatObjectMap.get(objectID);
}

โดยการนำกลับมาใช้ใหม่getRealObject(ID)และการทำแผนที่จากวัตถุไปยังชุดวัตถุ (หรือรหัสของพวกเขา) คุณจะได้รับแผนที่แม่ลูก> เช่นกัน

ฉันสามารถทำได้ใน 4 บรรทัดของรหัสและเวลา O (n log n) สมมติว่าพจนานุกรมเป็นเหมือน TreeMap

dict := Dictionary new.
ary do: [:each | dict at: each id put: each].
ary do: [:each | (dict at: each parent) addChild: each].
root := dict at: nil.

แก้ไข : ตกลงและตอนนี้ฉันอ่านแล้วว่า parentID บางตัวเป็นของปลอมดังนั้นลืมสิ่งข้างต้นและทำสิ่งนี้:

dict := Dictionary new.
dict at: nil put: OrderedCollection new.
ary do: [:each | dict at: each id put: each].
ary do: [:each | 
    (dict at: each parent ifAbsent: [dict at: nil]) 
          add: each].
roots := dict at: nil.

คำตอบส่วนใหญ่คิดว่าคุณต้องการทำสิ่งนี้นอกฐานข้อมูล หากทรีของคุณค่อนข้างคงที่ในธรรมชาติและคุณเพียงต้องการแมปทรีเข้ากับฐานข้อมูลคุณอาจต้องการพิจารณาใช้ชุดการแทนค่าแบบซ้อนในด้านฐานข้อมูล ตรวจสอบหนังสือโดย Joe Celko (หรือที่นี่ เพื่อดูภาพรวมโดย Celko)

หากเชื่อมโยงกับ Oracle dbs ให้ตรวจสอบ CONNECT BY ของพวกเขาเพื่อดูวิธี SQL แบบตรง

ด้วยวิธีใดวิธีหนึ่งคุณสามารถข้ามการแมปทรีก่อนที่จะโหลดข้อมูลในฐานข้อมูล แค่คิดว่าฉันจะเสนอสิ่งนี้เป็นทางเลือกมันอาจไม่เหมาะสมอย่างยิ่งสำหรับความต้องการเฉพาะของคุณ ส่วน "การสั่งซื้อที่เหมาะสม" ทั้งหมดของคำถามเดิมค่อนข้างบอกเป็นนัยว่าคุณต้องการคำสั่งที่จะ "ถูกต้อง" ในฐานข้อมูลด้วยเหตุผลบางอย่าง? นี่อาจผลักฉันไปยังการจัดการต้นไม้ที่นั่นเช่นกัน

มันไม่เหมือนกับสิ่งที่ผู้ถามหา แต่ฉันมีปัญหาในการคาดเดาคำตอบที่คลุมเครือไว้ที่นี่และฉันก็ยังคิดว่าคำตอบนี้เหมาะกับชื่อ

คำตอบของฉันคือการทำแผนที่โครงสร้างแบนกับต้นไม้โดยตรงบนวัตถุที่คุณมีอยู่ParentIDในแต่ละวัตถุ ParentIDเป็นnullหรือ0ถ้าเป็นรูต ตรงข้ามกับผู้ถามฉันถือว่าทุกParentIDจุดมีผลต่อสิ่งอื่นในรายการ:

var rootNodes = new List<DTIntranetMenuItem>();
var dictIntranetMenuItems = new Dictionary<long, DTIntranetMenuItem>();

//Convert the flat database items to the DTO's,
//that has a list of children instead of a ParentID.
foreach (var efIntranetMenuItem in flatIntranetMenuItems) //List<tblIntranetMenuItem>
{
    //Automapper (nuget)
    DTIntranetMenuItem intranetMenuItem =
                                   Mapper.Map<DTIntranetMenuItem>(efIntranetMenuItem);
    intranetMenuItem.Children = new List<DTIntranetMenuItem>();
    dictIntranetMenuItems.Add(efIntranetMenuItem.ID, intranetMenuItem);
}

foreach (var efIntranetMenuItem in flatIntranetMenuItems)
{
    //Getting the equivalent object of the converted ones
    DTIntranetMenuItem intranetMenuItem = dictIntranetMenuItems[efIntranetMenuItem.ID];

    if (efIntranetMenuItem.ParentID == null || efIntranetMenuItem.ParentID <= 0)
    {
        rootNodes.Add(intranetMenuItem);
    }
    else
    {
        var parent = dictIntranetMenuItems[efIntranetMenuItem.ParentID.Value];
        parent.Children.Add(intranetMenuItem);
        //intranetMenuItem.Parent = parent;
    }
}
return rootNodes;

นี่คือการดำเนินการทับทิม:

มันจะแคตตาล็อกตามชื่อคุณลักษณะหรือผลของการโทรวิธี

CatalogGenerator = ->(depth) do
  if depth != 0
    ->(hash, key) do
      hash[key] = Hash.new(&CatalogGenerator[depth - 1])
    end
  else
    ->(hash, key) do
      hash[key] = []
    end
  end
end

def catalog(collection, root_name: :root, by:)
  method_names = [*by]
  log = Hash.new(&CatalogGenerator[method_names.length])
  tree = collection.each_with_object(log) do |item, catalog|
    path = method_names.map { |method_name| item.public_send(method_name)}.unshift(root_name.to_sym)
  catalog.dig(*path) << item
  end
  tree.with_indifferent_access
end

 students = [#<Student:0x007f891d0b4818 id: 33999, status: "on_hold", tenant_id: 95>,
 #<Student:0x007f891d0b4570 id: 7635, status: "on_hold", tenant_id: 6>,
 #<Student:0x007f891d0b42c8 id: 37220, status: "on_hold", tenant_id: 6>,
 #<Student:0x007f891d0b4020 id: 3444, status: "ready_for_match", tenant_id: 15>,
 #<Student:0x007f8931d5ab58 id: 25166, status: "in_partnership", tenant_id: 10>]

catalog students, by: [:tenant_id, :status]

# this would out put the following
{"root"=>
  {95=>
    {"on_hold"=>
      [#<Student:0x007f891d0b4818
        id: 33999,
        status: "on_hold",
        tenant_id: 95>]},
   6=>
    {"on_hold"=>
      [#<Student:0x007f891d0b4570 id: 7635, status: "on_hold", tenant_id: 6>,
       #<Student:0x007f891d0b42c8
        id: 37220,
        status: "on_hold",
        tenant_id: 6>]},
   15=>
    {"ready_for_match"=>
      [#<Student:0x007f891d0b4020
        id: 3444,
        status: "ready_for_match",
        tenant_id: 15>]},
   10=>
    {"in_partnership"=>
      [#<Student:0x007f8931d5ab58
        id: 25166,
        status: "in_partnership",
        tenant_id: 10>]}}}

คำตอบที่ยอมรับนั้นดูซับซ้อนเกินไปสำหรับฉันดังนั้นฉันจึงเพิ่มรุ่น Ruby และ NodeJS

สมมติว่ารายการโหนดแบบแบนมีโครงสร้างต่อไปนี้:

nodes = [
  { id: 7, parent_id: 1 },
  ...
] # ruby

nodes = [
  { id: 7, parentId: 1 },
  ...
] # nodeJS

ฟังก์ชั่นที่จะเปลี่ยนโครงสร้างรายการแบนด้านบนให้เป็นต้นไม้มีลักษณะดังต่อไปนี้

สำหรับทับทิม:

def to_tree(nodes)

  nodes.each do |node|

    parent = nodes.find { |another| another[:id] == node[:parent_id] }
    next unless parent

    node[:parent] = parent
    parent[:children] ||= []
    parent[:children] << node

  end

  nodes.select { |node| node[:parent].nil? }

end

สำหรับ NodeJS:

const toTree = (nodes) => {

  nodes.forEach((node) => {

    const parent = nodes.find((another) => another.id == node.parentId)
    if(parent == null) return;

    node.parent = parent;
    parent.children = parent.children || [];
    parent.children = parent.children.concat(node);

  });

  return nodes.filter((node) => node.parent == null)

};

วิธีหนึ่งที่สวยงามในการทำเช่นนี้คือการแสดงรายการในรายการเป็นสตริงที่ถือรายการผู้ปกครองที่คั่นด้วยจุดและสุดท้ายเป็นค่า:

server.port=90
server.hostname=localhost
client.serverport=90
client.database.port=1234
client.database.host=localhost

เมื่อรวมต้นไม้คุณจะพบกับสิ่งต่อไปนี้:

server:
  port: 90
  hostname: localhost
client:
  serverport=1234
  database:
    port: 1234
    host: localhost

ฉันมีไลบรารีการกำหนดค่าที่ใช้การตั้งค่าการแทนที่ (ต้นไม้) จากอาร์กิวเมนต์บรรทัดคำสั่ง (รายการ) ขั้นตอนวิธีการที่จะเพิ่มรายการเดียวในรายการที่จะเป็นต้นไม้ที่อยู่ที่นี่

คุณติดขัดโดยใช้คุณลักษณะเฉพาะเหล่านั้นหรือไม่ ถ้าไม่เช่นนั้นอาจเป็นการดีที่จะสร้างอาร์เรย์ของโหนดลูกซึ่งคุณสามารถวนรอบวัตถุทั้งหมดเหล่านี้หนึ่งครั้งเพื่อสร้างคุณลักษณะดังกล่าว จากจุดนั้นให้เลือกโหนดที่มีลูก ๆ แต่ไม่มีพ่อแม่และสร้างต้นไม้ของคุณซ้ำ ๆ จากบนลงล่าง

รุ่นจาวา

// node
@Data
public class Node {
    private Long id;
    private Long parentId;
    private String name;
    private List<Node> children = new ArrayList<>();
}

// flat list to tree
List<Node> nodes = new ArrayList();// load nodes from db or network
Map<Long, Node> nodeMap = new HashMap();
nodes.forEach(node -> {
  if (!nodeMap.containsKey(node.getId)) nodeMap.put(node.getId, node);
  if (nodeMap.containsKey(node.getParentId)) {
    Node parent = nodeMap.get(node.getParentId);
    node.setParentId(parent.getId());
    parent.getChildren().add(node);
  }
});

// tree node
List<Node> treeNode = nodeMap .values().stream().filter(n -> n.getParentId() == null).collect(Collectors.toList());