【数据结构】串，数组，广义表 | 笔记整理

文章目录

前言
一、串
二、数组
三、广义表
四、病毒案例

前言

参考视频：数据结构与算法基础（青岛大学-王卓）
KMP算法之求next数组代码讲解

一、串

回忆一下之前学习的线性结构元素都是一一对应的关系。

栈和队列是操作受限的线性表

字符串依然是线性结构

不过和前面学习的顺序表，栈，队列，有一个不一样的地方，就是限定了元素：只能是字符 ，而顺序表，栈，队列可以有其他元素。

插一句，广义表这些可以看成是线性表的推广，但是严格意义上已经不是线性表了。

1.1、串的定义

字符串的定义：零个或多个任意字符组成的有限序列

定义部分还有串名，串值，串长。串长为0时就是空串。

字串：串中任意个连续字符组成的子序列（包括空串）称为该串的字串

真子串：不包含自身的子串
注意，空串也是子串

主串：包含子串的串叫主串

字符位置：字符在序列中的序号 成为该字符在串中的位置

子串位置：子串第一个字符 在串中的位置

空格串：由一个或多个空格组成的串（与空串的概念不同哈）

来个PPT中的例题看看：（这里位置默认是从1开始 ）

注意最后一个小问PPT里写错了：应该是b在d中的位置是5

串相等：长度相等，且各个对应位置的字符都相同，才是相等
所有的空串都是相等的

1.2、案例引入

案例一：病毒是否出现（病毒相当于就是子串，检测是否在主串中出现）

患者1看起来好像没感染，是因为忽视了病毒是环状这个前提条件

baa还可以是aab aba 这样就能匹配上了

当然像我视力比较好的情况我一眼也看出来倒数两个字符和第一个字符组成了病毒串

这种案例引入的问题有：一个字符串是否在另外一个字符串中出现过？如果出现过，出现的位置在哪里？这就是字符串的匹配问题

1.3、串的类型定义和存储结构

字符串的数据关系依然是这种前驱后继 的关系：一对一 的关系

字符串依然有顺序存储结构和链式存储结构：（逻辑结构是线性结构）

字符串的顺序存储结构：

这里字符串和前面线性表不一样的地方是：线性表定义中的元素类型没有限定死，可以是其他类型的（比如int）

字符串的链式存储结构：

链式存储的存储密度是非常低 的，对于一个结点来说，一个字符占的是1个字节，指针占4个字节（32位系统），这样存储密度就是20%。

解决方案：可以把多个字符放到同一个结点中：

对于一个结点来说，一个字符占的是1个字节，图中是4个，就是4个字节，指针占4个字节（32位系统），这样存储密度就是50% 。通常称这些连在一起的字符叫做块。块中可以多放一些元素，这样存储密度就上去了。

字符串的链式存储结构常用块链结构 ：

实际情况里，字符串的顺序存储我们用得更多一些，字符串中的字符插入删除比较少，更多还是匹配操作等。后面的内容也是基本围绕着顺序存储结构来的。

1.4、串的模式匹配算法

算法：确定主串中所含有的子串（模式串）第一次出现的位置（定位）

应用举例：查找某个文章里是否出现关键字

有两种经典的算法：BF和KMP

1.4.1、BF算法

称为简单匹配法。思路是穷举法

算法思路：从正文串第一个字符开始依次和模式串进行匹配。

BF算法的图解如下所示：

BF算法的C++实现：

cpp 复制代码

int index_BF(SString Source,SString Target){//Source是主串，Target是子串
    int i,j=1;
    while(i<=Source.length&&j<=Target.length){
        if(Source.ch[i]==Target.ch[j]){//匹配成功，开始匹配下一个字符
            ++i;
            ++j;
        }
        else{//匹配失败，时空回溯
            i=i-j+2;//i-j+1+1(前面+1是因为字符串默认从1开始，没有0)
            j=1;//退回子串的原点
        }
    }
    if(j>=Target.length){
        return i-Target.length;
    }
    else{
        return 0;
    }
}

完整运行代码如下：

cpp 复制代码

#include<iostream>
#include<string.h>
using namespace std;
#define MAXLEN 255
typedef struct{
    char ch[MAXLEN+1];
    int length;
}SString;

int index_BF(SString Source,SString Target){//Source是主串，Target是子串
    int i,j=1;
    while(i<=Source.length&&j<=Target.length){
        if(Source.ch[i]==Target.ch[j]){//匹配成功，开始匹配下一个字符
            ++i;
            ++j;
        }
        else{//匹配失败，时空回溯
            i=i-j+2;//i-j+1+1(前面+1是因为字符串默认从1开始，没有0)
            j=1;//退回子串的原点
        }
    }
    if(j>=Target.length){
        return i-Target.length;
    }
    else{
        return 0;
    }
}

int main(){
    SString mainStr, subStr;
    int ret;
    // 初始化主串
    cout << "请输入主串：";
    cin >> (mainStr.ch + 1);  // 从位置1开始存储
    mainStr.length = strlen(mainStr.ch + 1);

    // 初始化子串
    cout << "请输入子串：";
    cin >> (subStr.ch + 1);  // 从位置1开始存储
    subStr.length = strlen(subStr.ch + 1);
    
    ret=index_BF(mainStr,subStr);
    if(ret==0){
        cout<<"字符串匹配失败！"<<endl;
    }
    else{
        cout<<"字符串匹配成功，字符开始的位置是："<<ret<<endl;
    }
}

注意，我们这里cin >> (mainStr.ch + 1); 是从位置1开始存储，而不是位置0

我们试验一下：

BF算法的时间复杂度：

最好情况下是比较m次（第一次比较就找到了）,为O（m）

最坏情况下是比较了（n-m+1）*m次（找到最后一组再找到，甚至没找到）,O（mn）

时间复杂度平均下来就是O（mn）/2,依然是O（mn）

1.4.2、KMP算法

KMP算法的核心就是i和j的回溯方式不同:

1)主串的指针i不需要回溯

2)模式串的指针j回溯有一套自己的规则：查看next[j]数组：next数组也就是模式串与主串"失配"时，模式串中重新和主串开始比较的初始位置。

这样能提速到O（m+n）

而里面最难的就是如何找j应该回到哪个位置，也就是求next[j]数组，以下是求它的规则：

这里的第一条规则很难懂，我也看不懂，我写了两条笔记如下，比较形象：

然后是实现KMP函数的C++代码：

cpp 复制代码

void get_next(SString Target,int next[]){
    int i=1;
    int j=0;
    next[1]=0;
    while(i<=Target.length){
        if(j==0||Target.ch[i]==Target.ch[j]){
            ++i;
            ++j;
            next[i]=j;
        }
        else{
            j=next[j];
        }  
    }
}
int KMP(SString Source,SString Target,int next[]){//Source是主串，Target是子串
    int i=1;
    int j=1;
    while(i<=Source.length&&j<=Target.length){
        if(j==0||Source.ch[i]==Target.ch[j]){//匹配成功，开始匹配下一个字符
            ++i;
            ++j;
        }
        else{//匹配失败，查看next[j]数组进行回溯,i不用回溯
            j=next[j];//退回子串的原点
        }
    }
    if(j>=Target.length){
        return i-Target.length;
    }
    else{
        return 0;
    }
}

然而这里的求next数组的函数其实非常难去理解。

实现的完整代码：

cpp 复制代码

#include<iostream>
#include<string.h>
using namespace std;
#define MAXLEN 255
typedef struct{
    char ch[MAXLEN+1];
    int length;
}SString;
void get_next(SString Target,int next[]){
    int i=1;
    int j=0;
    next[1]=0;
    while(i<=Target.length){
        if(j==0||Target.ch[i]==Target.ch[j]){
            ++i;
            ++j;
            next[i]=j;
        }
        else{
            j=next[j];
        }  
    }
}
int KMP(SString Source,SString Target,int next[]){//Source是主串，Target是子串
    int i=1;
    int j=1;
    while(i<=Source.length&&j<=Target.length){
        if(j==0||Source.ch[i]==Target.ch[j]){//匹配成功，开始匹配下一个字符
            ++i;
            ++j;
        }
        else{//匹配失败，查看next[j]数组进行回溯,i不用回溯
            j=next[j];//退回子串的原点
        }
    }
    if(j>=Target.length){
        return i-Target.length;
    }
    else{
        return 0;
    }
}

int main(){
    SString mainStr, subStr;
    int ret;
    int next[1024];
    // 初始化主串
    cout << "请输入主串：";
    cin >> (mainStr.ch + 1);  // 从位置1开始存储
    mainStr.length = strlen(mainStr.ch + 1);

    // 初始化子串
    cout << "请输入子串：";
    cin >> (subStr.ch + 1);  // 从位置1开始存储
    subStr.length = strlen(subStr.ch + 1);
    get_next(subStr,next);
    ret=KMP(mainStr,subStr,next);
    if(ret==0){
        cout<<"字符串匹配失败！"<<endl;
    }
    else{
        cout<<"字符串匹配成功，字符开始的位置是："<<ret<<endl;
    }
}

二、数组

2.1、数组的定义

数组定义：按照一定格式排列起来的，具有相同类型的数据元素的集合

一位数组的定义 ：若线性表中的数据元素为非结构的简单元素，则为一维数组。

一维数组的逻辑结构：线性结构，定长的线性表

二维数组既可以看作非线性结构 也可以看作线性结构 ：

1）线性结构:二维数组中的每一个元素都可以看作是定长的线性表

2）非线性结构：二维数组中的每一个元素既在一个行表中也在一个列表中（不止有一个前驱和一个后继 ：从行看，有一个前驱后继，从列看，也有一个前驱后继，这就不是一对一的关系了）：

我们可以把数组看成是一种特殊的线性结构，是线性结构的扩展。
二维数组的几种定义方式： （有一种是套娃，先定义列再定义行）

关于三维和更高维度：

三维数组：二维数组中的元素又是一个一维数组，那么这就叫做三维数组。

n维数组：n-1维数组中的元素又是一个一维数组，那么这就叫做n维数组。

数组和线性表的关系：

线性表结构是数组结构的一个特例，数组结构是线性表结构的扩展。

数组特点：

结构是固定的，定义之后，维数和维界（每一维的长度是多少）不会再改变

数组操作：

数组结构是固定的，所以一般没有插入和删除的操作。一般只有初始化，销毁，修改元素等操作。

2.2、数组的抽象数据类型定义

代码如下（示例）：

c 复制代码

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context