Question

考虑我们有一系列按顺序到达的数字（总共N个数字）。如何开发一次通过（即在序列到达期间）O（N）算法来找到最小非零幅度的数字（以及它在序列中的位置）？请注意，标准的简单算法在这里不起作用，因为初始数字可能为零。

Answer 1

解决此问题的一种方法是将其建模为具有两种状态的状态机。在初始状态下，您还没有看到任何非零值，因此答案是“没有符合此标准的数字”。在这种状态下，只要你看到零，你就会留在这个状态。在非零值上，记录该值并转到下一个状态。下一个状态意味着“我已经看到至少一个非零值，现在我需要跟踪我看到的最小值。”到达此处后，每当您获得非零值作为算法的输入时，您将其幅度与您看到的最小非零幅度的值的大小进行比较，然后保持两者中较小的值。

使用类似C语言的简单实现可能如下所示：

bool seenNonzeroValue = false;
double minValue; /* No initializer necessary; we haven't seen anything. */

while (MoreDataExists()) {
    double val = GetNextElement();

    /* If the value is zero, we ignore it. */
    if (val == 0.0) continue;

    /* If the value is nonzero, then the logic depends on our state. */
     *
     * If we have not seen any values yet, then record this value as the first
     * value we've seen.
     */
    if (!seenNonzeroValue) {
        seenNonzeroValue = true;
        minValue = val;
    }
    /* Otherwise, keep the number with the smaller magnitude. */
    else {
        if (fabs(val) < fabs(minValue))
             minValue = val;
    }
}

/* If we saw at least one value, report it.  Otherwise report an error. */
if (seenNonzeroValue)
    return minValue;
else
    ReportError("No nonzero value found!");

希望这有帮助！

Answer 2

您无需跟踪是否已看到非零值。您可以使用sentinel值。调整@templatetypedef' answer：

中的代码

size_t pos = 0, minpos = -1; // track position as per the question requirements
double minValue = POSITIVE_INFINITY; // e.g., `1/+0.`

for ( ; MoreDataExists(); ++pos) {
  double val = GetNextElement();

  if (val and fabs(val) <= fabs(minValue)) { // skip +0, -0; update minValue 
    minpos   = pos;
    minValue = val;
  }
}

if (minpos != -1) 
  // found non-zero value with a minimal magnitude
  return make_pair(minpos, minValue);
else if (pos == 0)
  ReportError("sequence is empty");
else
  ReportError("no nonzero value found");

C ++中的示例

#include <algorithm>
#include <cmath>
#include <iostream>
#include <limits>

typedef double val_t;
typedef double* it_t;

int main () {
  val_t arr[] = {0, 0, 1, 0, 0, 2, 0}; // input may be any InputIterator
  it_t pend = arr + sizeof(arr)/sizeof(*arr);

  val_t sentinel = std::numeric_limits<val_t>::infinity();
  it_t pmin = &sentinel;

  for (it_t first = arr; first != pend; ++first)
    // skip +0,-0; use `<=` to allow positive infinity among values
    if (*first and std::abs(*first) <= std::abs(*pmin)) 
      pmin = first;

  if (pmin != &sentinel)
    std::cout << "value: " << *pmin << '\t'
              << "index: " << (pmin - arr) << std::endl;
  else
    std::cout << "not found" << std::endl;
}

输出

value: 1    index: 2

Answer 3

您需要考虑处理序列中每个数字所涉及的可能情况，即：它是零还是非零，如果非零则是第一个非零值？然后让alogrithm处理每个案例。我建议使用逻辑标志来跟踪后一种情况。

找到数字序列中最小非零幅度数的算法

3 个答案:

C ++中的示例

输出