Javascript 如何在数组中找到最接近的数字，而不进行遍历？

我正在做一个简单的程序来确定下一班火车的时间。我有一个包含所有火车时间的数组，我只是不知道如何确定哪一个最接近当前时间，而不经过检查。以下是我到目前为止的情况：

var d = new Date();
var hours = d.getHours();
var minutes = d.getMinutes();

var time = hours + minutes;
console.log(time);

var trainTimes = [1125, 1155, 1225, 1255, 1325, 1355, 1425, 1455, 1526, 1629, 1644, 1709];

function nextTrain(time) {

}

---

在函数

nextTrain（）

中，我应该简单地执行if-else语句，还是有更好的方法？

我建议您在此处执行二进制搜索，因为您的数组已经排序。您可以查看此项以了解有关实现的详细信息

---

计算出当前时间在数组中的位置后，可以计算当前时间与两个最近邻居的差值。这取决于当前时间在二叉树中的位置。无论如何，这种方法会很有效。

我建议您在这里进行二进制搜索，因为您的数组已经排序。您可以查看此项以了解有关实现的详细信息

var d = new Date();
var hours = d.getHours();
var minutes = d.getMinutes();

var time = hours + minutes;
console.log(time);

// given sorted array.
var trainTimes = [1125, 1155, 1225, 1255, 1325, 1355, 1425, 1455, 1526, 1629, 1644, 1709];

// returns nth train 
function nextTrain(num, arr) {
    n = 0
    while (arr[n] <= num){ // consider < vs. <=
      n++;
    }
    return arr[n];
}

console.log(nextTrain(time,trainTimes))

计算出当前时间在数组中的位置后，可以计算当前时间与两个最近邻居的差值。这取决于当前时间在二叉树中的位置。无论如何，这种方法将是有效的。

var d=new Date（）；
var d = new Date();
var hours = d.getHours();
var minutes = d.getMinutes();

var time = hours + minutes;
console.log(time);

// given sorted array.
var trainTimes = [1125, 1155, 1225, 1255, 1325, 1355, 1425, 1455, 1526, 1629, 1644, 1709];

// returns nth train 
function nextTrain(num, arr) {
    n = 0
    while (arr[n] <= num){ // consider < vs. <=
      n++;
    }
    return arr[n];
}

console.log(nextTrain(time,trainTimes))

var hours=d.getHours（）；
var minutes=d.getMinutes（）；
var时间=小时+分钟；
console.log（时间）；
//给定排序数组。
var列车时刻=[112511551225125132513514251451526162916441709]；
//返回第n列
函数nextTrain（num，arr）{
n=0
而（arr[n]
var d=new Date（）；
var hours=d.getHours（）；
var minutes=d.getMinutes（）；
var时间=小时+分钟；
console.log（时间）；
//给定排序数组。
var列车时刻=[112511551225125132513514251451526162916441709]；
//返回第n列
函数nextTrain（num，arr）{
n=0
而（arr[n]由于列车时刻的数组是有序的，您可以在它们之间循环，直到在当前时间之后找到第一个，然后中断

function nextTrain(time) {
  for (i = 0; i<trainTimes.length; i++){
    if(trainTimes[i]>time){
     console.log("the next train is " + trainTimes[i]);
     break;
    }
  }
}

功能下一个训练（时间）{
for（i=0；itime）{
console.log（“下一列车为”+列车次[i]）；
打破
}
}
}
由于列车时刻的数组是有序的，您可以循环遍历它们，直到找到当前时间之后的第一个列车时刻，然后中断

function nextTrain(time) {
  for (i = 0; i<trainTimes.length; i++){
    if(trainTimes[i]>time){
     console.log("the next train is " + trainTimes[i]);
     break;
    }
  }
}

功能下一个训练（时间）{
for（i=0；itime）{
console.log（“下一列车为”+列车次[i]）；
打破
}
}
}
你需要把你的小时数乘以100

然后，您可以尝试以下方法：

nextTrain(time);

function nextTrain(time) {
    var timeFound = false;
    for(var i = 0; i < trainTimes.length; i++){
        if(time > trainTimes[i - 1] && time < trainTimes[i] && !timeFound ){
            console.log("Next train time is: " + trainTimes[i]);
            timeFound=true;
        }
    }
}

nextTrain（时间）；
函数nextTrain（时间）{
var-timeFound=false；
对于（变量i=0；i列车时刻[i-1]&&time<列车时刻[i]&&timeFound）{
console.log（“下一列车时间为：“+trainTimes[i]）；
timeFound=true；
}
}
}
你需要把你的小时数乘以100

然后，您可以尝试以下方法：

nextTrain(time);

function nextTrain(time) {
    var timeFound = false;
    for(var i = 0; i < trainTimes.length; i++){
        if(time > trainTimes[i - 1] && time < trainTimes[i] && !timeFound ){
            console.log("Next train time is: " + trainTimes[i]);
            timeFound=true;
        }
    }
}

nextTrain（时间）；
函数nextTrain（时间）{
var-timeFound=false；
对于（变量i=0；i列车时刻[i-1]&&time<列车时刻[i]&&timeFound）{
console.log（“下一列车时间为：“+trainTimes[i]）；
timeFound=true；
}
}
}
我希望它能帮助你

var d = new Date();
var hours = d.getHours();
var minutes = d.getMinutes();

var time = hours + minutes;
console.log(time);

var trainTimes = [1125, 1155, 1225, 1255, 1325, 1355, 1425, 1455, 1526, 1629, 1644, 1709];
var diff = new Array(12);
for (i = 0; i < trainTimes.length; i++) {
    diff[i] =Math.abs( time + trainTimes[i]);//difference
}
var diff_sort = diff.sort(function(a, b){return a-b});//acs sort
var nearestIndex = diff.indexOf(diff_sort[0]); 
var nearestValue = trainTimes[nearestIndex]; 
alert(nearestValue)

var d=新日期（）；
var hours=d.getHours（）；
var minutes=d.getMinutes（）；
var时间=小时+分钟；
console.log（时间）；
var列车时刻=[112511551225125132513514251451526162916441709]；
var diff=新阵列（12）；
对于（i=0；i
我希望它能帮助你

var d = new Date();
var hours = d.getHours();
var minutes = d.getMinutes();

var time = hours + minutes;
console.log(time);

var trainTimes = [1125, 1155, 1225, 1255, 1325, 1355, 1425, 1455, 1526, 1629, 1644, 1709];
var diff = new Array(12);
for (i = 0; i < trainTimes.length; i++) {
    diff[i] =Math.abs( time + trainTimes[i]);//difference
}
var diff_sort = diff.sort(function(a, b){return a-b});//acs sort
var nearestIndex = diff.indexOf(diff_sort[0]); 
var nearestValue = trainTimes[nearestIndex]; 
alert(nearestValue)

var d=新日期（）；
var hours=d.getHours（）；
var minutes=d.getMinutes（）；
var时间=小时+分钟；
console.log（时间）；
var列车时刻=[112511551225125132513514251451526162916441709]；
var diff=新阵列（12）；
对于（i=0；i
只要用这个：

var nextTimeIndex = (trainsTimes.indexOf(time) >= trainsTimes.length) ? 0 : trainsTimes.indexOf(time) + 1;
var nextTrain = trainsTimes[nextTimeIndex];

只要用这个：

var nextTimeIndex = (trainsTimes.indexOf(time) >= trainsTimes.length) ? 0 : trainsTimes.indexOf(time) + 1;
var nextTrain = trainsTimes[nextTimeIndex];

该算法称为二进制搜索。如果这个问题不是重复的，我会感到惊讶。ES6:
let nextTrain=Math.min（…trainTimes.filter（I=>I>time））
该算法称为二进制搜索。如果这个问题不是重复的，我会感到惊讶。ES6:
let nextTrain=Math.min（…trainTimes.filter（I=>I>time））
Binary search for a array of a array of a Binary search for a array of a mably？它应该会给你1325Oh，对了，这是下一个。出于某种原因，我认为即使是上一个，在它更接近时也应该考虑。这意味着在
1256
上实现将失败-它将返回
1255
，谢谢。所有这些都是我的我要做的eft是实现文本语音：）1700应该给你1709，它可能会这样做？它应该给你1325哦，对了，这是下一个。出于某种原因，我认为即使是上一个也应该在它接近时考虑。这意味着在
1256
上实现将失败-它将返回
1255
，谢谢。我要做的就是实现nt文本语音：）1700应该给你1709，它确实如此