Question

我有一段简单的代码来读取值数组。在用户输入上，比较2个值并将其设置为二进制堆。这里描述了该方法：

http://foswiki.cs.uu.nl/foswiki/MethodEngineering/TheBinarySearchTreeAsRequirementsPrioritizationTechnique

彼得在一张纸上写下每个要求并将它们堆起来。在一个第二步，他从第一个要求（要求5）堆积并把它放在白板上。然后他拿另一个要求（要求7）从桩和小组讨论哪个要求（要求5或7）更重要。最后他们同意要求7不如要求5重要。彼得将要求7放在要求5的左下角。然后他接受另一项要求（要求4），该小组再次对此进行了比较有要求5.在得出结论认为它也更少之后比要求5重要，他们将其与要求7进行比较同意它比要求更重要7.彼得说要求4的右下角要求7.该小组重复这个程序适用于堆上的所有要求。最后，他们有在白板上创建了所有要求的BST。最后，彼得按优先顺序创建所有要求的列表。为此他开始记下最合适的要求数量 BST（要求6）。他继续最接近它的要求（要求8），然后是最接近这个的要求（要求10），等等。所有要求的最终优先顺序是（从高到低）6,8,10,9,3,5,4,7,2和1.列表现在可以使用优先级要求来选择要求在下一个版本中实现。

＆＃13;

tets()
function tets() {
  var tasks = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"];

  //root
  var root = [tasks[0]];


  function prio(q, step) {

    //compare with step[0], now I just say 'random' more or less important for this demo;  
    var res = Math.random() > .5;

    if (res) {
      if (!step[2]) {
        step[2] = [q];

      } else {

        prio(q, step[2])
      }
    } else {

      if (!step[1]) {
        step[1] = [q]

      } else {
        prio(q, step[1])
      }
    }


  }



  for (var i = 1; i < tasks.length; i++) {
    prio(tasks[i], root)
  }
  console.log(root)
}

＆＃13;

<pre id="result"> </pre>

＆＃13;

如您所见，数组的构建方式与图像中的二叉树类似。每个元素都像3的数组一样构建：[0] =名称，1是左边的节点，en 2是右边的节点。

主要问题是：

如何让javascript遍历此树并将最正确的元素作为最高优先级，最左边的元素作为最低优先级？

Answer 1

基本上你可以使用Breadth-first search。

执行的顺序很重要，首先查找正确的子节点并遍历，显示节点信息，然后迭代左边的子节点。

function traverse(a) {
    if (Array.isArray(a)) {
        a[2] && traverse(a[2]);
        a[0] && document.write(a[0] + '<br>');
        a[1] && traverse(a[1]);			
    }
}

var root = [5, [7, [2, [1]], [4]], [9, [3], [8, [10], [6]]]];
document.write('<pre>' + JSON.stringify(root, 0, 4) + '</pre>');
traverse(root);

Answer 2

好的，所以我写了这个函数：

的JavaScript

function getFlatArray(array, priority) {
  var result = [];
  getFlatArrayRecursive(array, priority, result);
  return result;
}

function getFlatArrayRecursive(array, priority, result) {
  for(var i = 0; i < priority.length; i++) {
    var currentItem = array[priority[i]];
    if(currentItem != null) {
      if(Array.isArray(currentItem)) {
        getFlatArrayRecursive(currentItem, priority, result);
      } 
      else {
        result.push(currentItem);
      }
    }
  }
}

var priority = [2, 0, 1];
var root = [
   5,
   [
      7,
      [
         2,
         [1]
      ],
      [4]
   ],
   [
      9,
      [3],
      [
         8,
         [10],
         [6]
      ]
   ]
];
var results = getFlatArray(root, priority);
console.log(results); //[6, 8, 10, 9, 3, 5, 4, 7, 2, 1]

JSFIDDLE

Answer 3

序列化树状态，并通过在每个分支级别使用排序方法分析哪个分支更高/更低，直到遍历整个树。将最高/最低值存储在函数外部的全局变量中。即使当前分支级别不仅仅是二进制系统，这也应该有效。下面是每个级别递归函数内部代码的示例：

// example tasks at this branch level
var tasks = [["a", 1, 2], ["b", 0, 1], ["c", 3, 0], ["d", 4, 1]];

// make a copy so that original task list is maintained
var tasksCopy = tasks;

// sort the array from lowest left node to highest left node      
var sortedLowToHigh = tasksCopy.sort(function(a, b) { 
     return a[1] - b[1];
});

// the lowest value will be at the first array element
var highestPriorityTask = sortedLowToHigh[0][1];

// sort the arry from highest right node to lowest right node
var sortedHighToLow = tasksCopy.sort(function(a, b){
     return b[2] - a[2];
});

// the highest value will be at the first array element
var lowestPriorityTask = sortedHighToLow[0][2];

Answer 4

我认为这个答案对代码行来说是最好的：

function traverse(n) {
  return !Array.isArray(n) 
        ? (isNaN(n) ? [] : [n]) 
        : [...traverse(n[2]), ...traverse(n[0]), ...traverse(n[1]), ];
}
var root = [5, [7, [2, [1]], [4]], [9, [3], [8, [10], [6]]]];

console.log(traverse(root));

从左到右读取数组＆＃39;，二进制堆优先级

4 个答案: