用sunday算法解决字符串匹配问题

题目内容：
题目说起来很简单，你会读到两个字符串，每个字符串占据一行，每个字符串的长度均小于10000字符，而且第一个字符串的长度小于第二个字符串的。你的程序要找出第一个字符串在第二个字符串中出现的位置，输出这些位置，如果找不到，则输出-1。

注意，第一个字符的位置是0。

注意，第一个字符串在第二个字符串中的位置可能不止一处。

注意，字符串中可能含有空格。

注意，两个字符串的长度一定大于0。

输入格式:
两个字符串，一行一个。

输出格式：
第一个字符串在第二个字符串中出现的位置，按照从小到到的顺序排列，每个数字后面有一个空格。
如果在第二个字符串中找不到第一个字符串，则输出-1。

输入样例：
abba
ababbba abbabbabbabbaacc

输出样例：
8 11 14 17

/sunday算法解决字符串匹配问题///

sunday算法思想：
  对匹配串长度的模式串进行随机顺序的检测，在失败位置生成
  移动数组，根据移动数据最大幅度的减少匹配次数
使用结构体：
  SqString(char data[];int lengthp) //顺序栈保存字符串
函数说明：
  SundayIndex：
  输入：  int start //模式开始匹配位置
      SqString s //模式串
      SqString p //匹配串 
      int ScanOrdToUse[]  //对读取顺序进行的顺序读取转译
      int ScanOrder[]  //随机生成的匹配串读取顺序
      int ValueOfShift[] //对错误位置生成的后移数组
  输出：返回匹配成功的字符串起始位置，失败返回-1
算法思路：
  int i=start,j=0;  //i代替起始位置，j代表匹配串当前匹配位置
  while 开始位置未到模式串尾，匹配串未结束
    //按检查顺序检查，匹配成功继续下一个
    //失败将模式串定位i移动对应位置
  返回成功与否信息  

/

#include
#include
#include
#define MaxSize 10000

typedef struct
{
  char data[MaxSize];
  int length;
}SqString;

//获取随机排序
void getScanOrder (int len,int ScanOrder[], int ScanOrdToUse[])
{
  int i,j;
  srand((unsigned)time(NULL));
  for (i=0; i
  {
    ScanOrder[i] = rand()%len;
    for (j=0; j
  {
   if (ScanOrder[i] == ScanOrder[j])
   {
    i--;break;
   }
  }
 }
 for (i=0; i
  ScanOrdToUse[ScanOrder[i]] = i;
}

//成功匹配位置检查
int checkSucc (int i, SqString p, int ScanOrdToUse[], int k)
{   
  while (i>=0)
  {
    if (ScanOrdToUse[i]-k>=0)
    {
      if (p.data[ScanOrdToUse[i]] == p.data[ScanOrdToUse[i]-k])
        i--;//对应位置相同，检查下一位置           
      else //对应位置不相同，成功位置检查失败，返回
        return 0;
    }   
    else
      i--;               
  }
  if (i==-1) //如果成功匹配全部检查成功，返回成功信息
    return 1; 
}

//获取ValueOfShift数组
void getValueOfShift (SqString p,int ValueOfShift[],int ScanOrder[],int ScanOrdToUse[])
{ 
  int j,k;   
  j=0;
  while (j
  {
    k=1;
    while (k < p.length)
    {     
      if (ScanOrdToUse[j]-k>=0)
      {
        if (p.data[ScanOrdToUse[j]]!=p.data[ScanOrdToUse[j]-k]) 
          if (!checkSucc(j-1,p,ScanOrdToUse,k)) k++;
          else break;       
        else
          k++;   
      }
      else
        if (!checkSucc(j-1,p,ScanOrdToUse,k)) k++;
        else break;           
    }
    ValueOfShift[ScanOrdToUse[j]] = k;   
    j++;
  }    
}

int SundayIndex (int start,SqString s,SqString p,int ScanOrdToUse[],int ScanOrder[],int ValueOfShift[])
{
  int i=start,j=0; 
  while (i
  {
    //按检查顺序检查，匹配成功继续下一个
    if (s.data[i+ScanOrdToUse[j]]==p.data[ScanOrdToUse[j]])
      j++;
    else //失败将模式串定位i移动对应位置
    {
      i = i+ValueOfShift[ScanOrdToUse[j]];j=0;
    }
  }
  if (j>=p.length)
    return i;
  else
    return -1;
}

int main ()
{
  char a[MaxSize];
  char b[MaxSize]; 
  SqString s,p;
  int i;
  int loac=0,start=0;
  int existIf = 0;
  int ValueOfShift[MaxSize],ScanOrdToUse[MaxSize],ScanOrder[MaxSize];
 
  gets(b);
  gets(a);
 
  for (i = 0; a[i] != '\0'; i++)
    s.data[i] = a[i];
  s.length = i;
 
  for (i = 0; b[i] != '\0'; i++)
    p.data[i] = b[i];
  p.length = i;

  getScanOrder (p.length,ScanOrder,ScanOrdToUse);
  getValueOfShift (p,ValueOfShift,ScanOrder,ScanOrdToUse);
 
  for (;;)
  {
    loac = SundayIndex (start,s,p,ScanOrdToUse,ScanOrder,ValueOfShift);
    if (loac==-1)
      break;
    else 
    {
      printf ("%d ",loac);
      existIf = 1;
      start = loac+1;
    }
  }
  if (existIf == 0)
    printf ("%d",-1);     
}