第四十二课 KMP算法的应用

思考：

 

replace图解：

程序完善：

 DTString.h：

#ifndef DTSTRING_H
#define DTSTRING_H

#include "Object.h"

namespace DTLib
{

class String : Object
{
protected:
    char* m_str;
    int m_length;

    void init(const char* s);
    bool equal(const char* l, const char* r, int len) const;

    static int* make_pmt(const char* p);
    static int kmp(const char* s, const char* p);

public:
    String();
    String(char c);
    String(const char* s);
    String(const String& s);

    int length() const;
    const char* str() const;

    bool startWith(const char* s) const;
    bool startWith(const String& s) const;
    bool endOf(const char* s) const;
    bool endOf(const String& s) const;

    String& insert(int i, const char* s);
    String& insert(int i, const String& s);

    String& trim();

    int indexOf(const char* s) const;
    int indexOf(const String& s) const;

    String& remove(int i, int len); //删除指定下标，指定长度的子串
    String& remove(const char* s);
    String& remove(const String& s);

    String& replace(const char* t, const char* s);
    String& replace(const String& t, const char* s);
    String& replace(const char* t, const String& s);
    String& replace(const String& t, const String& s);

    String sub(int i, int len) const;

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

    bool operator == (const String& s) const;
    bool operator == (const char* s) const;

    bool operator != (const String& s) const;
    bool operator != (const char* s) const;

    bool operator > (const String& s) const;
    bool operator > (const char* s) const;

    bool operator < (const String& s) const;
    bool operator < (const char* s) const;

    bool operator >= (const String& s) const;
    bool operator >= (const char* s) const;

    bool operator <= (const String& s) const;
    bool operator <= (const char* s) const;

    String operator + (const String& s) const;
    String operator + (const char* s) const;
    String& operator += (const String& s);
    String& operator += (const char* s);

    String operator - (const char* s) const;
    String operator - (const String& s) const;
    String& operator -= (const char* s);
    String& operator -= (const String& s);

    String& operator = (const String& s);
    String& operator = (const char* s);
    String& operator = (char c);

    ~String();
};

}


#endif // DTSTRING_H

DTString.cpp：

#include <cstring>
#include <cstdlib>
#include "DTString.h"
#include "Exception.h"

using namespace std;

namespace DTLib
{

int* String::make_pmt(const char* p)  // O(m)
{
    int len = strlen(p);

    int* ret = static_cast<int*>(malloc(sizeof(int) * len));

    if( ret != NULL )
    {
        int ll = 0;

        ret[0] = 0; // 第0个元素（长度为1的字符串）的ll值为0

        for(int i = 1; i < len; i++)
        {
            //不成功的情况
            while( (ll > 0) && (p[ll] != p[i]) )
            {
                ll = ret[ll];
            }

            // 假设最理想的情况成立
            //在前一个ll值的基础行进行扩展，只需比对最后扩展的字符是否相等
            //相等的话ll值加1，并写入到部分匹配表
            if( p[ll] == p[i] )
            {
                ll++;
            }

            ret[i] = ll; // 将ll值写入匹配表

        }
    }

    return ret;
}

int String::kmp(const char* s, const char* p)  //O(m) + O(n) = O(m + n)
{
    int ret = -1;

    int sl = strlen(s);
    int pl = strlen(p); //子串

    int* pmt = make_pmt(p);   //O(m)

    if( (pmt != NULL) && (0 < pl) && (pl <= sl))
    {
        for( int i = 0,j = 0; i < sl; i++ )
        {
            while( (j > 0) && (s[i] != p[j]) ) // j小于等于0时要退出
            {
                j = pmt[j];
            }

            if( s[i] == p[j] )
            {
                j++;
            }

            if( j == pl ) // j的值如果最后就是子串的长度，意味着查找到了
            {
                ret = i + 1 - pl; // 匹配成功时i的值停在最后一个匹配的字符上
                break;
            }
        }
    }

    free(pmt);

    return ret;
}

void String::init(const char* s)
{
    m_str = strdup(s);

    if( m_str )
    {
        m_length = strlen(m_str);
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create string object ...");
    }
}

bool String::equal(const char* l, const char* r, int len) const
{
    bool ret = true;

    for(int i = 0; i < len && ret; i++)
    {
        ret = ret && (l[i] == r[i]);
    }

    return ret;
}

String::String()
{
    init("");
}

String::String(const char* s)
{
    init(s ? s : "");   //空指针就转换成空字符串
}

String::String(const String& s)
{
    init(s.m_str);
}

String::String(char c)
{
    char s[] = {c, ''};

    init(s);
}

int String::length() const
{
    return m_length;
}

const char* String::str() const
{
    return m_str;
}

bool String::startWith(const char* s) const
{
    bool ret = ( s != NULL );

    if( ret )
    {
        int len = strlen(s);

        ret = (len < m_length) && equal(m_str, s, len);

    }

    return ret;
}

bool String::startWith(const String& s) const
{
    return startWith(s.m_str);
}

bool String::endOf(const char* s) const
{
    bool ret = ( s != NULL );

    if( ret )
    {
        int len = strlen(s);

        char* str = m_str + (m_length - len);

        ret = (len < m_length) && equal(str, s, len);

    }

    return ret;
}

bool String::endOf(const String& s) const
{
    return endOf(s.m_str);
}

String& String::insert(int i, const char* s)
{
    if( (0 <= i) && (i <= m_length) )
    {
        if( ( s != NULL) && ( s[0] != '' ) )
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(m_length + len + 1));

            if( str != NULL )
            {
                strncpy(str, m_str, i);
                strncpy(str + i, s, len);
                strncpy(str + i + len, m_str + i, m_length - i);

                str[m_length + len] = '';

                free(m_str);

                m_str = str;
                m_length = m_length + len;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create str object...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "parameter i is invalid...");
    }

    return *this;
}

String& String::insert(int i, const String& s)
{
    return insert(i, s.m_str);
}

String& String::trim()
{
    int b = 0;
    int e = m_length - 1;

    while( m_str[b] == ' ')b++;
    while( m_str[e] == ' ')e--;

    if( b == 0 )
    {
        m_str[e + 1] = '';

        m_length = e + 1;
    }
    else
    {
        for(int i = 0,j = b; j <= e; i++, j++)
        {
            m_str[i] = m_str[j];
        }

        m_str[e - b + 1] = '';
        m_length = e - b + 1;
    }

    return *this;
}

int String::indexOf(const char* s) const
{
    return kmp(m_str, s ? s : "");
}

int String::indexOf(const String& s) const
{
    return kmp(m_str, s.m_str);
}

String& String::remove(int i, int len)
{
    if( (0 <= i) && (i < m_length) )
    {
        int n = i;
        int m = i + len;

        while( (n < m) && (m < m_length) )
        {
            m_str[n++] = m_str[m++];
        }

        m_str[n] = '';
        m_length = n;
    }

    return *this;
}

String& String::remove(const char* s)
{
    return remove(indexOf(s), s ? strlen(s) : 0);
}

String& String::remove(const String& s)
{
    return remove(indexOf(s), s.length());
}

String& String::replace(const char* t, const char* s)
{
    int index = indexOf(t);

    if( index >= 0 )
    {
        remove(t);
        insert(index, s);
    }

    return *this;
}

String& String::replace(const String& t, const char* s)
{
    return replace(t.m_str, s);
}

String& String::replace(const char* t, const String& s)
{
    return replace(t, s.m_str);
}

String& String::replace(const String& t, const String& s)
{
    return replace(t.m_str, s.m_str);
}

String String::sub(int i, int len) const
{
    String ret;

    if( (0 <= i) && (i<m_length) )
    {
        if( len < 0 ) len = 0;
        if(len + i > m_length) len = m_length - i;

        char* str = reinterpret_cast<char*>(malloc(len + 1));

        strncpy(str, m_str + i, len);

        str[len] = '';

        ret = str;
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "parameter i is invalid...");
    }

    return ret;
}

char& String::operator [] (int i)
{
    if( (0 <= i) && (i < m_length) )
    {
        return m_str[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "parameter i is invalid ...");
    }
}

char String::operator [] (int i) const
{
    return (const_cast<String&>(*this))[i];
}

bool String::operator == (const String& s) const
{
    return ( strcmp(m_str, s.m_str) == 0 );
}

bool String::operator == (const char* s) const
{
    return ( strcmp(m_str, s ? s : "") == 0 );
}

bool String::operator != (const String& s) const
{
    return !(*this == s);
}

bool String::operator != (const char* s) const
{
    return !(*this == s);
}

bool String::operator > (const String& s) const
{
    return (strcmp(m_str, s.m_str) > 0);
}

bool String::operator > (const char* s) const
{
    return (strcmp(m_str, s ? s : "") > 0);
}

bool String::operator < (const String& s) const
{
    return (strcmp(m_str, s.m_str) < 0);
}

bool String::operator < (const char* s) const
{
    return (strcmp(m_str, s ? s : "") < 0);
}

bool String::operator >= (const String& s) const
{
    return (strcmp(m_str, s.m_str) >= 0);
}

bool String::operator >= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") >= 0);
}

bool String::operator <= (const String& s) const
{
    return (strcmp(m_str, s.m_str) <= 0);
}

bool String::operator <= (const char* s) const
{
    return (strcmp(m_str, s ? s : "") <= 0);
}

String String::operator + (const String& s) const
{
    return (*this + s.m_str);
}

String String::operator + (const char* s) const
{
    String ret;

    int len = m_length + strlen(s ? s : "");

    char* str = reinterpret_cast<char*>(malloc(len + 1));

    if( str )
    {
        strcpy(str, m_str);
        strcat(str, s ? s : "");

        free(ret.m_str);

        ret.m_str = str;
        ret.m_length = len;
    }
    else
    {
        THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create str object...");
    }

    return ret;
}

String& String::operator += (const String& s)
{
    return (*this = *this + s.m_str);
}

String& String::operator += (const char* s)
{
    return (*this = *this + s);
}

String String::operator - (const char* s) const
{
    return String(*this).remove(s);
}

String String::operator - (const String& s) const
{
    return String(*this).remove(s);
}

String& String::operator -= (const char* s)
{
    return remove(s);
}

String& String::operator -= (const String& s)
{
    return remove(s);
}

String& String::operator = (const String& s)
{
    return (*this = s.m_str);
}

String& String::operator = (const char* s)
{
    if( m_str != s )
    {
        char* str = strdup(s ? s: "");

        if( str )
        {
            free(m_str);

            m_str = str;
            m_length = strlen(m_str);
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create str object...");
        }
    }

    return *this;
}

String& String::operator = (char c)
{
    char s[] = {c, ''};

    return (*this = s);
}

String::~String()
{
    free(m_str);
}

}

小结：