Question

关于为存储在数组中的n元树选择排序算法...

我正在使用简单的块（在此示例中定义）在线性化数组中存储n元树：

let block = {
  UID: 'Go0d',     // 4-digits-of-64-values (pseudo randsom)
  PUID: '_Bad',    // parent UID, same spec as UIDs,
  rank: 11,        // child rank
  value: 'tomato', // embeded value 
  used: true       // whenever to release/recyckle a block
}

存储最小值对于内存大小更好。我没有维护子UID的列表以节省空间，但是我可以使用查找哈希来有效地定位O（N）中的块。

要允许树复兴，我需要通过育儿和同级对数组进行排序。我写过类似的东西：

// big piece of code, questions below...

import { toString } from './blocks.js'

export const multisort = pool => {

  const byUsage = (b1, b2) => {
    if(!b1.used && b2.used) return -1
    if(b1.used && !b2.used) return 1

    return 0
  } 

  const byParenting = (b1, b2 ) => {
    if(b1.PUID === b2.UID) return -1
    if(b1.UID === b2.PUID) return   1

    return 0
 }

  const bySibling = (b1, b2) => {
    if(b1.PUID === b2.PUID) {
      if(b1.rank < b2.rank) return -1
      if(b1.rank > b2.rank) return 1
    }

    return 0 
  }


  // a 'ptrdivate function'
  const decide = (prev,  next) =>  (prev === 0) ? next : prev

  // a custom sort function
  const multi_sort = (b1, b2) => { 

    // note there are weights:
    // 
    // +1 = asc
    // -1 = desc
    // 0 = disable
    // 
    const bu = 0 * byUsage(b1, b2)
    const bp = 1 * byParenting(b1, b2)
    const bs = -1 * bySibling(b1, b2)

    const tests = [bu, bp, bs].reduce((acc, val) => decide(acc, val), 0 )

    return tests
  }

  pool.blocks.sort(multi_sort)
}

问题是在使用JS sort进行排序时出现的：这是一种快速排序，因此不会将所有元素都进行比较（因为O（N * log（N））复杂性），并且parentUID在集合上定义了部分顺序。 ..

我应该考虑：

选项1：使用冒泡排序（Argh）：O（N * N）中的复杂度吗？
选项2：像我所做的那样：维护每个节点，在树中列出到根的路径，并带有特殊键“ 0000”或NULL作为根，但是如果我对树进行了突变，我需要重新计算此列表吗？
选项3：重复k次不完美的排序算法...推测它会在几个循环数内产生稳定的输出。我更喜欢这种方法，但是该死，k = function（avg_branch_factor，max_tree_depth）是什么样的？
选择4：使用拓扑排序算法（如果适用），我不掌握此技术？

听起来更好吗？

JS：从n元树中排序节点

0 个答案: