Algorithm 本机字符串匹配算法

下面是本机字符串匹配中一个非常著名的问题。请有人给我解释一下答案

假设模式p中的所有字符都不同。演示如何加速NAIVE-STRING MATCHER在n字符文本T上及时运行。

基本思想：

同时迭代输入和模式，相互比较它们的字符 无论何时，只要在两个字符之间获得不匹配的字符，就可以重置模式位置并保持输入位置不变 这是因为模式字符都是不同的，这意味着只要有部分匹配，就不会有其他匹配与之重叠，因此我们可以从部分匹配的末尾开始查看

下面是一些不太难理解的伪代码：

input[n]
pattern[k]
pPos = 0
iPos = 0
while iPos < n
  if pPos == k
    FOUND!
  if pattern[pPos] == input[iPos]
    pPos++
    iPos++
  else
    // if pPos is already 0, we need to increase iPos,
    //   otherwise we just keep comparing the same characters
    if pPos == 0
      iPos++
    pPos = 0

很容易看出，ipo至少每秒钟增加一次循环，因此最多可以有2n次循环运行，使运行时间延长。

基本思想：

同时迭代输入和模式，相互比较它们的字符 无论何时，只要在两个字符之间获得不匹配的字符，就可以重置模式位置并保持输入位置不变 这是因为模式字符都是不同的，这意味着只要有部分匹配，就不会有其他匹配与之重叠，因此我们可以从部分匹配的末尾开始查看

下面是一些不太难理解的伪代码：

input[n]
pattern[k]
pPos = 0
iPos = 0
while iPos < n
  if pPos == k
    FOUND!
  if pattern[pPos] == input[iPos]
    pPos++
    iPos++
  else
    // if pPos is already 0, we need to increase iPos,
    //   otherwise we just keep comparing the same characters
    if pPos == 0
      iPos++
    pPos = 0

---

很容易看出，iPos至少每秒钟增加一次循环，因此最多可以运行2n次循环，使运行时间延长。

当NAIVE-STRING-MATCHER中的T[i]和p[j]不匹配时，我们可以跳过T[i]之前的所有字符，并从T[i+1]开始与p[1]的新匹配

NAIVE-STRING-MATCHERT，p

1N长度[T]

2米长[p]

s 0至n-m为3

4如果p[1..m]=T[s+1..s+m]

---

5然后，当NAIVE-STRING-MATCHER中的T[i]和p[j]不匹配时，会出现移位s的打印模式，我们可以跳过T[i]之前的所有字符，并从T[i+1]开始与p[1]的新匹配

NAIVE-STRING-MATCHERT，p

1N长度[T]

2米长[p]

s 0至n-m为3

4如果p[1..m]=T[s+1..s+m]

---

5然后，在Python2.7中的shift s

Naive字符串搜索算法实现中出现打印模式：

在实现Boyer Moore的字符串搜索算法的过程中，我决定使用我最初的朴素搜索算法。它被实现为一个实例方法，该方法接受一个字符串进行搜索。对象有一个属性“pattern”，它是要匹配的模式

1这里是搜索方法的原始版本，使用双for循环。 打电话给range和len

def search(self, string):
    for i in range(len(string)):
        for j in range(len(self.pattern)):
            if string[i+j] != self.pattern[j]:
                break
            elif j == len(self.pattern) - 1:
                return i
    return -1

2这里是第二个版本，使用了双while循环。 稍微快一点，不打电话到靶场

def search(self, string):
    i = 0
    while i < len(string):
        j = 0
        while j < len(self.pattern) and self.pattern[j] == string[i+j]:
            j += 1
        if j == len(self.pattern):
            return i
        i += 1
    return -1

4在局部变量中存储值=赢！使用双while循环，这是最快的

def search(self, string):
    len_pat = len(self.pattern)
    len_str = len(string)
    i = 0
    while i < len_str:
        j = 0
        while j < len_pat and self.pattern[j] == string[i+j]:
            j += 1
        if j == len_pat:
            return i
        i += 1
    return -1

---

Python 2.7中的朴素字符串搜索算法实现：

在实现Boyer Moore的字符串搜索算法的过程中，我决定使用我最初的朴素搜索算法。它被实现为一个实例方法，该方法接受一个字符串进行搜索。对象有一个属性“pattern”，它是要匹配的模式

1这里是搜索方法的原始版本，使用双for循环。 打电话给range和len

def search(self, string):
    for i in range(len(string)):
        for j in range(len(self.pattern)):
            if string[i+j] != self.pattern[j]:
                break
            elif j == len(self.pattern) - 1:
                return i
    return -1

2这里是第二个版本，使用了双while循环。 稍微快一点，不打电话到靶场

def search(self, string):
    i = 0
    while i < len(string):
        j = 0
        while j < len(self.pattern) and self.pattern[j] == string[i+j]:
            j += 1
        if j == len(self.pattern):
            return i
        i += 1
    return -1

4在局部变量中存储值=赢！使用双while循环，这是最快的

def search(self, string):
    len_pat = len(self.pattern)
    len_str = len(string)
    i = 0
    while i < len_str:
        j = 0
        while j < len_pat and self.pattern[j] == string[i+j]:
            j += 1
        if j == len_pat:
            return i
        i += 1
    return -1