Javascript 递归排序数组

我有这样一个数组：

var a = [
  {id: 1, pid: 0},
  {id: 2, pid: 1},
  {id: 3, pid: 1},
  {id: 4, pid: 2},
  {id: 5, pid: 2},
  {id: 6, pid: 3},
  {id: 7, pid: 3}
]

var map = {
  "1": {id: 1, pid: 0},
  "2": {id: 2, pid: 1},
  "3": {id: 3, pid: 1},
  "4": {id: 4, pid: 2},
  "5": {id: 5, pid: 2},
  "6": {id: 6, pid: 3},
  "7": {id: 7, pid: 3}
}

和这样的贴图对象：

var a = [
  {id: 1, pid: 0},
  {id: 2, pid: 1},
  {id: 3, pid: 1},
  {id: 4, pid: 2},
  {id: 5, pid: 2},
  {id: 6, pid: 3},
  {id: 7, pid: 3}
]

var map = {
  "1": {id: 1, pid: 0},
  "2": {id: 2, pid: 1},
  "3": {id: 3, pid: 1},
  "4": {id: 4, pid: 2},
  "5": {id: 5, pid: 2},
  "6": {id: 6, pid: 3},
  "7": {id: 7, pid: 3}
}

我正在尝试对其进行排序以匹配此模式：

var result = [
  {"id": 1, "pid": 0},
    {"id": 2, "pid": 1},
      {"id": 4, "pid": 2},
      {"id": 5, "pid": 2},
    {"id": 3, "pid": 1},
      {"id": 6, "pid": 3},
      {"id": 7, "pid": 3}
]

如您所见，这是一个嵌套的树结构。我想在匹配的

id

下得到

pid

，在顶部得到最低的

id

有没有办法只使用一次迭代就对这样的数组进行排序如果不是的话，最好能看到一个关于如何绕过它的例子

到目前为止，我只有：

a.sort(function(q, w) { return q.pid - w.pid; });

---

我正在考虑使用我的地图，使用

pid

->

id

找到我的父母，然后按该键排序。在我的对象上也可以存储额外的属性。

假设有一个pid为0的根：

var children = {}
var root = null;
a.forEach(function(e) {
    children[e.id] = [];
});

a.forEach(function(e) {
    if (e.pid === 0) {
        root = e;
    }
    else {
        children[e.pid].push(e);
    }
});

var sorted = [];

function preorder(e) {
    sorted.push(e);
    if (children.hasOwnProperty(e.id)) {
        children[e.id].forEach(preorder);
    }
}
preorder(root);

结果:

[
  {"id":1,"pid":0},
    {"id":2,"pid":1},
    {"id":4,"pid":2},
      {"id":5,"pid":2},
    {"id":3,"pid":1},
      {"id":6,"pid":3},
      {"id":7,"pid":3}
]

---

假设存在pid为0的单个根：

var children = {}
var root = null;
a.forEach(function(e) {
    children[e.id] = [];
});

a.forEach(function(e) {
    if (e.pid === 0) {
        root = e;
    }
    else {
        children[e.pid].push(e);
    }
});

var sorted = [];

function preorder(e) {
    sorted.push(e);
    if (children.hasOwnProperty(e.id)) {
        children[e.id].forEach(preorder);
    }
}
preorder(root);

结果:

[
  {"id":1,"pid":0},
    {"id":2,"pid":1},
    {"id":4,"pid":2},
      {"id":5,"pid":2},
    {"id":3,"pid":1},
      {"id":6,"pid":3},
      {"id":7,"pid":3}
]

---

你在缩进它，就像它是嵌套的一样，但实际上你没有嵌套任何数组或对象。你不能用一个只知道两个元素的简单比较函数来做这件事@Barmar我想他知道这一点，基本上，他想要有一棵树，然后用预排序进行线性化。@Barmar我缩进结果的原因只是为了清楚——至少我认为是这样。

sort（）

查看每一对数组元素，需要知道哪一个更高或更低。但您的排序是基于特定元素之间的父子关系。您将其缩进为嵌套，但实际上没有嵌套任何数组或对象。您不能使用只知道两个元素的简单比较函数来实现这一点@Barmar我想他知道这一点，基本上，他想要有一棵树，然后用预排序进行线性化。@Barmar我缩进结果的原因只是为了清楚——至少我认为是这样。

sort（）

查看每一对数组元素，需要知道哪一个更高或更低。但您的排序是基于特定元素之间的父子关系。