您可以将搜索与 Boyer-Moore-Search 结合使用或跟踪常见的前缀序列。
[1] 博耶-摩尔
#include <algorithm>
#include <iostream>
#include <limits>
#include <memory>
#include <tuple>
class SkipTable
{
public:
typedef std::size_t size_type;
private:
enum { TableSize = unsigned(std::numeric_limits<unsigned char>::max()) + 1 };
public:
SkipTable()
{
size_type size;
std::tie(m_table, size) = std::get_temporary_buffer<size_type>(TableSize);
if(TableSize <= size) std::fill_n(m_table, TableSize, 1);
else {
std::return_temporary_buffer<size_type>(m_table);
m_table = 0;
}
}
private:
SkipTable(const SkipTable&); // No copy
SkipTable& operator = (const SkipTable&); // No copy
public:
~SkipTable() {
std::return_temporary_buffer<size_type>(m_table);
}
void set(const char* s, size_type len) {
if(len < 1) len = 1;
if(m_table) {
m_len = len;
std::fill_n(m_table, TableSize, m_len);
while(len)
m_table[unsigned(*s++)] = len--;
}
}
const size_type get(size_type pos) const {
size_type n = (m_table && pos < TableSize) ? m_table[pos] : 1;
return n;
}
operator bool() const { return m_table; }
private:
size_type* m_table;
size_type m_len;
};
const char* find(
SkipTable& skip,
const char* str, const std::size_t strlen,
const char* substr, const std::size_t substrlen)
{
typedef std::char_traits<char> traits_type;
typedef std::size_t size_type;
if (substrlen == 0 || strlen < substrlen) return 0;
const char* end = str + strlen - substrlen;
if(skip && 4 < substrlen && substrlen < strlen - substrlen) {
// Boyer-Moore-Search
//===================
skip.set(substr, substrlen);
while(str <= end) {
if(traits_type::compare(str, substr, substrlen) == 0)
break;
str += skip.get(*(str + substrlen));
}
return (str <= end) ? str : 0;
}
else {
// Brute Search
//=============
while(str <= end) {
if (traits_type::compare(str, substr, substrlen) == 0)
return str;
++str;
}
}
return 0;
}
#include <map>
void find_duplicates(const char* s, const std::size_t size) {
std::map<std::string, unsigned> duplicates;
SkipTable skip;
for(std::size_t n = 1; n < size / 2; ++n) {
for(std::size_t i = 0; i <= size - 2*n; ++i) {
const char* p = find(skip, s + i + n, size - i - n, s + i, n);
if(p) {
++duplicates[std::string(p, n)];
}
}
}
// Increment the counts
for(auto& d : duplicates) {
++d.second;
std::cout << '[' << d.second << "] \"" << d.first << "\"\n";
}
}
int main() {
std::string text = "Some text for matching sub-strings in the text.";
find_duplicates(text.c_str(), text.size());
}
注意：如果存在前缀序列，则可以通过映射结果和执行搜索来改进搜索（参见下面的代码）。
[2] 常用前缀序列
更快的方法：使用公共前缀序列存储指针并匹配前缀序列之后的后缀字符：
void find_duplications(const char* str, const std::size_t size) {
if(size <= 1) return;
struct Pointer {
const char* p;
std::size_t n;
Pointer(const char* p, std::size_t n)
: p(p), n(n)
{}
bool operator < (const Pointer& other) const {
typedef std::char_traits<char> traits_type;
int result = traits_type::compare(p, other.p, std::min(n, other.n));
if(result == 0) return (n < other.n);
else return result < 0;
}
};
typedef std::map<Pointer, unsigned> duplicate_container;
duplicate_container duplicates;
// Prefix
std::vector<const char*> prefix;
for(std::size_t i = 0; i < size - 1; ++i) {
duplicate_container::iterator pos = duplicates.find(Pointer(str+i, 1));
if(pos == duplicates.end()) {
for(std::size_t j = i + 1; j < size ; ++j) {
if(str[i] == str[j]) {
prefix.push_back(str+i);
prefix.push_back(str+j);
pos = duplicates.insert(duplicate_container::value_type(
Pointer(str+i, 1), 2)).first;
for(std::size_t k = j + 1; k < size ; ++k) {
if(str[i] == str[k]) {
prefix.push_back(str+k);
++pos->second;
}
}
// Delimiter
prefix.push_back(0);
break;
}
}
}
}
// Suffix
std::vector<const char*> suffix;
const char* limit = str + size;
std::size_t len = 1;
while( ! prefix.empty()) {
++len;
--limit;
suffix.clear();
for(std::size_t i = 0; i < prefix.size(); ++i) {
const char* p = prefix[i];
if( ! p) continue;
if(limit <= p) break;
duplicate_container::iterator pos = duplicates.find(Pointer(p, len));
if(pos == duplicates.end()) {
for(std::size_t j = i + 1; j < prefix.size(); ++j) {
const char* q = prefix[j];
if( ! q || limit <= q) break;
if(p + len <= q && p[len-1] == q[len-1]) {
suffix.push_back(p);
suffix.push_back(q);
pos = duplicates.insert(duplicate_container::value_type(
Pointer(p, len), 2)).first;
for(std::size_t k = j + 1; k < prefix.size(); ++k) {
q = prefix[k];
if( ! q || limit <= q) break;
if(p[len-1] == q[len-1]) {
suffix.push_back(q);
++pos->second;
}
}
// Delimiter
suffix.push_back(0);
break;
}
}
}
}
prefix.swap(suffix);
}
for(duplicate_container::iterator pos = duplicates.begin(); pos != duplicates.end(); ++pos) {
std::cout
<< '[' << pos->second << "] \""
<< std::string(pos->first.p, pos->first.n) << "\"\n";
}
}
int main() {
std::string text = "Some text for matching sub-strings in the text.";
find_duplications(text.c_str(), text.size());
}
结果
两种算法都将产生相同的结果集，但第二种算法的性能要优于第一种算法。
[7] " "
[3] " t"
[2] " te"
[2] " tex"
[2] " text"
[4] "e"
[2] "e "
[2] "e t"
[2] "e te"
[2] "e tex"
[2] "e text"
[2] "ex"
[2] "ext"
[2] "g"
[2] "h"
[3] "i"
[3] "in"
[2] "ing"
[2] "m"
[3] "n"
[2] "ng"
[2] "o"
[2] "r"
[3] "s"
[7] "t"
[2] "te"
[2] "tex"
[2] "text"
[2] "x"
[2] "xt"