如果需要在特定的节点下插入 children 节点，并且要保证后续的子节点也相应变化，可以通过以下方式来实现：

1. 首先，我们需要修改 Node 类，添加一个新的字段 List<Node> Children 来表示该节点的所有子节点。

public class Node
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int ParentId { get; set; }

    public List<Node> Children { get; set; }

    public Node()
    {
        Children = new List<Node>();
    }
}

1. 然后，在生成嵌套结构数据时，需要判断是否有特殊情况需要插入 children 节点。如果有，则在递归生成子节点数据时，在目标节点的 Children 列表中添加新的子节点。

private static void GenerateData(Node[] nodes, Node currentNode, Data currentData)
{
    // 递归处理当前节点的所有子节点
    foreach (var childNode in currentNode.Children)
    {
        var childData = new Data();
        childData.label.format.Add(childNode.Name);
        
        // 如果当前是目标节点，则在其 Children 中插入新的子节点
        if (childNode.Id == targetNodeId)
        {
            var newNode = new Node() { Id = newNodeId, Name = "New Child", ParentId = targetNodeId };
            childNode.Children.Insert(insertIndex, newNode);
            newNodeId++;
        }
        
        currentData.children.Add(childData);
        
        // 递归处理当前子节点的所有子节点
        GenerateData(nodes, childNode, childData);
    }
}

完整的代码如下：

using System;
using System.Collections.Generic;

public class Node
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int ParentId { get; set; }

    public List<Node> Children { get; set; }

    public Node()
    {
        Children = new List<Node>();
    }
}

public class Data
{
    public Label label { get; set; }
    public List<Data> children { get; set; }

    public Data()
    {
        label = new Label();
        children = new List<Data>();
    }
}

public class Label
{
    public List<string> format { get; set; }

    public Label()
    {
        format = new List<string>();
    }
}

public static class Program
{
    private static int newNodeId = 1000;
    
	private static int targetNodeId = 2;
	private static int insertIndex = 1;

	private static void Main()
	{
	    // 构造示例数据
	    var nodes = new[]
	    {
	        new Node() { Id = 1, Name = "aa", ParentId = 0 },
	        new Node() { Id = 2, Name = "bb", ParentId = 1 },
	        new Node() { Id = 3, Name = "cc", ParentId = 2 },
	        new Node() { Id = 4, Name = "dd", ParentId = 2 },
	        new Node() { Id = 5, Name = "ee", ParentId=1 },
	        new Node() { Id=6,Name="ff",ParentId=5},
	        new Node() { Id=7,Name="gg",ParentId=5},
	    };
	    
	    // 将所有节点添加到其父节点的 Children 列表中
	    foreach (var node in nodes)
	    {
	        if (node.ParentId != 0)
	        {
	            var parentNode = nodes.FirstOrDefault(n => n.Id == node.ParentId);
	            parentNode.Children.Add(node);
	        }
	    }
	    
	    var rootDataList = new List<Data>();
	    
	    // 递归处理所有根节点
	    foreach (var rootNode in nodes.Where(n => n.ParentId == 0))
	    {
	        var rootData = new Data();
	        rootData.label.format.Add(rootNode.Name);
	        
	        GenerateData(nodes, rootNode, rootData);
	        
	        rootDataList.Add(rootData);
	    }

        Console.WriteLine(Newtonsoft.Json.JsonConvert.SerializeObject(rootDataList));
	}

	private static void GenerateData(Node[] nodes, Node currentNode, Data currentData)
	{
	    // 递归处理当前节点的所有子节点
	    foreach (var childNode in currentNode.Children)
	    {
	        var childData = new Data();
	        childData.label.format.Add(childNode.Name);
	        
	        // 如果当前是目标节点，则在其 Children 中插入新的子节点
	        if (childNode.Id == targetNodeId)
	        {
	            var newNode = new Node() { Id = newNodeId, Name = "New Child", ParentId = targetNodeId };
	            childNode.Children.Insert(insertIndex, newNode);
	            newNodeId++;
	        }
	        
	        currentData.children.Add(childData);
	        
            // 递归处理当前子节点的所有子节点
            GenerateData(nodes, childNode, childData);        
        }
    }
}

其中，targetNodeId 表示要在哪个目标节点下插入 children 节点，insertIndex 表示要在目标节点的 Children 列表中的哪个位置插入新的子节点。这两个参数可以根据实际情况进行修改。