字符串匹配之BM算法

最近，涉及到android下的c++开发，但是麻烦在于，在android平台下编译的话，如果使用了标准库中的iostream, fstream等，会使得编译出来的二进制代码体积过度膨胀，

所以需要去除iostream等标准库的使用，当然， STL中的<string>模板也会使得代码体积增大， 是由于string间接包含了其他标准库文件；

同时，std::string采用模板技术，所以效率也不高，也会导致代码膨胀，处于各方面需要考虑，实现了一个简单的KyString类，作为内部使用：

当然，还有许多不足，请高人指教：

字符串KyString类实现的主要难度在于find以及rfind,如下为其核心字符串匹配算法，请参考代码实现：

BM算法正向查找字符串代码如下：

inline int index_BM(const char *S, const char *T, int pos = 0)

{

int i;

int j;

i = pos;

j = 0;

while ( (i < strlen(S)) && (j < strlen(T)) )

{

if (S[i] == T[j])

{

i++;

j++;

}

else

{

i = i - j + 1;

j = 0;

}

}

if (strlen(T) == j)

{

return i - strlen(T);

}

else

{

return -1;

}

}

BM算法反向查找字符串代码如下：

inline int index_BMR(const char *S, const char *T, int pos = 0)

{

int i;

int j;

i = strlen(S);

j = strlen(T);

int len = strlen(T);

while ( (i > 0) && (j > 0) )

{

if (S[i - 1] == T[j - 1])

{

i--;

j--;

}

else

{

i = i + (len - j) - 1;

j = len;

}

}

if (j == 0)

{

return i;

}

else

{

return -1;

}

}

// KyStirng.h

#ifndef KYSTRING_H_

#define KYSTRING_H_

class KyString

{

friend KyString operator+(const KyString &lhs, const KyString &rhs);

public:

KyString();

KyString(const KyString &str);

KyString(const char *str);

~KyString();

KyString& operator=(const KyString &str);

public:

// 判断是否为空

bool empty() const;

// 获取字符串的大小

int size() const;

// 获取字符串的长度

int length() const;

//

const char* c_str();

//

void append(const char *str);

//

bool operator==(const KyString &str);

//

KyString& operator+=(const KyString &str);

//

int rfind(const char *sub) const;

//

int find(const char *sub) const;

//

KyString sub_str(int start, int end);

//

char& operator[](int idex);

//

const char& operator[](int idx) const;

private:

char *buffer;

};

#endif /* KYSTRING_H_ */

// KyString.cpp

#include <stdio.h>

#include <string.h>

#include "KyString.h"

KyString::KyString()

{

buffer = NULL;

}

KyString::KyString(const KyString &str)

{

if(str.buffer == NULL)

{

buffer = NULL;

}

else

{

buffer = new char[strlen(str.buffer) + 1];

strcpy(buffer, str.buffer);

}

}

KyString::KyString(const char *str)

{

if(str == NULL)

{

buffer = NULL;

}

else

{

buffer = new char[strlen(str) + 1];

strcpy(buffer, str);

}

}

KyString& KyString::operator=(const KyString &str)

{

if(this == &str)

{

return *this;

}

else

{

if(str.buffer == NULL)

{

buffer = NULL;

return *this;

}

else

{

if(buffer != NULL)

{

delete []buffer;

buffer = NULL;

}

buffer = new char[strlen(str.buffer) + 1];

strcpy(buffer, str.buffer);

}

}

}

KyString::~KyString()

{

if(buffer != NULL)

{

delete []buffer;

buffer = NULL;

}

}

// 判断是否为空

bool KyString::empty() const

{

if(buffer != NULL && strlen(buffer) > 0)

{

return true;

}

else

{

return false;

}

}

// 获取字符串的大小

int KyString::size() const

{

int size = strlen(buffer) + 1;

return size;

}

// 获取字符串的长度

int KyString::length() const

{

int len = strlen(buffer);

return len;

}

//

const char* KyString::c_str()

{

return buffer;

}

//

void KyString::append(const char *str)

{

if(str != NULL)

{

if(buffer != NULL)

{

int len_left = strlen(buffer);

int len_right = strlen(str);

char *tmp_buffer = new char[len_left + len_right + 1];

strcpy(tmp_buffer, buffer);

strcat(tmp_buffer, str);

delete []buffer;

buffer = NULL;

buffer = tmp_buffer;

}

else

{

int len = strlen(str);

buffer = new char[len + 1];

strcpy(buffer, str);

}

}

}

//

bool KyString::operator==(const KyString &str)

{

if(buffer == NULL || str.buffer == NULL)

{

return false;

}

else

{

if(!strcmp(buffer, str.buffer))

{

return true;

}

else

{

return false;

}

}

}

//

KyString& KyString::operator+=(const KyString &str)

{

if(this == &str)

{

return *this;

}

KyString tm;

tm.buffer = NULL;

if(str.buffer == NULL)

{

return *this;

}

if(buffer != NULL)

{

int len_left = strlen(buffer);

int len_right = strlen(str.buffer);

char *tmp_buffer = new char[len_left + len_right + 1];

strcpy(tmp_buffer, buffer);

strcat(tmp_buffer, str.buffer);

delete []buffer;

buffer = NULL;

buffer = tmp_buffer;

}

else

{

int len = strlen(str.buffer);

buffer = new char[len + 1];

strcpy(buffer, str.buffer);

}

}

KyString operator+(const KyString &lhs, const KyString &rhs)

{

KyString tmp;

tmp.append(lhs.buffer);

tmp.append(rhs.buffer);

return tmp;

}

inline int index_BMR(const char *S, const char *T, int pos = 0)

{

int i;

int j;

i = strlen(S);

j = strlen(T);

int len = strlen(T);

while ( (i > 0) && (j > 0) )

{

if (S[i - 1] == T[j - 1])

{

i--;

j--;

}

else

{

i = i + (len - j) - 1;

j = len;

}

}

if (j == 0)

{

return i;

}

else

{

return -1;

}

}

inline int index_BM(const char *S, const char *T, int pos = 0)

{

int i;

int j;

i = pos;

j = 0;

while ( (i < strlen(S)) && (j < strlen(T)) )

{

if (S[i] == T[j])

{

i++;

j++;

}

else

{

i = i - j + 1;

j = 0;

}

}

if (strlen(T) == j)

{

return i - strlen(T);

}

else

{

return -1;

}

}

//

int KyString::rfind(const char *sub) const

{

if(sub == NULL)

{

return -1;

}

else

{

if(buffer == NULL)

{

return -1;

}

else

{

return index_BMR(buffer, sub);

}

}

}

//

int KyString::find(const char *sub) const

{

if(sub == NULL)

{

return -1;

}

else

{

if(buffer == NULL)

{

return -1;

}

else

{

return index_BM(buffer, sub);

}

}

}

//

KyString KyString::sub_str(int start, int end)

{

if(buffer == NULL)

{

return KyString("");

}

if(start < 0 || end <= 0 || end <= start)

{

return KyString("");

}

int len = end - start;

char *new_buffer = new char[len + 1];

memset(new_buffer, 0, len + 1);

memcpy(new_buffer, buffer + start, len);

KyString tmp(new_buffer);

delete []new_buffer;

new_buffer = NULL;

return new_buffer;

}

//

char& KyString::operator[](int idx)

{

if(buffer != NULL && idx >= 0 && idx < strlen(buffer))

{

return buffer[idx];

}

}

//

const char& KyString::operator[](int idx) const

{

if(buffer != NULL && idx >= 0 && idx < strlen(buffer))

{

return buffer[idx];

}

}