有一个数组List，里面通过parentId确定树状图结构，树状图层级不固定，现在试用js找出没有子节点的数据

好的，针对您的问题，可以使用递归的方式来遍历这个树状结构，找到所有没有子节点的数据。具体步骤如下：

1. 遍历列表，找到parentId为null的节点，将这些节点作为根节点。
2. 对于每一个根节点，递归遍历其子节点，如果子节点列表为空，则说明这个节点是叶子节点，将其添加到结果集中。
3. 重复步骤2，直到所有的根节点都被遍历完毕。

下面是一个示例的JavaScript代码实现：

function findLeafNodes(list) {
  const result = [];
  for (const node of list) {
    const children = list.filter(item => item.parentId === node.id);
    if (children.length === 0) {
      result.push(node);
    } else {
      result.push(...findLeafNodes(children));
    }
  }
  return result;
}

其中，`list`是待处理的数组。这个函数会返回一个没有子节点的数据列表。

需要注意的是，这个代码中使用了递归调用的方式，如果树状结构比较深，可能会导致栈溢出等问题。可以通过优化算法或者增加递归深度限制等方式来解决这个问题。

相关问题

js数组对象通过id与parentid生存层级结构的序号数据xh 1 xh 1.1 xh1.1.1 xh1.1.2 xh1.2 xh1.2.1

在JavaScript中，可以通过使用数组对象来创建具有层级结构的序号数据。可以使用id和parentid属性来表示每个元素的唯一标识和父级元素的标识。下面是一个示例代码：

// 定义一个包含id和parentid属性的数组
var data = [
  { id: 1, parentid: null, name: 'xh' },
  { id: 2, parentid: 1, name: 'xh 1.1' },
  { id: 3, parentid: 2, name: 'xh 1.1.1' },
  { id: 4, parentid: 2, name: 'xh 1.1.2' },
  { id: 5, parentid: 1, name: 'xh 1.2' },
  { id: 6, parentid: 5, name: 'xh 1.2.1' }
];

// 定义一个函数来生成层级结构的序号数据
function generateHierarchy(data, parentid, prefix) {
  var result = [];
  
  for (var i = 0; i < data.length; i++) {
    if (data[i].parentid === parentid) {
      var item = {
        id: data[i].id,
        name: prefix + data[i].name
      };
      
      var children = generateHierarchy(data, data[i].id, prefix + ' ');
      if (children.length > 0) {
        item.children = children;
      }
      
      result.push(item);
    }
  }
  
  return result;
}

// 调用函数生成层级结构的序号数据
var hierarchyData = generateHierarchy(data, null, '');

console.log(hierarchyData);

上述代码中，我们定义了一个包含id、parentid和name属性的数组data。然后，通过调用generateHierarchy函数来生成层级结构的序号数据。该函数会递归遍历数组，根据parentid属性来确定每个元素的父级元素，并使用prefix参数来表示层级关系。最后，将生成的层级结构数据存储在hierarchyData变量中，并打印输出。

将以上数组用js方法处理为树状结构数组

假设给出的数组如下：

var arr = [
  { id: 1, name: 'Node 1', parent: 0 },
  { id: 2, name: 'Node 2', parent: 1 },
  { id: 3, name: 'Node 3', parent: 1 },
  { id: 4, name: 'Node 4', parent: 3 },
  { id: 5, name: 'Node 5', parent: 4 },
  { id: 6, name: 'Node 6', parent: 3 },
  { id: 7, name: 'Node 7', parent: 0 },
  { id: 8, name: 'Node 8', parent: 7 },
  { id: 9, name: 'Node 9', parent: 8 },
  { id: 10, name: 'Node 10', parent: 9 }
];

可以通过以下方式将其处理为树状结构数组：

function buildTree(arr, parentId) {
  var tree = [];
  for (var i = 0; i < arr.length; i++) {
    if (arr[i].parent === parentId) {
      var node = {
        id: arr[i].id,
        name: arr[i].name,
        children: buildTree(arr, arr[i].id)
      };
      tree.push(node);
    }
  }
  return tree;
}

var tree = buildTree(arr, 0);
console.log(JSON.stringify(tree));

这里定义了一个 `buildTree` 函数，参数 `arr` 为原始数组，`parentId` 为当前节点的父节点 ID。函数首先创建一个空数组 `tree`，然后遍历原始数组，找到所有父节点 ID 为 `parentId` 的节点，将其添加到 `tree` 中，并递归调用 `buildTree` 函数，将其子节点添加到当前节点的 `children` 属性中。最后返回 `tree` 数组，即为树状结构数组。