数据结构第四章学习小结

第四章主要学习了串和数组，串中最重要的内容就是KMP算法和BF算法，BF算法会好理解一点，但是时间复杂度较大，KMP算法虽然理解起来有点难，但是弄懂了之后就会发现用起来比BF算法方便很多，时间复杂度也会小很多。其次，还学了特殊矩阵的压缩存储，这种压缩存储对于一些特殊矩阵（对称，三角，对角矩阵）的存储有很大的帮助，可以节省很大的空间。

PTA上的两道编程，第一道是串的模式匹配，刚开始打的时候想试试BF算法，但是发现如果 i 和 j 从1开始的话，第二个测试点试过不了的，都改成从0开始后，就只有最后一个测试点运行超时，这个问题我查了一下，一般情况下，BF算法时间复杂度为O（m*n），数据量不大时候，执行时间近似为O（m+n）,但如果是庞大数据，那它的效率就很低了，最后那个测试点的数据量很大，并且，这两个字符串从第一个字符比较一直不匹配，而模式串一直回溯到 j=0 ,这样工作量很大，所以BF算法提交之后在这个测试点是运行超时的。

代码如下：

int Index_BF(string s,string t)
{
    int i = 0;
    int j = 0;
    while(i<=strlen(S)&&j<=strlen(T))
    {
        if(S[i]==T[j])  
        {
            i++; 
            j++;
        }
        else
        {
            if(j==0)
            {
                j++;
            }
            else
            {
                i=i-j+2;
                j=1;
            }
                
        }
    }
    if(j>strlen(T))  
    {
        return i-strlen(T);
    }
    else return 0;
}

后来我照着SPOC上的视频打了一遍代码，发现用char *做函数参数是=时只能过一个测试点，改为string类型后，全部测试点都可以过，不会出现运行超时的问题，主要是因为kmp算法减少了字符串查找过程中的回退，尽可能减少不用的操作，算法复杂度是O(n+m)。

代码如下：

void BuildMatch( string pattern, int *match )
{
    Position i, j;
    int m = pattern.length();
    match[0] = -1;
      
    for ( j=1; j<m; j++ ) {
        i = match[j-1];
        while ( (i>=0) && (pattern[i+1]!=pattern[j]) )
            i = match[i];
        if ( pattern[i+1]==pattern[j] )
             match[j] = i+1;
        else match[j] = -1;
    }
}
  
Position KMP( string k, string pattern )
{
    int n = k.length();
    int m = pattern.length();
    Position s, p, *match;
      
    if ( n < m ) return NotFound;
    match = new Position[m];
    BuildMatch(pattern, match);
    s = p = 0;
    while ( s<n && p<m ) {
        if ( k[s]==pattern[p] ) {
            s++; p++;
        }
        else if (p>0) p = match[p-1]+1;
        else s++;
    }
    return ( p==m )? (s-m+1) : NotFound;
}

第二个代码是求交集，不过这次的两个集合是无序的，所以需要先给两个集合排序，开始的时候我自己打了两个sort函数，发现过不了最后那个测试点，会显示运行超时的错误，后来我查了下资料，改用了<algorithm>库中的sort的函数，此时全部测试点都可以通过，这个sort函数的时间复杂度为n*log2n，想了解的同学可以去这个链接看看https://baike.baidu.com/item/sort%E5%87%BD%E6%95%B0/11042699?fr=aladdin。

代码如下：

void sort(int a[],int n)
{
    int i,j,t;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n-1-i;j++)
        {
            if(a[j]>a[j+1])
            {
                t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
            }
        }
    }
} 

void sort(int a[],int n)
{
    int i,j,p,t;
    for(i=0;i<n-1;i++)
    {
        p = i;
        for(j=i+1;j<n;j++)
        {
            if(a[j]<a[p]) p=j;
        }
        if(p!=i)
        {
            t = a[p];
            a[p]=a[i];
            a[i]=t;
        }
    }
}


 void Sort(int a[],int n)
{
 int i,j,temp=a[0];
 for(i=0;i<n-1;i++)
 {
  for(j=i+1;j<n;j++)
  {
   if(a[j]<a[i])
   {
    temp = a[i];
    a[i] = a[j];
    a[j] = temp;
   }
  }
 }
}

这三个函数都是运行超时的问题，下面这份代码运用了<algorithm>库中的函数，所有的测试点都可以过

#include <iostream>
#include <algorithm>
using namespace std;
 
int main()
{
    int a[100000],b[100000],c[100000];
    int n,m;
    cin >> n >> m;
    int i,j,k=0;
    for(i=0;i<n;i++)
    {
        cin >> a[i];
    }
    for(i=0;i<m;i++)
    {
        cin >> b[i];
    }
    sort(a,a+n);
    sort(b,b+m);
    for(i=0,j=0;i<n&&j<m;)
    {
        if(a[i]==b[j])
        {
            c[k++]=a[i];
            i++;
            j++;
        }
        else if(a[i]>b[j])
        {
            j++;
        }
        else
        {
            i++;
        }
    }
    cout << k <<endl; 
    for(i=0;i<k;i++)
    {
        if(i==0) cout << c[i];
        else
        {
            cout << " " <<c[i];
        }
    }
    return 0;
}

这章的学习我在CSDN和博客园上找到了许多有利于学习的博客，推荐大家在遇到不懂的知识时可以去上面查一查

大家对KMP算法还不是很会的话可以去看看这个博客，讲的很清楚https://blog.csdn.net/dark_cy/article/details/88698736

我在打求交集的时候最开始想用链表实现，就去找了一下给链表排序的方法，有兴趣的同学可以看看https://blog.csdn.net/qq_33835221/article/details/85988596

虽然现在可以理解KMP算法了，但是无法完全独自打出KMP算法的全部代码，争取在下一章的学习中可以在学习新知识的同时可以复习一些以前学的知识，多自己去复现一些书上的代码。