相关疑难解决方法(0)

我有一个关于Array.forEachJavaScript 的本机实现的问题:它是否异步？例如,如果我打电话:

[many many elements].forEach(function () {lots of work to do})

这会不会阻塞吗？

我有一个已排序的JavaScript数组,并希望在数组中再插入一个项目,以便生成的数组保持排序状态.我当然可以实现一个简单的快速插入式插入功能:

var array = [1,2,3,4,5,6,7,8,9];
var element = 3.5;
function insert(element, array) {
  array.splice(locationOf(element, array) + 1, 0, element);
  return array;
}

function locationOf(element, array, start, end) {
  start = start || 0;
  end = end || array.length;
  var pivot = parseInt(start + (end - start) / 2, 10);
  if (end-start <= 1 || array[pivot] === element) return pivot;
  if (array[pivot] < element) {
    return locationOf(element, array, pivot, end);
  } else {
    return locationOf(element, array, start, pivot);
  }
}

console.log(insert(element, …

通过添加和删除项目,可以非常轻松地修改JavaScript中的数组.它有点掩盖了大多数语言数组是固定大小的事实,并且需要复杂的操作来调整大小.似乎JavaScript可以很容易地编写性能不佳的数组代码.这导致了一个问题:

在数组性能方面,我可以从JavaScript实现中获得什么样的性能(就大O时间复杂度而言)？

我假设所有合理的JavaScript实现至少具有以下大O.

• 访问 - O(1)
• 附加 - O(n)
• 前期 - O(n)
• 插入 - O(n)
• 删除 - O(n)
• 交换 - O(1)

JavaScript允许您使用new Array(length)语法将数组预填充到特定大小.(额外的问题:以这种方式创建一个数组O(1)或O(n))这更像是一个传统的数组,如果用作预先调整大小的数组,可以允许O(1)追加.如果添加了循环缓冲逻辑,则可以实现O(1)前置.如果使用动态扩展数组,则O(log n)将是这两者的平均情况.

对于某些事情,我可以期待比我的假设更好的表现吗？我不希望在任何规范中概述任何内容,但实际上可能是所有主要实现都在后台使用优化的数组.是否有动态扩展阵列或其他一些性能提升算法？

PS

我想知道这个的原因是因为我正在研究一些排序算法,其中大多数似乎假设在描述它们的整体大O时附加和删除是O(1)操作.

作为测试一些代码的副作用,我编写了一个小函数来比较使用array.push方法与直接寻址(array [n] = value)的速度.令我惊讶的是,推送方法通常表现得更快,特别是在Firefox中,有时在Chrome中.只是出于好奇:任何人都有解释吗？您可以在此页面找到测试(单击"数组方法比较")

我想知道旋转JavaScript数组的最有效方法是什么.

我想出了这个解决方案,其中正向n旋转数组向右旋转,负向左旋转n(-length < n < length):

Array.prototype.rotateRight = function( n ) {
  this.unshift( this.splice( n, this.length ) )
}

然后可以这样使用:

var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
months.rotate( new Date().getMonth() )

我上面的原始版本有一个缺陷,正如Christoph在下面的评论中指出的那样,正确的版本是(额外的返回允许链接):

Array.prototype.rotateRight = function( n ) {
  this.unshift.apply( this, this.splice( n, this.length ) )
  return this;
}

是否有更紧凑和/或更快的解决方案,可能在JavaScript框架的上下文中？(以下提出的版本都没有更紧凑或更快)

是否有任何JavaScript框架,内置数组旋转？(还没有人回答)

我有和object literal本质上是一个没有固定数量级别的树.我怎样才能在树中搜索特定节点,然后在javascript中以高效的方式返回该节点？

基本上我有一个像这样的树,并希望找到标题为'randomNode_1'的节点

var data = [
{
title: 'topNode',
 children: [
   {
       title: 'node1',
       children: [
       {
           title: 'randomNode_1'
       },
       {   
           title: 'node2',
           children: [
           {
               title: 'randomNode_2',
               children:[
               {   
                   title: 'node2',
                   children: [
                   {
                       title: 'randomNode_3',
                   }]
               }
               ]
           }]
       }]
   }
  ]
 }];

我正在学习算法和 DS。如何在 JavaScript 中使用队列？

我知道你可以做这样的事情。

var stack = [];
stack.push(2);       // stack is now [2]
stack.push(5);       // stack is now [2, 5]
var i = stack.pop(); // stack is now [2]
alert(i);            // displays 5

var queue = [];
queue.push(2);         // queue is now [2]
queue.push(5);         // queue is now [2, 5]
var i = queue.shift(); // queue is now [5]
alert(i);              // displays 2

但shift()不会改变所有东西因此，时间复杂度是O(N)，而不是Java中的Dequeue，时间复杂度是O(1)

为什么 JavaScript 本身没有像 Stack（数组）那样的队列概念？

我只是好奇而已。请赐教。

（我问自己这个问题，但找不到 ES8 或 ES9 内置 Dequeue O(1) 和 enqueue …

我需要找到最大数量，然后将其从数组中删除。（仅限单个实例）

令数组为

a=[91,65,91,88,26]

我正在使用Math.max()找到最大值

k=Math.max(...a)

a=a.filter(e => e!=k);