Javascript 创建一个堆，该堆根据竞争对手字段的出现情况进行优先级排序

这是我用来测试的一个模型变量：

[
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 2 },
    { competitor: 3 },
    { competitor: 4 },
    { competitor: 4 },
    { competitor: 4 },
    { competitor: 5 },
    { competitor: 6 },
    { competitor: 6 },
    { competitor: 7 },
    { competitor: 7 },
    { competitor: 7 },
    { competitor: 8 },
    { competitor: 9 },
    { competitor: 10 },
    { competitor: 11 },
    { competitor: 12 },
  ]

这是对重复项目进行分组的代码：

const splitRepeated = (array) => {
  let obj = array.reduce((res, curr) => {
    if (res[curr.competitor]) res[curr.competitor].push(curr);
    else Object.assign(res, { [curr.competitor]: [curr] });

    return res;
  }, {});
  return obj;
};

结果是：

{
  '1': [
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 },
    { competitor: 1 }
  ],
  '2': [ { competitor: 2 } ],
  '3': [ { competitor: 3 } ],
  '4': [ { competitor: 4 }, { competitor: 4 }, { competitor: 4 } ],
  '5': [ { competitor: 5 } ],
  '6': [ { competitor: 6 }, { competitor: 6 } ],
  '7': [ { competitor: 7 }, { competitor: 7 }, { competitor: 7 } ],
  '8': [ { competitor: 8 } ],
  '9': [ { competitor: 9 } ],
  '10': [ { competitor: 10 } ],
  '11': [ { competitor: 11 } ],
  '12': [ { competitor: 12 } ]
}

现在我需要均匀地分布这个数组的重复元素

例如：

[{ competitor: 1 },{ competitor: 2 },{ competitor: 3 },{ competitor: 1 },{ competitor: 4 },{ competitor: 5 },{ competitor: 1 }]

这是我最好的尝试：

const spreadOrder3 = (array) => {
  let obj = splitRepeated(array);
  let objEntities = Object.entries(obj);
  console.log(obj);
  let newArray = objEntities.map((x) => x[1][0]).flat();
  let oldIndex = newArray.length;
  for (let e = 0; e < oldIndex; e++) {
    let each = Math.floor(oldIndex / objEntities[e][1].length);

    let counter = 0;
    for (let i = 0; i < objEntities[e][1].length; i++) {
      console.log(objEntities[e][1][i]);
      console.log((counter + 1) * each);
      newArray.splice((counter + 1) * each, 0, objEntities[e][1][i]);
      // newArray[(counter + 1) * each] = objEntities[e][1][i];
      counter++;
    }
  }
  return newArray;
};

---

您可以对值进行分组，并按相同值的长度对分组的值进行排序

为结果数组获取一个索引数组，并以相同的距离分散同一组的值

Math.floor((indices.length - 1) / (a.length - 1))

通过使用索引数组，将其导入结果数组。从

索引

数组中删除已使用的索引，并继续操作，直到没有更多的值可供编辑

0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  indices at start

1  1  1  1  2  3  4  4  4  5  6  6  7  7  7  8  9 10 11 12  values
1                 1                 1                 1     d = 6
   4                       4                       4
      7                       7                          7
         6                                      6
            2  3     5  8        9    10 11 12              solitary values

const
数据=[1,1,1,1,2,3,4,4,5,6,6,7,7,8,9,10,11,12]，
索引=[…data.keys（）]，
组=数据.reduce（（r，v）=>（（r[v]？=[]）.push（v，r），{}），
结果=对象
.价值观（组）
.sort（（a，b）=>b.length-a.length）
.减少（（r，a）=>{
常数d=a.length==1？1：数学层（（index.length-1）/（a.length-1））；
a、 forEach（（v，i）=>r[index.splice（i*d-i，1）[0]]=v）；
返回r；
}, []);
console.log（…结果）请添加所需的结果。您是否也可以用精确的文字说明生成的数组应该是什么样子？必须有一个易于描述的模式。均匀分布这个数组的重复元素很难理解，对不同的人来说可能意味着不同的东西。我添加了一些结果，我希望我能更容易地理解这是描述你要找的东西的另一种方式吗创建一个根据竞争对手字段“Yes@PaulNikonowicz”的出现情况进行优先级排序的堆。您的描述最适合我的问题
0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  indices at start

1  1  1  1  2  3  4  4  4  5  6  6  7  7  7  8  9 10 11 12  values
1                 1                 1                 1     d = 6
   4                       4                       4
      7                       7                          7
         6                                      6
            2  3     5  8        9    10 11 12              solitary values