仅使用按索引获取单词的方法在未知大小的字典中查找单词

Question

前几天我在某大公司面试，名字不要求:)，面试官让我想办法解决下一个任务：

预定义： 有一个未指定大小的单词字典，我们只知道字典中的所有单词都是排序的（例如按字母表）。我们也只有一种方法

String getWord(int index) throws IndexOutOfBoundsException

需求： 需要开发算法来使用java在字典中查找一些输入词。为此我们应该实现方法

public boolean isWordInTheDictionary(String word)

限制： 我们无法改变字典的内部结构，我们无法访问内部结构，我们不知道字典中元素的数量。

问题： 我开发了修改后的二进制搜索，将发布我的算法变体（工作变体），但是否还有其他具有对数复杂度的变体？我的变体复杂度为 O(logN)。

我的实现变体：

public class Dictionary {
    private static final int BIGGEST_TOP_MASK = 0xF00000;
    private static final int LESS_TOP_MASK = 0x0F0000;
    private static final int FULL_MASK = 0xFFFFFF;
    private String[] data;
    private static final int STEP = 100; // for real test step should be Integer.MAX_VALUE
    private int shiftIndex = -1;
    private static final int LESS_MASK = 0x0000FF;
    private static final int BIG_MASK = 0x00FF00;


    public Dictionary() {
        data = getData();
    }

    String getWord(int index) throws IndexOutOfBoundsException {
        return data[index];
    }

    public String[] getData() {
        return new String[]{"a", "aaaa", "asss", "az", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "test", "u", "v", "w", "x", "y", "z"};
    }


    public boolean isWordInTheDictionary(String word) {
        boolean isFound = false;
        int constantIndex = STEP; // predefined step
        int flag = 0;
        int i = 0;
        while (true) {
            i++;
            if (flag == FULL_MASK) {
                System.out.println("Word is not found ... Steps " + i);
                break;
            }
            try {
                String data = getWord(constantIndex);
                if (null != data) {
                    int compareResult = word.compareTo(data);
                    if (compareResult > 0) {
                        if ((flag & LESS_MASK) == LESS_MASK) {
                            constantIndex = prepareIndex(false, constantIndex);
                            if (shiftIndex == 1)
                                flag |= BIGGEST_TOP_MASK;
                        } else {
                            constantIndex = constantIndex * 2;
                        }
                        flag |= BIG_MASK;

                    } else if (compareResult < 0) {
                        if ((flag & BIG_MASK) == BIG_MASK) {
                            constantIndex = prepareIndex(true, constantIndex);
                            if (shiftIndex == 1)
                                flag |= LESS_TOP_MASK;
                        } else {
                            constantIndex = constantIndex / 2;
                        }
                        flag |= LESS_MASK;
                    } else {
// YES!!! We found word.
                        isFound = true;
                        System.out.println("Steps " + i);
                        break;
                    }
                }
            } catch (IndexOutOfBoundsException e) {
                if (flag > 0) {
                    constantIndex = prepareIndex(true, constantIndex);
                    flag |= LESS_MASK;
                } else constantIndex = constantIndex / 2;
            }
        }
        return isFound;
    }

    private int prepareIndex(boolean isBiggest, int constantIndex) {
        shiftIndex = (int) Math.ceil(getIndex(shiftIndex == -1 ? constantIndex : shiftIndex));
        if (isBiggest)
            constantIndex = constantIndex - shiftIndex;
        else
            constantIndex = constantIndex + shiftIndex;
        return constantIndex;
    }

    private double getIndex(double constantIndex) {
        if (constantIndex <= 1)
            return 1;
        return constantIndex / 2;
    }
}

Answer 1

听起来他们真正希望您考虑的部分是如何处理您不知道字典大小的事实。我认为他们认为你可以给他们一个二分搜索。所以真正的问题是如何在搜索过程中控制搜索范围。

一旦您在字典中找到大于您的搜索目标（或超出范围）的值，其余的看起来就像标准的二分搜索。困难的部分是当目标值大于您查找的字典值时，如何以最佳方式扩展范围。看起来您正在扩大 1.5 倍。对于一个庞大的字典和一个小的固定初始步骤（如您所拥有的（100）），这可能真的有问题。想想如果有 5000 万个单词，如果您要搜索“斑马”，您的算法必须向上扩展范围多少次。

这是一个想法：通过假设每个单词的第一个字母均匀分布在字母表中的字母中来利用集合的有序性质（这永远不会是真的，但在不了解单词集合的情况下）这可能是你能做的最好的）。然后根据您期望字典单词距离结尾的距离来衡量您的范围扩展量。

因此，如果您在初始步骤 100 中查找该索引处的字典单词，并且它是“土豚”，那么与如果它是“海象”相比，您下一步的范围会扩大很多。仍然是 O(log n)，但对于大多数单词集合来说可能要好得多。

Answer 2

这是使用Collections.binarySearch 的替代实现。如果列表中的单词之一以字符 '\uffff' 开头（即 Unicode 0xffff 而不是合法的 not a valid unicode character），则会失败。

public static class ListProxy extends AbstractList<String> implements RandomAccess
{
    @Override public String get( int index )
    {
        try {
            return getWord( index );
        } catch( IndexOutOfBoundsException ex ) {
            return "\uffff";
        }
    }

    @Override public int size()
    {
        return Integer.MAX_VALUE;
    }
}

public static boolean isWordInTheDictionary( String word )
{
    return Collections.binarySearch( new ListProxy(), word ) >= 0;
}

更新：我对其进行了修改，使其实现了RandomAccess，因为 Collections 中的 binarySearch 否则会在如此大的列表上使用基于迭代器的搜索，这将非常慢。然而，这现在应该相当快，因为​​即使 List 尽可能大，二分搜索也只需要 31 次迭代。

这是一个稍作修改的版本，它记住最小的失败索引，以将其宣称的大小收敛到经过时的字典的实际大小，从而避免连续查找中的几乎所有异常。尽管每当字典的大小可能发生变化时，您都需要创建一个新的 ListProxy 实例。

public static class ListProxy extends AbstractList<String> implements RandomAccess
{
    private int size = Integer.MAX_VALUE;

    @Override public String get( int index )
    {
        try {
            if( index < size )
                return getWord( index );
        } catch( IndexOutOfBoundsException ex ) {
            size = index;
        }
        return "\uffff";
    }

    @Override public int size()
    {
        return size;
    }
}

private static ListProxy listProxy = new ListProxy();

public static boolean isWordInTheDictionary( String word )
{
    return Collections.binarySearch( listProxy , word ) >= 0;
}

Answer 3

您的想法是正确的，但我认为您的实现过于复杂。你想做一个二分搜索，但你不知道上限是多少。所以不是从中间开始，而是从索引 1 开始（假设字典索引从 0 开始）。

如果您要查找的单词“小于”当前字典单词，请将当前索引与“低”值之间的距离减半。 （当然，“低”从 0 开始）。

如果您要查找的单词“大于”您刚刚检查的索引处的单词，则将当前索引与您的“高”值之间的距离减半（“高”从 2 开始）或者，如果 index 和 "high" 相同，则将 index 加倍。

如果将索引加倍导致超出范围异常，则将当前值与加倍值之间的距离减半。因此，如果从 16 变为 32 会引发异常，请尝试 2​​4。当然，请注意 32 大于最大值这一事实。

因此，搜索序列可能看起来像 1、2、4、8、16、12、14 - 找到了！

这与二分查找的概念相同，但不是从低 = 0、高 = n-1 开始，而是从低 = 0、高 = 2 开始，并在需要时将高值加倍。它仍然是 O(log N)，尽管这个常数会比“正常”二分查找大一点。

Answer 4

如果您知道字典不会更改，则可能会产生 O(n) 的一次性成本。您可以将字典中的所有单词添加到哈希表中，然后对 isWordInDictionary() 的任何后续调用都将是 O(1)（理论上）。

Answer 5

使用 getWord() API 将字典的全部内容复制到更合理的数据结构中（例如哈希表、trie，甚至可能通过 Bloom 过滤器进行扩充）。 ;-)

Answer 6

使用不同的语言：

#!/usr/bin/perl

$t=0;
$cur=1;
$under=0;
$EOL=int(rand(1000000))+1;
$TARGET=int(rand(1000000))+1;
if ($TARGET>$EOL)
{
  $x=$EOL;
  $EOL=$TARGET;
  $TARGET=$x;
}
print "Looking for $TARGET with EOL $EOL\n";

sub testWord($)
{
  my($a)=@_;
  ++$t;
 return 0 if ($a eq $TARGET);
 return -2 if ($a > $EOL);
 return 1 if ($a > $TARGET);
 return -1;
}

while ($r = testWord($cur))
{
  print "Tested $cur, got $r\n";
  if ($r == 1) { $over=$cur; }
  if ($r == -1) { $under=$cur; }
  if ($r == -2) { $over = $cur; }
  if ($over)
  {
    $cur = int(($over-$under)/2)+$under;
    $cur++ if ($cur <= $under);
    $cur-- if ($cur >= $over);
  }
  else
  {
    $cur *= 2;
  }
}
print "Found $TARGET at $r in $t tests\n";

这个的主要好处是它更容易理解。我认为如果您的第一次猜测低于目标可能会更有效，因为我认为您没有利用您已经“搜索”的空间，但这只是快速浏览您的代码。因为它是为了简单而寻找数字，所以它不必处理找不到目标，但这是一个简单的扩展。

Answer 7

@Sergii Zagriichuk 希望采访顺利。祝你好运。

我认为正如@alexcoco 所说，二进制搜索就是答案。

我看到的其他选项只有在您可以扩展字典时才可用。你可以让它稍微好一点。例如。您可以计算每个字母上的单词，并以这种方式跟踪它们，您实际上只需要处理一部分单词。

或者是的，正如人们所说的，完全实现自己的字典结构。

我知道这不能正确回答您的问题。但我看不到其他可能性。

顺便说一句，很高兴看到您的算法。

编辑： 扩展 my comment under answer of bshields...

@Sergii Zagriichuk 我认为最好记住最后一个索引为空（无字）的索引。然后在每次运行时，您都可以检查它是否仍然正确。如果不是，则将范围扩展为通过反转二进制搜索行为获得的“先前索引”，因此我们再次为 null。这样，您将始终调整搜索算法范围的大小，从而根据需要适应字典的当前状态。此外，更改必须非常重要才能导致您的范围调整，因此调整不会对算法产生任何真正的负面影响。字典在本质上往往是静态的，所以这应该可以工作:)

Answer 8

一方面是的，您对二分搜索实现是正确的。但另一方面，如果字典是静态的并且在查找之间没有改变 - 我们可以建议不同的算法。这里我们有一个共同的问题 - 字符串排序/搜索与排序/搜索 int 数组相比是不同的，所以 getWord(int i).compareTo(string) 是 O(min(length0, length1))。

假设我们请求查找单词 w0, w1, ... wN，在查找过程中，我们可以建立一个带有索引的树（可能一些后缀树足以胜任这项任务）。 在下一次查找请求中，我们有以下集合 a1, a2, ... aM，因此为了减少平均时间，我们可以首先通过在树中搜索位置来减少范围。 这个实现的问题是并发和内存使用，所以下一步是实现使搜索树更小的策略。

PS：主要目的是检查您提出的想法和问题。

Answer 9

我认为可以更好地利用字典排序的信息。 假设您正在寻找单词“Zebra”，而第一次猜测搜索结果为“abcg”。 所以我们可以使用这个信息来选择第二个猜测索引。就像在我的情况下，结果词以 a 开头，而我正在寻找以 z 开头的东西。因此，我可以根据当前结果和所需结果进行一些计算跳跃，而不是进行静态跳转。所以以这种方式假设如果我的下一次跳跃将我带到“yvu”这个词，我现在非常接近，所以我会做一个比上一个例子更慢的小跳跃。

Answer 10

这是我的解决方案.. 使用 O(logn) 操作。代码的第一部分尝试找到长度的估计值，然后第二部分利用字典已排序并执行二进制搜索这一事实。

boolean isWordInTheDictionary(String word){
    if (word == null){
        return false;
    }
    // estimate the length of the dictionary array
    long len=2;
    String temp= getWord(len);

    while(true){
        len = len * 2;
        try{
          temp = getWord(len);
        }catch(IndexOutOfBoundsException e){
           // found upped bound break from loop
           break;
        }
    }

    // Do a modified binary search using the estimated length
    long beg = 0 ;
    long end = len;
    String tempWrd;
    while(true){
        System.out.println(String.format("beg: %s, end=%s, (beg+end)/2=%s ", beg,end,(beg+end)/2));
        if(end - beg <= 1){
            return false;
        }
        long idx = (beg+end)/2;
        tempWrd = getWord(idx);
        if(tempWrd == null){
            end=idx;
            continue;
        }
        if ( word.compareTo(tempWrd) > 0){
            beg = idx;
        }
        else if(word.compareTo(tempWrd) < 0){
            end= idx;
        }else{
            // found the word..
            System.out.println(String.format("getword at index: %s, =%s", idx,getWord(idx)));
            return true;
        }
    }
}

Answer 11

假设字典是从 0 开始的，我会将搜索分解为两部分。

首先，假设 getWord() 参数的索引是一个整数，并且假设索引必须是介于 0 和最大正整数之间的数字，请在该范围内执行二进制搜索以找到最大有效值索引（与单词值无关）。这个操作是 O(log N)，因为是一个简单的二分查找。

一旦获得了字典的大小，第二次普通的二分查找（复杂度也是 O(log N)）就会得到想要的答案。

由于 O(log N)+O(log N) 是 O(log N)，所以这个算法符合你的要求。

Answer 12

我正在招聘过程中问我同样的问题... 我的方法有点不同，考虑到我拥有的字典（网络服务），它的效率大约提高了 30%（对于我测试过的单词）。

解决方法如下： https://github.com/gustavompo/wordfinder

这里就不贴整个解决方案了，因为是通过类和方法解耦的，但是核心算法是这样的：

public WordFindingResult FindWord(string word)
    {
        var callsCount = 0;
        var lowerLimit = new WordFindingLimit(0, null);
        var upperLimit = new WordFindingLimit(int.MaxValue, null);
        var wordToFind = new Word(word);
        var wordIndex = _initialIndex;

        while (callsCount <= _maximumCallsCount)
        {
            if (CouldNotFindWord(lowerLimit, upperLimit))
                return new WordFindingResult(callsCount, -1, string.Empty, WordFindingResult.ErrorCodes.NOT_FOUND);

            var wordFound = RetrieveWordAt(wordIndex);
            callsCount++;

            if (wordToFind.Equals(wordFound))
                return new WordFindingResult(callsCount, wordIndex, wordFound.OriginalWordString);

            else if (IsIndexTooHigh(wordToFind, wordFound))
            {
                upperLimit = new WordFindingLimit(wordIndex, wordFound);
                wordIndex = IndexConsideringTooHighPreviousResult(lowerLimit, wordIndex);
            }
            else
            {
                lowerLimit = new WordFindingLimit(wordIndex, wordFound);
                wordIndex = IndexConsideringTooLowPreviousResult(lowerLimit, upperLimit, wordToFind);
            }

        }
        return new WordFindingResult(callsCount, -1, string.Empty, WordFindingResult.ErrorCodes.CALLS_LIMIT_EXCEEDED);
    }

    private int IndexConsideringTooHighPreviousResult(WordFindingLimit maxLowerLimit, int current)
    {
        return BinarySearch(maxLowerLimit.Index, current);
    }

    private int IndexConsideringTooLowPreviousResult(WordFindingLimit maxLowerLimit, WordFindingLimit minUpperLimit, Word target)
    {
        if (AreLowerAndUpperLimitsDefined(maxLowerLimit, minUpperLimit))
            return BinarySearch(maxLowerLimit.Index, minUpperLimit.Index);

        var scoreByIndexPosition = maxLowerLimit.Index / maxLowerLimit.Word.Score;
        var indexOfTargetBasedInScore = (int)(target.Score * scoreByIndexPosition);
        return indexOfTargetBasedInScore;
    }