数据结构笔记7-数组和字符串

字符串     子串：串中任意个连续的字符组成的子序列。 主串：包含子串的串。 子串的位置：子串的第一个字符在主串中的序号。  串的存储结构   顺序串：用数组来存储串中的字符序列。链接串：用链接存储结构来存储串。                                                             模式匹配：
        给定主串S="s1s2…sn"和模式T="t1t2…tm"，
在S中寻找T 的过程称为模式匹配。给定主串S="s1s2…sn"和模式T="t1t2…tm"， 在S中寻找T 的过程称为模式匹配。 如果匹配成功，返回T 在S中的位置，如果匹配失败，返回-1。假设串采用顺序存储结构，串值从0号单元开始存放 。                                        基本思想： 从主串S的第0个字符开始和模式T 的第0个字符进行比较，     若相等，则继续比较两者的后续字符；     否则，从主串S的第1个字符开始和模式T 的第0个字符进行比较，     重复上述过程，直到T 中的字符全部比较完毕，则说明本趟匹配成功；或S中字符全部比较完，则说明匹配失败。                             算法：1. 在串S和串T中设比较的起始下标i和j； 2. 循环直到S或T的所有字符均比较完；     2.1 如果S[i]==T[j]，继续比较S和T的下一个字符；     2.2 否则，将i和j回溯(i=i-j+1,j=0)，准备下一趟比较； 3. 如果T中所有字符均比较完，则匹配成功，返回匹配的起始比较下标(i-j)；否则，匹配失败，返回-1；

int BF(char S[ ], char T[ ])
{
     i=0; j=0;   
    while (i<S.Length（）&&j<T.length())
    {
         if (S[i]==T[j]) {
             i++;   j++;
         }  
         else {
             i=i-j+1;    j=0;
         }   
     }
     if (j>=T.length())  return (i-j);   
     else return -1;
}

                                                                            ①    -1，当j＝0时 ， //不比较
KMP算法：          令k = next[ j ]，则：next[ j ]＝②     max { k  | 0<k<j   且T0…Tk-1=Tj-(k-1) …Tj-1 }                                                                                                                          ③     0       其他情况                                                                                                   next[j]表征着模式T中最大相同前缀子串和左子串（真子串）的长度。      k=next[j-1]; while((k!=-1)&&(t[k]!=t[j-1]))       k=next[k]; next[j]=++k;           next[j]的算法分析: k=next[j-1](由next[]的 定义可以知道：t0t1…tk-1= tj-k…tj-3tj-2) 1. 如果t[k]==t[j-1]或k==-1（不存在长度相同的前缀子串和左子串 ）     则t0t1…tk-1tk= tj-k…tj-3tj-2tj-1，因此     next[j]=k+1，next[j]计算结束 否则， 查找t0t1…tk的最长左子串        k=next[k]，转 1 继续执行  ，否则， 查找t0t1…tk的最长左子串        k=next[k]，转 1 继续执行。

void Compute_Next(char t[], int next[])
{
    int j,k;
      next[0]=-1;j=1;
    while(t[j]!='\0')
    {
        k=next[j-1];
        while((k!=-1)&&(t[k]!=t[j-1]))
            k=next[k];
        next[j]=++k;
        j++;
    }
}

1.在串S和串T中分别设比较的起始下标i和j；
2. 循环直到S中所剩字符长度小于T的长度或T中所有字符均比较完毕
     2.1 如果S[i]==T[j]，继续比较S和T的下一个字符；否则
     2.2 将j向右滑动到next[j]位置，即j=next[j]；
     2.3 如果j=-1，则将i和j分别加1，准备下一趟比较；
 3. 如果T中所有字符均比较完毕，则返回匹配的起始下标；否则返回-1；

int KMP_FindPat(char *s, char *t,int *next){
    int i=0,j=0,k;
    while(s[i]!='\0' && t[j]!='\0')    {
        if(j==-1 || s[i]==t[j])    {
                 i++;
                 j++;
           }
        else
              j=next[j];
    }
    if(t[j]=='\0')
        return i-j;
    else
        return -1;
}

数组：数组是由一组类型相同的数据元素构成的有序集合，每个元素受n(n≥1)个线性关系的约束，并称该数组为 n 维数组。            元素本身可以具有某种结构，属于同一数据类型； 数组是一个具有固定格式和数量的数据集合。
 数组的存储结构与寻址--一维数组:设一维数组的下标的范围为闭区间［l，h］，每个数组元素占用 c 个存储单元，则其任一元素 ai 的存储地址可由下式确定： Loc(ai)＝Loc(al)＋(i－l)×c                        aij前面的元素个数 =整行数×每行元素个数+本行中aij前面的元素个数 =(i -l1)×(h2 -l2＋1)＋(j -l2)             Loc(aij)＝Loc(al1l2)＋((i－l1)×(h2－l2＋1)＋(j－l2))×c                                              各维元素个数为  m1, m2, m3, …, mn  下标为 i1, i2, i3, …, in 的数组元素的存储地址：                                                                            LOC ( i1, i2, …, in ) = a +   ( i1*m2*m3*…*mn + i2*m3*m4*…*mn+   + ……+ in-1*mn + in ) * l

 矩阵的压缩存储                 特殊矩阵的压缩存储——对称矩阵,aij在一维数组中的序号 = i×(i-1)/2+ j ,∵一维数组下标从0开始 ,∴aij在一维数组中的下标  , k= i×(i-1)/2+ j-1              aij在一维数组中的序号 = i×(i+1)/2+ j+1    ∵一维数组下标从0开始   ∴aij在一维数组中的下标 k= i×(i+1)/2+ j           对于下三角中的元素aij(i≥j), 在一维数组中的下标k与i、j的关系为： k＝i×(i-1)/2＋j-1 。 上三角中的元素aij（i＜j），因为aij＝aji，则访问和它对应的元素aji即可，即： k＝j×(j-1)/2＋i -1。

对角矩阵（带状矩阵）的压缩存储:以行序为主序， aij在一维数组中的地址k？ k=(3*(i-1)-1)+(j-i+1) k=2i+j-3