数据结构 第四章 串、数组和广义表

概述：

串：字符串的简称，串是一种特殊的线性表，特殊在其数据元素都是一个字符。
数组和广义表可以看做是线性表的扩充，即线性表的数据元素自身又是一个数据结构。

串 String

本结主要讲述：串的存储结构和基本操作
定义：主要是有0个或多个字符组成的序列。
存储结构：顺序存储和链式存储，但是串一般使用顺序存储结构。

顺序存储

typedef struct {    char *ch;   //若为非空串，则按串长分配存储区，否则ch为null    int length;  //串长度}HString;

链式存储：

#define CHUNKSIZE 80;  //可有用户定义的块大小typedef struct Chunk{    char ch[CHUNKSIZE ];       struck Chunk *next;}Chunk;typedef struct {    Chunk *head,*tail;//串的头尾指针    int  curlen;   //串的当前长度}LString;

串的存储密度=串值所占的存储位/实际分配的存储位
密度小，运算处理才方便；

串的模式匹配算法
子串的定位运算通常称为串的模式匹配或串匹配。
应用场景：搜索引擎、拼音检查、语言翻译、数据压缩等。

eg：有两个字符串S-主串、T-子串（也称模式）；
著名的模式匹配算法有两种：BF和KMP算法：
1. BF算法：最简单直观的模式匹配算法，Brute-Force算法

int Indext(SString S,SString T,int pos){        int i=pos,j=1;  //i指向主串，j指向子串        while(S[0]>=i && j<=T[0]){            if(S[i] == T[j]){                ++i;                ++j;            }else{                i=i-j+2;                j=1;            }        }        if(j>T[0]){            return i-T[0];        }else{            return 0;        }}

主串长：N ，子串长：M
算法的时间复杂度：在最好的情况下（N+M)1/2即O(N+M），最坏的情况下：M(N-M+2)*1/2即O(N+M）；
BF思路直观简明，但是时间复杂度高为：O(N+M），

2.KMP算法：由Kunth Morris Pratt共同设计所以称为KMP算法；
特点：无需回溯主串的指针，当模式串与主串中存在许多“部分匹配”的情况下才显得比BF快，所以BF至今任然被采用。
时间复杂度：O（m+n）

int Indext_KMP(SString S,SString T,int pos){        //利用模式串T的next函数求T在主串S中第pos个字符之后的位置        //其中，T非空，1<=pos<=Strlength(S)        int i=pos,j=1;  //i指向主串，j指向子串        while(S[0]>=i && j<=T[0]){            if(j==0 || S[i] == T[j]){                ++i;                ++j;            }else{                j=next[j]; //模式串向右移动             }        }        if(j>T[0]){            return i-T[0];        }else{            return 0;        }}T的Next函数,算法时间复杂度为O(m)void get_next(SString T,int next[]){    int i = 1;    next[1] = 0 ;    int j = 0 ;    while(i<T[0]){        if(j == 0 || T[i] == T[j]){            ++i;            ++j;            next[i] = j;        }else{            j=next[j];        }    }}

J 1 2 3 4 5 6 7 8 模式串 a b a a b c a c next[j] 0 1 1 2 2 3 1 2

---

上面的next算法有缺陷，下面有修正版的：void get_nextval(SString T,int nextval[]){    int i = 1;    nextval[1] = 0 ;    int j = 0 ;    while(i<T[0]){        if(j == 0 || T[i] == T[j]){            ++i;            ++j;            if(T[i] != T[j]){                nextval[i] = j;            }else{                nextval[i] = nextval[j];            }        }else{            j=nextval[j];        }    }}

next函数修正值：

J 1 2 3 4 5 模式串 a a a a b next[j] 0 1 2 3 4 nextval[j] 0 0 0 0 4

数组

本结主要讲述：数组的内部实现和特殊的二维数组如何实现压缩存储。
定义：由类型相同的数据元素构成的有序集合。

一维数组可以看成线性表
二维数组是数据元素为线性表的线性表；
数组一般不做插入和删除操作，所以一般采用顺序存储结构。

二维数组有两种存储方式：列序为主序的存储方式，行序为主序的存储方式。
java、C、Basic、Pasical都是行序为主序的编程语言；
Fortran是以列序为主序的编程语言；

每个元素占L个存储单元，二维数组A[0~m-1,0~n-1]（A[m,n]）中任一元素aij的存储位置：
LOC（i,j）=LOC(0,0)+(n x i+j)L;

由于计算各个元素存储位置的时间相等，所以存取数组中任一元素的时间也相等，即数组是一种随机存取结构。

---

矩阵的压缩存储

矩阵用二维数组来表示是最自然的。
压缩存储:指为多个值相同的元只分配一个存储空间，对0元不分配空间；
特殊矩阵：对值相同的元素或0元素在矩阵中的分布有一定规律；
主要有三种特殊矩阵：对称矩阵、三角矩阵、对角矩阵
若n阶矩阵A中的元满足A_ij=A_ji，称为n阶对称矩阵。
–可将n²个元素压缩到n(n+1）/2个元的空间中。
设一维数组Sa[n(n+1)/2]作为矩阵A的存储结构，则sa[k]和矩阵元a_ij的关系：
k=i(i-1)/2+j-1 条件（i < j）
k=j(j-1)/2+i-1 条件（i > j）

---

广义表

本结主要讲述：广义表的概念和存储结构。
广义表是线性表的推广，也称为列表。
广泛的用于人工智能领域的表处理语言LISP语言。
记为：LS=（a₁,a₂,a₃,a₄…..a_n)

//广义表的头尾链表存储表示typedef enum{    ATOM,LIST}ElemTag;typedef struct GLNode{    ElemTag tag;       union{        AtomType atom;        struct{            struct GLNode *hp;            struct GLNode *tp;        }ptr;    };}*GList;