《数据结构》_PTA_数据结构作业4：串、数组和广义表

判断题

1-1
假设模式串是abababaab，则KMP模式匹配算法中的next[j] = 0 1 1 2 3 4 5 6 2
T

1-2
KMP算法的最大特点是指示主串的指针无须回溯
T

1-3
空串与空格串是相同的.
F

1-4
KMP算法的特点是在模式匹配时指示主串的指针不会变小回溯。
T

1-5
数组可以应用顺序式存储结构，也可以应用链式存储结构
T

选择题

2-1
设主串 T = abaabaabcabaabc，模式串 S = abaabc，采用 KMP 算法进行模式匹配，到匹配成功时为止，在匹配过程中进行的单个字符间的比较次数是：（10）

2-2
如下陈述中正确的是（串是一种特殊的线性表）

2-3
串是一种特殊的线性表，其特殊性体现在（数据元素是一个字符）

2-4
设有两个串p和q，求q在p中首次出现的位置的运算称为（模式匹配）

2-5
串的长度是指( 串中所含字符的个数)。

2-6
设广义表L=（（a,b,c）），则L的长度和深度分别为（1和2 ）

2-7
广义表((a,b,c,d))的表头、表尾是（表头：(a,b,c,d) 表尾：( ) ）。

2-8
对n阶对称矩阵压缩存储时，需要表长为（　n(n+1)/2 ）的顺序表。

2-9
有一个n×n的对称矩阵A，将其下三角部分按行存放在一维数组B中，而A[0][0]存放于B[0]中，则第i行的对角元素A[i][i]存放于B中的（(i+3)i/2　）处。

2-10
二维数组 A 的每个元素是由 10 个字符组成的串，其行下标 i=0,1,…,8，列下标 j=1,2,…,10。若 A 按行序优先存储，元素 A[8,5] 的起始地址与当 A 按列序优先存储时的元素（A[3,10] ）的起始地址相同。设每个字符占一个字节。

2-11
对于 C 语言的二维数组 int A[m][n]，每个元素占 2 个字节，数组中元素 a[i,j]的存储位置可由( Loc[i, j]=Loc[0, 0]+ (n×i+j)×2)式确定。

2-12
数组 A[0…5, 0…6] 的每个元素占 5 个字节，将其按列优先次序存储在起始地址为 1000 的内存单元中，则元素 A[5, 5] 的地址是(1175 )。

2-13
广义表 ((a,b,c,d)) 的表头是（ ( a,b,c,d )）

2-14
广义表((a,b,c,d))的表尾是（ ( ) ）。

2-15
设广义表 L=((a,b,c))，则 L 的长度和深度分别为（1和2 ）。

2-16
对矩阵进行压缩存储是为了（减少存储空间）。

2-17
稀疏矩阵一般的压缩存储方式有两种，即（三元组和十字链表）。

2-18
数组A中，每个元素的长度为3个字节，行下标i从1到8，列下标j从1到10，从首地址SA开始连续存放的存储器内，该数组按列存放，元素A[5][8]的起始地址为( SA＋180)

2-19
设二维数组A[1… m,1… n]按行存储在数组B中，则二维数组元素A[i,j]在一维数组B[1…m*n]中的下标为 (n(i-1)+j-1* )。

数组下标还是从0开始，只是数组A和数组B的元素个数是m*n，

2-20
设有一个10阶的对称矩阵A，采用压缩存储方式，以行序为主存储，a1，1为第一个元素，其存储地址为1，每个元素占1个地址空间，则a8，5的地址为( 33 )。

2-21
带行表的三元组表是稀疏矩阵的一种(顺序存储结构 )

2-22
表头和表尾均为空表的广义表是( (()) )

2-23
如果最常用的操作是取第i个结点及前驱，最节省时间的存储方式是（顺序表）。

2-24
稀疏矩阵在计算机中通常采用（三元组线性表）来表示。

2-25
广义表是一种（递归的）数据结构

2-26
广义表与稀疏矩阵都是线性表的扩展，它们的共同点为（数据元素本身是一个数据结构）

填空题

3-1
若串S=‘software’，其子串的数目是（37）

3-2
根据KMP算法，模式串p="abaabcac"各字符对应的失配值分别是（-1；0；0；1；1；2；0；1）

3-3
设目标串text=“abccdcdccbaa”，模式串pattern=“cdcc”，若采用BF（Brute Force）算法，则在第（6）趟匹配成功。

3-4
若n为主串长度，m为模式串长度，采用BF（Brute Force）模式匹配算法，在最好情况下需要的字符比较次数为（m）

3-5
若n为主串长度，m为模式串长度，采用BF（Brute Force）模式匹配算法，在最坏情况下需要的字符比较次数为（*(n-m+1)m）

3-6
设二维数组a[10][20]，每个数组元素占用1个存储单元，若按列优先顺序存放数组元素，a[0][0]的存储地址为200，则a[6][2]的存储地址是（226）

3-7
有一个100×90的稀疏矩阵，非0元素有10，设每个整型数占2个字节，则用三元组表示该矩阵时，所需的字节数是（66）

程序填空题

下面函数StrConcat1(char s1[],char s2[],char s[])实现了定长顺序串连接算法，即 把两个串s1和s2首尾连接成一个新串s算法。请填空。 顺序串类型说明：

#define MAXSIZE 1024
typedef struct
{
	char data[MAXSIZE]; /*串尾存储 \0作为终结符*/
	int curlen;
} SeqString;
int StrConcat1(char s1[], char s2[], char s[])
{
	int i = 0, j, len1, len2;
	len1 = StrLength(s1);
	len2 = StrLength(s2)
		if (len1 + len2 > MAXSIZE - 1) return 0;
	j = 0;
	while (@@ s1[j] != '\0' @@ )
	{
		@@ s[i] = s1[j] @@;
		i++; j++;
	}
	j = 0;
	while (s2[j] != '\0')
	{
		@@s[i] = s2[j]@@;
		i++; j++;
	}
	@@s[i] = '\0'@@;
	return 1;
}

KMP算法。

#include
#include
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
#define MAXSTRLEN 255

void get_nextval(char T[], int nextval[])
{
	int i = 1, j = 0;
	nextval[1] = 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];
}

int Index_KMP(char S[], char T[], int pos, int next[])
{
	int i = pos, j = 1;
	while (i <= S[0] && 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;
}

int main()
{
	char S[MAXSTRLEN + 1], T[MAXSTRLEN + 1];
	char S1[MAXSTRLEN], S2[MAXSTRLEN];
	cin >> S1 >> S2;
	strcpy(&S[1], S1);
	strcpy(&T[1], S2);
	S[0] = strlen(S1);
	T[0] = strlen(S2);
	int* p = new int[T[0] + 1];
	get_nextval(T, p);
	cout < return 0;
}

朴素的模式匹配算法

/***字符串匹配算法***/
#include<cstring>
#include<iostream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
#define MAXSTRLEN 255           //用户可在255以内定义最长串长
typedef char SString[MAXSTRLEN+1];        //0号单元存放串的长度

//BF算法
int Index(SString S, SString T, int pos)
{
    int i = pos;
    int j = 1;
    while (@@i <= S[0]&&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;
    return 0;
}

int main()
{
   char str1[MAXSTRLEN+1],str2[MAXSTRLEN+1];
    cin>>str1>>str2;
    SString S,T;
    strcpy(&S[1],str1);
    strcpy(&T[1],str2);
    S[0]=strlen(str1);
    T[0]=strlen(str2);
    cout<<Index(S,T,1);
        return 0;
}