写一段Boyer-Moore算法的C++代码

### 回答1：

Boyer-Moore算法是一种在文本中搜索模式的有效算法，它使用一个简单的技巧来提高搜索效率。下面是一段C语言实现Boyer-Moore算法的代码：int BoyerMooreSearch(char *txt, char *pat)
{
int m = strlen(pat);
int n = strlen(txt);

int badchar[256];

/* 填充bad character array */
FillBadChar(pat, m, badchar);

int s = 0;
while (s <= (n - m))
{
int j = m-1;

/* 找到匹配的字符*/
while (j >= 0 && pat[j] == txt[s+j])
j--;

/* 找到匹配的字符 */
if (j < 0)
{
/* 打印匹配的字符 */
printf("在位置 %d 匹配成功\n", s);
s += (s+m < n)? m-badchar[txt[s+m]] : 1;
}
else
s += max(1, j - badchar[txt[s+j]]);
}
return -1;
}

### 回答2：
Boyer-Moore算法是一种用于字符串匹配的高效算法，相比于传统的字符串匹配算法，它具有更快的速度和更少的比较次数。下面是在C语言中实现Boyer-Moore算法的代码：

#include <stdio.h>
#include <string.h>

#define MAX_CHAR 256

// 计算字符串中每个字符出现的最后位置
void computeLastOccurence(char *pattern, int *lastOccurence)
{
    int len = strlen(pattern);
    
    for(int i = 0; i < MAX_CHAR; i++)
    {
        lastOccurence[i] = -1;
    }
    
    for(int i = 0; i < len; i++)
    {
        lastOccurence[(int)pattern[i]] = i;
    }
}

// 实现Boyer-Moore算法
int boyerMoore(char *text, char *pattern)
{
    int textLen = strlen(text);
    int patternLen = strlen(pattern);
    int lastOccurence[MAX_CHAR];
    
    // 计算每个字符在pattern中最后出现的位置
    computeLastOccurence(pattern, lastOccurence);
    
    int shift = 0;
    while(shift <= textLen - patternLen)
    {
        int j = patternLen - 1;
        
        // 从后往前匹配pattern和text
        while(j >= 0 && pattern[j] == text[shift + j])
        {
            j--;
        }
        
        if(j < 0)
        {
            // 匹配成功，返回匹配的起始位置
            return shift;
        }
        else
        {
            // 计算pattern向右移动的距离
            int maxShift = j - lastOccurence[(int)text[shift + j]];
            
            if(maxShift < 1)
            {
                maxShift = 1;
            }
            
            shift += maxShift;
        }
    }
    
    return -1;  // 未找到匹配的位置
}

int main()
{
    char text[] = "ABABCABABDABABCABABCDE";
    char pattern[] = "ABABCABABCDE";
    
    int result = boyerMoore(text, pattern);
    
    if(result == -1)
    {
        printf("未找到匹配的位置\n");
    }
    else
    {
        printf("匹配位置: %d\n", result);
    }
    
    return 0;
}

以上是Boyer-Moore算法在C语言中的实现代码。该算法通过计算每个字符在模式串中最后出现的位置，从而优化了字符串匹配的效率。在主函数中，我们定义了一个文本串和模式串，并调用boyerMoore函数进行匹配。最终输出匹配的位置或未找到匹配的提示信息。

### 回答3：
下面是一个使用Boyer-Moore算法的C代码示例：

#include <stdio.h>
#include <string.h>

#define MAX_CHARS 256

// 计算字符串中每个字符最右出现的位置
void calculateBadChar(char *str, int size, int badChar[MAX_CHARS]){
    int i;
    for(i = 0; i < MAX_CHARS; i++){
        badChar[i] = -1;
    }
    for(i = 0; i < size; i++){
        badChar[(int)str[i]] = i;
    }
}

// Boyer-Moore算法
int boyerMoore(char *text, char *pattern){
    int textSize = strlen(text);
    int patternSize = strlen(pattern);

    int badChar[MAX_CHARS];
    calculateBadChar(pattern, patternSize, badChar);

    int shift = 0;
    while(shift <= (textSize - patternSize)){
        int j = patternSize - 1;

        while(j >= 0 && pattern[j] == text[shift+j]){
            j--;
        }

        if(j < 0){
            return shift;
        }else{
            shift += (j - badChar[(int)text[shift+j]]);
        }
    }
    return -1;
}

int main(){
    char text[] = "ABABDABACDABABCABAB";
    char pattern[] = "ABABCABAB";
    int result = boyerMoore(text, pattern);
    if(result == -1){
        printf("Pattern not found in the text\n");
    }else{
        printf("Pattern found at index: %d\n", result);
    }
    return 0;
}

Boyer-Moore算法是一种用于字符串搜索的高效算法，根据Pattern中的字符在Text中的出现位置规律，跳过一些不需要再进行比较的字符，从而提高搜索效率。