自动完成算法？
Posted
技术标签:
【中文标题】自动完成算法？【英文标题】：Algorithm for autocomplete? 【发布时间】：2011-02-23 12:22:26 【问题描述】：我指的是当用户在 Google 中键入搜索词时用于提供查询建议的算法。
我主要感兴趣的是： 1. 最重要的结果（最有可能的查询而不是任何匹配的结果） 2.匹配子串 3. 模糊匹配
我知道你可以使用 Trie 或广义 trie 来查找匹配项，但它不符合上述要求...
早先提出的类似问题here
【问题讨论】：
这些东西，在谷歌规模上，是业界最伟大的成就之一。我建议你从更窄一点的东西开始 @Michael：我不是要求像谷歌这样的算法......但比尝试更好的东西......你也可以建议一些小但比尝试更好的东西...... 我删除了与 Google 自动完成类似的解决方案的要求，因为它简直太荒谬了。 【参考方案1】：我不知道这是否会回答您的问题，但我当时使用 C 语言编写了一个非常简单的输入自动完成代码。我还没有在这上面实现机器学习和神经网络，所以它不会进行概率计算等等。它所做的是使用子字符串检查算法检查与输入匹配的第一个索引。
您可以将匹配数据提供到“dict.txt”文件中。
/* Auto-complete input function in c
@authors: James Vausch
@date: 2018-5-23
- This is a bona-fide self-created program which aims to
stimulate an input auto-suggest or auto-complete function
in C language. This is open source so you can use the code
freely. However if you will use this, just acknowledge the
creator as a sign of respect.
- I'd also like to acknowledge Code with C team whom where I
I got an answer how to have a colored output instead of
using system("color #"). Link down below
https://www.codewithc.com/change-text-color-in-codeblocks-console-window/
- THE GENERAL IDEA IS; WE READ A FILE WITH DICTIONARY WORDS
OR SHALL WE SAY ALL WORDS. WE RUN A WHILE LOOP THAT WILL
GET CHARACTER FROM THE USER USING "getch()" FUNCTION THEN
STORE IT IN A CHARACTER ARRAY THEN IS PASSED ON A FUNCTION
THAT CHECKS IF THE ANY DICTIONARY WORDS HAS A SUBSTRING
THAT IS THE USER INPUT. IF YES(0), THE FUNCTION WILL COPY
THE FOLLOWING STRING FROM THE DICTIONARY ARRAY THEN STORED
IN A TEMP CHAR ARRAY AND PROCESSED. THE PROCESSING SHOULD
BE SIMPLE. WE RUN A LOOP IN WHICH WILL CHECK THE AMOUNT OF
CHARACTERS IN THE MATCHED STRING, THEN WE'LL RUN A LOOP
THAT WILL SORT THE WORDS DECREMENTALLY BASED ON THE AMOUNT
OF CHARACTERS OF THE INPUT SUBSTRING. THEN PRINT THE
PROCESSED STRING ON THE FRONT OF THE INPUT STRING THEN RUN
A LOOP BASED ON THE AMOUNT OF CHARACTERS PRESENT OR STRING
LENGTH OF THE PROCESSED STRING PLUS 10 EXTRA CHARACTERS
ALONG WITH PRINTING SOME BACKWARD TRAVERSE CARET FUNCTION
TO MAKE THE CARET STAY WHERE IT SHOULD BE ALONG WITH
INPUTTING. SIMPLE.
- <EXAMPLE>
INPUT: COM
AFTER LOOP RUN: MATCHED WITH WORD "COMMAND"
AFTER LOOP RUN: INPUT HAS 3 CHARACTERS
LOOP SEQUENCE:
LOOP 0: OMMAND
LOOP 1: MMAND
LOOP 2: MAND
AFTER LOOP: MAND
PRINT: "MAND" AFTER INPUT BUT KEEP CARET ON THE INPUT "COM"
NOTE:
- You'll need the "dict.txt" file or you can create one and
put some stuff there
- Since C Programs run on.. say a terminal, I have not much of a way to
efficiently make a way to use arrow keys for the job.
- you should type your INPUT in LOWERCASE since pressing "Shift_Key + M"
is equivalent to pressing the VK_Right(right arrow key) as well as
the other arrow keys
- the right arrow key has an ascii equivalent of <-32><77>, 77 = M
- to complete the input, you'll need to press right arrow key
- the left arrow key has an ascii equivalent of <-32><75>, 75 = K
- to remove auto-complete suggestion, press left arrow key
TO ADD:
- UP arrow key and DOWN arrow key to cycle through suggestions
*/
//#include <headers.h> //My personal header file
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
void main()
SetColor(6);
start();
void start()
int rep = 0;
char dictFile[] = "dict.txt";
loadDictionaryEntries(dictFile);
char inp[50];
printf("\nAuto Complete Program : C");
while(rep == 0)
printf("\nInput: ");
autoCompleteInput(inp);
if(strcasecmp(inp, "exit") == 0)
break;
printf("\nOutput: %s", inp);
printf("\n");
system("pause");
int dictEntryCount = 0;
struct allWords
char entry[100];
dictionary[60000];
//============================================================================//
void loadDictionaryEntries(char directory[])
FILE *file;
int dex = 0;
char str[100];
if(file = fopen(directory, "r"))
printf("File accessed.\n");
while(!feof(file))
fscanf(file, "%s", str);
//UN-COMMENT line 109 to check if the program is reading from file
//printf("Adding entry %d: \"%s\" to dictionary\n",dex + 1, str);
strcpy(dictionary[dex].entry, str);
dex++;
dictEntryCount++;
fclose(file);
printf("[ADDED %d WORDS TO DICTIONARY]\n", dictEntryCount);
else
printf(" File cannot be accessed.");
fclose(file);
void printArray()
for(int i = 0; i < dictEntryCount; i++)
printf("Index %d: %s\n", i + 1, dictionary[i].entry);
//============================================================================//
void autoCompleteInput(char input[])
char matchedWord[100]; //STORAGE FOR THE WORD THAT MATCHES INPUT
char ch; //STORAGE FOR EACH CHARACTER THAT THE USER INPUTS
int i = 0; //COUNTER
int words;
while(i != 200) //LOOP TO GET EACH CHARACTER FROM KEYBOARD PRESS
SetColor(6);
ch = getch();
clsx(strlen(matchedWord));
if(ch == 13) //CONDITION TO CHECK IF INPUT IS "ENTER" KEY
break; //BREAKS LOOP IF "ENTER IS PRESSED"
else if(ch == 8) //CONDITION TO CHECK IF INPUT IS "BACKSPACE"
if(i == 0) //IF INPUT IS NULL, DO NOTHING, DONT ERASE ANYTHING
//DO NOTHING
else //IF INPUT IS NOT NULL, ENABLE ERASING
clsx(strlen(matchedWord));
bksp();
i--;
input[i] = '\0';
if(i > 2)
if(matchToDictionary(input, matchedWord) == 0)
words = 0;
processMatchedWord(i, matchedWord);
SetColor(8);
printf("%s", matchedWord);
words = getArrSizeChar(matchedWord);
for(int x = 0; x < words; x++)
printf("\b");
else if(ch == 77) //CONDITION TO CHECK IF INPUT IS RIGHT ARROW KEY
printf("%s", matchedWord); //PRINT SUGESTED WORD WITH CARET AT FRONT
strcat(input, matchedWord); //CONCATENATE SUGGESTION TO INPUT
i = i + words - 1; //SETS INDEX AT THE END OF INPUT
words = 0; //
else if(ch == 75) //CONDITION TO CHECK IS INPUT IS LEFT ARROW KEY
clsx(strlen(matchedWord)); //ERASE SUGGESTION
i--; //DECREMENT INDEX
else //IF CONDITIONS ABOVE ARE NOT MET, DO THIS
input[i] = ch; //INSERT CH AT THE INDEX OF INPUT
printf("%c", ch); //PRINT CHARACTER
input[i + 1] = '\0'; //SET END OF CURRENT INPUT TO NULL
i++;
if(i >= 2)
if(matchToDictionary(input, matchedWord) == 0)
words = 0;
processMatchedWord(i, matchedWord);
SetColor(8);
printf("%s", matchedWord);
words = getArrSizeChar(matchedWord);
for(int x = 0; x < words; x++)
printf("\b");
else
clsx(strlen(matchedWord));
input[i] = '\0'; //NULL ENDING VALUE TO PREVENT UNNECESSARY CHARACTERS
int getArrSizeChar(char array[])
int size = 0;
while(array[size] != '\0')size++;
return size;
void clsx(int maxVal)
for(int i = 0; i < maxVal + 10; i++)
printf(" ");
for(int i = 0; i < maxVal + 10; i++)
printf("\b");
int matchToDictionary(char input[], char matchedWord[])
int found = 0;
int dex = dictEntryCount; //LIMIT OF ARRAY / ARRAY BOUND/S
//while(dictionary[dex] != '\0') //LOOP TO DETERMINE ARRAY BOUND
//printf("%d", dex);
//dex++; //INCREMENT IF INDEX OF ARRAY IS NOT NULL
//
//printf("%d", dex);
for(int i = 0; i < dex; i++) //LOOP TROUGH ALL INDEXES OF DICTIONARY
//CHECKS IF THE INDEX OF DICTIONARY HAS A SUBSTRING INPUT
//printf(" Matching %s and %s\n", dictionary[i], input);
if(containsIgnoreCase(dictionary[i].entry, input) == 0)
//CHECKS IF THE INDEX OF DICTIONARY TOTALLY MATCHES THE INPUT
//IT IS TO PREVENT ERRORS IN AUTO-COMPLETING PROCESS
if(strcasecmp(dictionary[i].entry, input) == 1)
//IF NOT, STORE INDEX OF DICTIONARY TO MATCHED WORD
strcpy(matchedWord, dictionary[i].entry);
found++;
break; //BREAK LOOP
if(found == 1)
return 0;
else
return 1;
void processMatchedWord(int rep, char str[])
int lim = 0;
int i;
char temp[50];
while(str[lim] != '\0')
lim++;
while(rep != 0)
for(i = 0; i < lim; i++)
str[i] = str[i + 1];
rep--;
//===================================================================//
void bksp()
printf("\b "); //first backsapce to print an emtpy character
printf("\b"); //second backspace to erase printed character
int containsIgnoreCase(char str1[], char str2[])
char tmp1[100];
char tmp2[100];
toLowerCase(tmp1, str1);
toLowerCase(tmp2, str2);
int i, j = 0, k;
for(i = 0; tmp1[i]; i++)
if(tmp1[i] == tmp2[j])
for(k = i, j = 0; tmp1[k] && tmp2[j]; j++, k++)
if(tmp1[k] != tmp2[j])
break;
if(!tmp2[j])
return 0;
return 1;
void toLowerCase(char destination[], char source[])
int lim = 0;
int i;
while(source[lim] != '\0')
lim++;
for(i = 0; i < lim; i++)
destination[i] = tolower(source[i]);
destination[i] = '\0';
/*Console Colors: Windows
0 = Black 8 = Gray
1 = Blue 9 = LBlue
2 = Green 10 = LGreen
3 = Aqua 11 = LAqua
4 = Red 12 = LRed
5 = Purple 13 = LPurple
6 = Yellow 14 = LYellow
7 = White 15 = Bright White
*/
void SetColor(int ForgC) //CODE SNIPPET FROM WWW.CODEWITHC.COM
WORD wColor;
//This handle is needed to get the current background attribute
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
//csbi is used for wAttributes word
if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
//To mask out all but the background attribute, and to add the color
wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);
SetConsoleTextAttribute(hStdOut, wColor);
return;
如果您指的是具有空初始化匹配的程序，然后将用户的输入保存到数组或文件中，然后当用户键入相同的单词时，程序将其与先前的输入匹配，也许我可以工作那个。
【讨论】：
【参考方案2】：如果您正在寻找问题的整体设计，请尝试阅读https://www.interviewbit.com/problems/search-typeahead/ 的内容。
他们首先通过使用 trie 的幼稚方法构建自动完成功能，然后在此基础上进行构建。他们还解释了采样和离线更新等优化技术，以迎合特定用例。
为了保持解决方案的可扩展性，您必须智能地对 trie 数据进行分片。
【讨论】：
【参考方案3】：Google 的确切算法未知，但it is said 通过对用户输入的统计分析来工作。一种不适用于大多数情况的方法。更常见的是使用以下方法之一实现自动完成：
树木。通过在树结构（前缀树、后缀树、dawg 等）中对可搜索文本进行索引，可以执行非常快速的搜索，但会占用内存存储空间。树遍历可以适应近似匹配。 模式分区。通过将文本划分为标记 (ngram)，您可以使用简单的散列方案执行模式出现的搜索。 过滤。找到一组潜在匹配项，然后应用顺序算法检查每个候选对象。看看completely，这是一个Java 自动完成库，它实现了后面的一些概念。
【讨论】：
【参考方案4】：对于子字符串和模糊匹配，Levenshtein 距离算法对我来说效果很好。虽然我承认它似乎并不像自动完成/建议的行业实现那么完美。我认为谷歌和微软的 Intellisense 都做得更好，因为他们已经改进了这个基本算法来衡量匹配不同字符串所需的编辑操作类型。例如。转置两个字符可能只算作 1 次操作，而不是 2 次（插入和删除）。
但即便如此，我发现这已经足够接近了。这是它在 C# 中的实现...
// This is the traditional Levenshtein Distance algorithem, though I've tweaked it to make
// it more like Google's autocomplete/suggest. It returns the number of operations
// (insert/delete/substitute) required to change one string into another, with the
// expectation that userTyped is only a partial version of fullEntry.
// Gives us a measurement of how similar the two strings are.
public static int EditDistance(string userTyped, string fullEntry)
if (userTyped.Length == 0) // all entries are assumed to be fully legit possibilities
return 0; // at this point, because the user hasn't typed anything.
var inx = fullEntry.IndexOf(userTyped[0]);
if (inx < 0) // If the 1st character doesn't exist anywhere in the entry, it's not
return Int32.MaxValue; // a possible match.
var lastInx = inx;
var lastMatchCount = 0;
TryAgain:
// Is there a better starting point?
var len = fullEntry.Length - inx;
var matchCount = 1;
var k = 1;
for (; k < len; k++)
if (k == userTyped.Length || userTyped[k] != fullEntry[k + inx])
if (matchCount > lastMatchCount)
lastMatchCount = matchCount;
lastInx = inx;
inx = fullEntry.IndexOf(userTyped[0], inx + 1);
matchCount = 0;
if (inx > 0)
goto TryAgain;
else
break;
else
matchCount++;
if (k == len && matchCount > lastMatchCount)
lastInx = inx;
if (lastInx > 0)
fullEntry = fullEntry.Substring(lastInx); // Jump to 1st character match, ignoring previous values
// The start of the Levenshtein Distance algorithem.
var m = userTyped.Length;
var n = Math.Min(m, fullEntry.Length);
int[,] d = new int[m + 1, n + 1]; // "distance" - meaning number of operations.
for (var i = 0; i <= m; i++)
d[i, 0] = i; // the distance of any first string to an empty second string
for (var j = 0; j <= n; j++)
d[0, j] = j; // the distance of any second string to an empty first string
for (var j = 1; j <= n; j++)
for (var i = 1; i <= m; i++)
if (userTyped[i - 1] == fullEntry[j - 1])
d[i, j] = d[i - 1, j - 1]; // no operation required
else
d[i, j] = Math.Min
(
d[i - 1, j] + 1, // a deletion
Math.Min(
d[i, j - 1] + 1, // an insertion
d[i - 1, j - 1] + 1 // a substitution
)
);
return d[m, n];
【讨论】：
【参考方案5】：我只想说... 这个问题的一个很好的解决方案是不仅仅包含三元搜索树。 需要 Ngram 和带状疱疹（短语）。还需要检测字边界错误。 “hell o”应该是“hello”……而“whitesocks”应该是“white socks”——这些是预处理步骤。如果您不正确地预处理数据，您将不会获得有价值的搜索结果。 三元搜索树是确定什么是单词的有用组件，也可用于在键入的单词不是索引中的有效单词时实现相关单词猜测。
谷歌算法执行词组建议和修正。 谷歌算法也有一些上下文概念......如果您搜索的第一个词与天气相关，并且您将它们结合起来“weatherforcst”与“monsoonfrcst”与“deskfrcst” - 我的猜测是幕后排名正在改变基于遇到的第一个词的建议 - 预测和天气是相关的词，因此预测在你是不是意思猜测中排名很高。
word-partials (ngrams)、phrase-terms (shingles)、word-proximity (word-clustering-index)、ternary-search-tree (word lookup)。
【讨论】：
【参考方案6】：对于（呵呵）很棒的模糊/部分字符串匹配算法，请查看 Damn Cool Algorithms：
http://blog.notdot.net/2007/4/Damn-Cool-Algorithms-Part-1-BK-Trees http://blog.notdot.net/2010/07/Damn-Cool-Algorithms-Levenshtein-Automata这些不会取代尝试，而是防止尝试中的蛮力查找 - 这仍然是一个巨大的胜利。接下来，您可能想要一种限制特里树大小的方法：
尝试使用全球最近/前 N 个单词； 对于每个用户，为该用户保留最近/前 N 个单词的 trie。最后，您希望尽可能避免查找...
缓存查找结果：如果用户点击任何搜索结果，您可以非常快速地提供这些结果，然后异步获取完整的部分/模糊查找。 预计算查找结果：如果用户输入了“appl”，他们可能会继续输入“apple”、“apply”。 预取数据：例如，Web 应用程序可以向浏览器发送较小的结果集，小到足以使 JS 中的蛮力搜索可行。【讨论】：
我不知道为什么这有 0 票。这是一个非常非常棒的答案。 嗅探，链接已损坏...如果有人知道在哪里可以找到有关 Levenshtein Automata 和 Burkhard-Keller Trees 的好文档 ... @Benibur：刚刚点击了链接，两者都在工作。【参考方案7】：看看Firefox's Awesome bar algorithm
Google 建议很有用，因为它考虑了数百万个热门查询以及您过去的相关查询。
虽然它没有一个好的完成算法/用户界面：
-
不做子串
似乎是一个相对简单的词边界前缀算法。
例如：尝试
tomcat tut --> 正确提示“tomcat 教程”。现在试试tomcat rial --> 没有建议)-:
不支持“您的意思是？” - 就像在谷歌搜索结果中一样。
【讨论】：
从我自己的搜索习惯来看，谷歌很聪明，不会自动完成子字符串。如果我正在寻找教程，我不会想到输入“rial”——所以不要给我看。另一方面，谷歌的自动完成功能似乎与可能是错别字或拼写错误的东西相匹配。我不介意。【参考方案8】：我认为构建一个专门的树可能会更好，而不是追求完全不同的数据结构。
我可以看到该功能体现在一个 trie 中，其中每个叶子都有一个字段，该字段反映了其相应单词的搜索频率。
搜索查询方法将显示具有最大值的后代叶子节点，该最大值是通过将到每个后代叶子节点的距离乘以与每个后代叶子节点相关联的搜索频率计算得出的。
Google 使用的数据结构（以及随之而来的算法）可能要复杂得多，可能会考虑到大量其他因素，例如您自己特定帐户的搜索频率（以及一天中的时间......以及天气）。 ..季节...和月相...和...）。 但是，我相信基本的 trie 数据结构可以通过在每个节点中包含附加字段并在搜索查询方法中使用这些字段来扩展为任何类型的专门搜索偏好。
【讨论】：
【参考方案9】：有像soundex和levenshtein distance这样的工具可以用来查找一定范围内的模糊匹配。
Soundex 查找听起来相似的单词，而 levenshtein distance 查找与另一个单词在特定编辑距离内的单词。
【讨论】：
以上是关于自动完成算法？的主要内容，如果未能解决你的问题，请参考以下文章