使用PHP在数组中获取最接近的值而无需循环

Question

给定一个数组：

   $foo = Array(
         99=>'Lowest Numbers',
        123=>'Low Numbers',
        456=>'High Numbers',
        777=>'Highest Numbers',
   );

...和值'144'，我想返回最近的低值和最近的高值，而不必循环遍历数组中的每个元素，因为实际数组非常大。

'144' 的预期结果是 123=>'Low Numbers'

我目前有以下代码：

    function name($color,$fuzzy=false) {
        global $resene;
        $long = 0;
        if(is_array($color)) {
            $long = Color::hex2lng(Color::rgb2hex($color));
        } else {
            $long = Color::hex2lng($color);
        }

        if(isset($resene[$long])) {
            echo $resene[$long];
        } else {
            if($fuzzy) {
                $resene[$long] = '';
                ksort($resene);

                // This is where I am having problems
                                    // The array is sorted, so it should be a simple
                                    // matter of getting the previous and next value
                                    // somehow since we know the position we want to
                                    // start at exists because it has been added.

                echo 'No color name found';
            }
        }
    }

基本上，这个概念非常简单，因为我们将未找到的值注入到数组中，我们知道它存在。按键排序，现在确保两个最接近的键是与正在搜索的数字最接近的匹配项。

上述函数实际上是一个基于Hex或RGB颜色的搜索，转换为base 10（long值）。

数组中的键是非增量的，这意味着它不是 0,1,2,3，即使我“翻转”了数组，键也会是字符串，同样，没有增量可获取最接近的。

我正在考虑拆分或其他什么，但是这似乎是根据元素的数量来拆分数组——而不是基于键。

这实际上是完成这项工作的最后一步——无需遍历每个元素。

任何帮助将不胜感激。

这是我编写的静态函数的 Pastbin，它使用颜色的 Long 值作为键返回颜色的 Array()，值是颜色的字符串名称。

Color Index Array

Answer 1

正如 thelolcat 指出的那样，您在这里可能不需要担心性能，但您可以尝试二进制搜索的变体。此处无法跳过搜索，因为您无法切入 ksort()。这只是我想出的一个快速草稿：

//$resene is your input ksort()-ed array, $long is the key which position and neighbours you're trying to find
$keys = array_keys($resene);
$min = reset($keys);
$s = key($keys);   // = 0
$max = end($keys);
$e = key($keys);   // = count($resene)
do {
    $guess = $s + (int)(($long - $min)/($max - $min)*($e - $s));
    if ($keys[$guess] > $long) {
        $e = $guess - 1;
        $max = $keys[$e];
        $min = $keys[++$s];
    } elseif ($keys[$guess] < $long) {
        $s = $guess + 1;
        $min = $keys[$s];
        $max = $keys[--$e];
    }
} while ($keys[$guess] != $long && $e != $s);
echo 'Me = '.$keys[$guess].'; prev = '.$keys[$guess - 1].'; next = '.$keys[$guess + 1];

我对一个包含 0 到 5,000,000 的 20,000 个随机数的数组进行了一些测试，该数组的目标值是随机的，我在 3-4 个循环中得到了成功。当然不要忘记检查 prev/next 是否存在。

此外，如果您可以使用普通的索引数组并在其上使用普通的 sort() 以避免与 array_keys() 重复数组，它会更好。我猜你试图在这里使用键只是为了获得一些速度，而你在数组值中没有任何有用的东西？如果是这样，您应该切换到索引数组。

如果您避免使用 k/sort() 并使用类似的方法首先找到插入新值的位置，您可以让它工作得更好。然后，您可以使用 array_splice() 插入它，并且您已经知道它的位置，因此，prev/next。

更新

查看示例中的方法 2 后，您的尝试变得更加清晰。我很好奇我可以在 PHP 中提出多少索引，所以这里有一个函数，它给出的结果与你的相同：

function fast_nearest($array, $value, $exact=false) {
    if (isset($array[$value])) {
        // If exact match found, and searching for exact (not nearest), return result.
        return array($value => $array[$value], 'exact' => true);
    } elseif ($exact || empty($array)) {
        return false;
    }
    // else
    $keys = array_keys($array);
    $min = $keys[0];
    $s = 0;
    $max = end($keys);
    $e = key($keys);
    if ($s == $e) {
        // only one element, it's closest
        return array_merge($array, array('exact' => false));
    } elseif ($value < $min) {
        return array($min => $array[$min], 'exact' => false);
    } elseif ($value > $max) {
        return array($max => $array[$max], 'exact' => false);
    }
    $result = false;
    do {
        $guess = $s + (int)(($value - $min) / ($max - $min) * ($e - $s));
        if ($guess < $s) {
            // oops, off the scale; we found it
            $result = $keys[$s];
        } elseif ($guess > $e) {
            $result = $keys[$e];
        } elseif ($keys[$guess] > $value && $keys[$guess - 1] < $value) {
            // found range
            $result = (($value - $keys[$guess - 1]) < ($keys[$guess] - $value)
                ? $keys[$guess - 1]
                : $keys[$guess]);
        } elseif ($keys[$guess] < $value && $keys[$guess + 1] > $value) {
            $result = (($value - $keys[$guess]) < ($keys[$guess + 1] - $value)
                ? $keys[$guess]
                : $keys[$guess + 1]);
        } elseif ($keys[$guess] > $value) {
            // narrowing search area
            $e = $guess - 1;
            $max = $keys[$e];
        } elseif ($keys[$guess] < $value) {
            $s = $guess + 1;
            $min = $keys[$s];
        }
    } while ($e != $s && $result === false);
    if ($result === false) {
        throw new Exception("Math laws don't work in this universe.");
    }
    return array($result => $array[$result], 'exact' => false);
}

我编译了大部分分散在函数顶部的退出场景，并且我放弃了将一个项目插入到数组中，因为它不会在函数之外持续存在。您可以在找到的位置使用array_splice() 轻松添加它。

我对两个函数（你的和我的）进行了速度测试，以比较从 1 到 1,000,000,000 的随机数数组（是的，两个函数都输入相同的输入）：

• 20,000 项：
  • fast_nearest() - 7.3 毫秒 平均 1000 次运行
  • nearest() - 207 毫秒 平均 1000 次运行
• 200,000 项：
  • fast_nearest() - 70 毫秒平均 10 次运行（抱歉，1000 次等待这个大小的时间太长了）
  • nearest() - 2,798 毫秒平均 10 次运行
• 2,000,000 项：
  • fast_nearest() - 937 毫秒 平均 2 次运行
  • nearest() - 22,156 毫秒平均 2 次运行

显然，两者在大型数组上都不能很好地工作，因此如果您必须处理这么多数据 - 我建议使用具有适当索引的数据库服务器之类的东西，PHP 不是适合它的工具。

Answer 2

这里：

$input = 142;
$offset = 0;

while(true){
  if(isset($foo[$input - $offset])){
    $found = array($input - $offset => $foo[$input - $offset]);
    break;
  }  

  if(isset($foo[$input + $offset])){
    $found = array($input - $offset => $foo[$input + $offset]);
    break;
  }      

  $offset++;
}

应该比标准循环便宜一点

这个数组到底有多大？为什么速度很重要？

编辑：

NVM。你的问题是错误的。我刚刚在 100K 元素的关联数组上对 ksort() 进行了计时测试。它需要 0.07 秒。而一个完整的 foreach 循环，需要 0.01 秒！