时间复杂度O()与KMP算法

爷,独闯天下 提交于 2020-03-28 17:49:36

要得到某个结果,可以有很多种方式,算法就是为了寻找一条最快的方式。

而评判其好坏的标准就是时间复杂度。

O(1):

  我们把执行一次的时间复杂度定义为O(1)

  sum = a +b;

  cout << sum <<endl;

O(n):

  for(int i = 0; i < n ;++n)

  {  

    //do something.

  }

O(n2):

    for(int i = 0; i < n ;++n)

  {  

   for(int j = 0; j < n ;++n)

    {

      //do something.

    }

  }

我们会碰到这样的需求,从一个主字符串中找到一个子串,首先我们想到的是这种方法:

#include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;

int findString(string S,string T)
{
    int i = 0;
    int j = 0;
    while(i<S.length() && j < T.length())
    {
        if(T[j] == S[i])
        {
            i++;
            j++;
        }
        else
        {
            j=0;
            i = i-j+1;
        }
    }
    if(j = T.length())
    {
        return i-j;
    }
    else
    {
        return -1;
    }
}

void main()
{
    int a = findString("adsfdjfxdf","xdf");
    cout << a <<endl;
    cin.get();
    cin.get();
}

时间复杂度为O(n*m)这个好理解,每比较m次,主字符串位置加1,最坏的情况就是比较n*m次

而实际上,我们不需要这样做,例如如果要在主字符串中找abcd,那每次i可以加4,下次直接从第5个开始比较。这样的时间复杂度是O(n/m*m) = O(n),而实际上我们要找的子串有可能会重复,于是一种更通用的算法就产生了, 克努特一莫里斯一普拉特算法, 简称 KMP 算法

主要思想基于上图,找到的比较便于理解的图,上图中1,2,3,4为相同内容,中间蓝色为相同内容,当我们第一次比较时,发现A和B不同,那么下一次比较时,我们主串仍从A开

始,而子串则从C处开始,3和2相同的内容便不再需要比较。具体解释百度,其实一看就能感觉应该是这样,而i从上次比较失败的地方继续开始在代码上逻辑也不混乱。

因此KMP算法比较关键的便是如何得到子串失败后开始的这个点C,为了得到这个C的位置i,KMP这3个人设计了一个中间数组,来保存子串的若比较失败应该开始的下一个比较点。

next数组, 含义就是一个固定字符串的最长前缀和最长后缀相同的长度。

 

比如:abcjkdabc,那么这个数组的最长前缀和最长后缀相同必然是abc。


cbcbc,最长前缀和最长后缀相同是cbc。   这个子串的next数组是[0,0,1,2,0]

 #include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;

void get_next(string T,int* next)
{
    next[0] = -1;
    int i = 0;
    int j = -1;
    while(i<T.length())
    {
        if((j == (-1)) || (T[i] == T[j]))
        {
            next[++i] = ++j;
        }
        else
        {
            j = next[j];   //可以想象两个子串如上图一样的比较
        }
    }
}

int KMP(string S , string T)
{
    int * next = new int[T.length()+1];
    int i = 0;
    int j = 0;
    get_next(T, next);
    while(i < int(S.length()) && j < int(T.length()))
    {
        if((-1 == j) || S[i] == T[j])
        {
            i++;
            j++;
        }
        else
        {
            j=next[j];      //如上图4区域刚好是next[j]不需要比较,从c处开始比较
        }
    }
    delete []next;
    if(j == T.length())
    {
        return i-j;
    }
    else
    {
        return -1;
    }
}

void main()
{
    string S;
    string T;
    cout<<"please input the Mstring:"<<endl;
    cin>>S;
    cout<<endl<<"please input the Cstring:"<<endl;
    cin >>T;
    cout<<S.length()<<endl;
    cout<<T.length()<<endl;
    cout<<"the child String in the M number is: "<< KMP(S,T);
    system("pause");
}

这个时间复杂度是O(m+n),因为是两个单循环相加。

写这个的时候 while(i < int(S.length()) && j < int(T.length())) 这句没有强转化int,导致j = -1时while循环只执行了一次未继续下去,后来看了一下length返回的并不是int,而是一个抽象的size,被这个错误搞得有点心态崩了。

 

O(1)

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!