《数据结构》学习笔记（4）——串

最新推荐文章于 2022-03-13 19:47:57 发布
最新推荐文章于 2022-03-13 19:47:57 发布
阅读量428 收藏
点赞数
分类专栏： 数据结构 文章标签： 串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36904568/article/details/88593537
版权

一：基本概念

串是由零个或多个字符组成的有限序列，又名字符串。

串的长度n是一个有限的数值，零个字符的串称为空串，它的长度为零。

串的相邻字符之间具有前驱和后继的关系。

子串与主串：串中任意个数的连续字符组成的子序列称为该串的子串，相应地，包含子串的串称为主申。子串在主串中的位置就是子串的第一个字符在主串中的序号。

二：串的比较

  1. 比较组成串的字符的编码。
  2. 如果编码相同，则比较长度。‘

三：抽象数据类型

  • StrAssign ( T，* chars ) ：生成一个其值等于字符串常量chars的串T。
  • StrCopy(T，S)：串S存在，由串S复制得到T。
  • ClearString(S)：若S存在，将串清空。
  • StringEmpty ( S ):若串 S 为空，返回true,否则返回 false。
  • StrLength ( S )：返回串S的元素个教，即串的长度。
  • StrCompare(S,T)：若 S>T,返回值>0，若 S=T,返回 0,若 S<T,返回值<0。
  • Concat (T，S1，S2)：用T返回由S1和S2联接而成的新串。
  • SubString ( Sub, S, pos，len )：串 S 存在，1 <=pos<=StrLength ( S ), 且 0<=len<=StrLength ( S )-pos+1,用 Sub 返回串S的第pos个字符起长度为len的子串。
  • Index ( S,T,pos )：串S和T存在，T是非空串，1 <=pos<=StrLength ( S ) 。若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0。
  • Replace (S,T,V):串S、T和V存在，T是非空串。用V替换主串S中出现的所有与T相等的不重叠的子串。
  • StrInsert (S,pos,T) : 串S和T存在，1 <=pos<=StrLength ( S ) -len+1，在串S的第pos个字符之前插入串T。
  • StrDelete(S，pos, len):串 S 存在，1 <=pos<=StrLength ( S ) -len+1，从串S中删除第pos个字符起长度为len的子串。

四：存储结构

1. 顺序存储结构

（1）定义

用一组地址连续的存储单元来存储串中的字符序列的。按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区。一般是用定长数组来定义。

（2）属性
  • 预定义的最大串长度
  • 实际的串长度值

2. 链式存储结构

（1）定义

一个结点可以存放一个字符，也可以存放多个字符，最后一个结点若是未被占满时 ， 可以用其他字符补全

（2）特点
  • 连接串与串操作方便。
  • 没有顺序存储灵活，性能也不如顺序存储结构好。

3. 单词查找树

（1）定义

由链接的结点组成，链接可能指向空或其他结点，每个链接对应一个字符。每个结点都由父结点指向该结点，它包含了父节点表示的字符串前缀，每个结点有N个链接（N为字母表的大小）。

（2）属性
  • 预定义的串的字符个数
  • 包含键值对和指向各个字符链接的结点
（3）特点
  • 对于任意一组键，它的单词查找树是唯一的。
  • 查找树时访问数组最多为键的长度+1次
  • 查找未命中的成本与键的长度无关
  • 所需空间与键的长度和字母表的长度有关
/**
 * 单词查找树
 * @param <T>
 */
public class StringSearchTree<T>{

    private int R;

    private Alphabet alphabet;

    private StringTreeNode<T> root;

    public StringSearchTree() {
        alphabet = Alphabet.EXTENDED_ASCII;
        R = alphabet.R();
        root = new StringTreeNode<>(R);
    }

    public StringSearchTree(Alphabet alphabet) {
        this.alphabet = alphabet;
        R = alphabet.R();
        root = new StringTreeNode<>(R);
    }

    //获取键值
    public T get(String key){
        StringTreeNode<T> node = get(key,root,0);
        if (node == null)
            return null;
        return node.getValue();
    }

    private StringTreeNode<T> get(String key,StringTreeNode<T> node,int digit){
        //在串的范围内查找
        if (node == null)
            return null;
        if (digit == key.length())
            return node;
        int index = alphabet.toIndex(key.charAt(digit));
//        char x = alphabet.toChar(index);
        return  get(key,node.getNodes()[index],digit+1);//在对应的子树查找
    }

    //添加键值
    public void put(String key,T value){
        root = put(root,key,value,0);
    }

    private StringTreeNode put(StringTreeNode<T> node,String key,T value,int digit){
        if (node == null)
            node = new StringTreeNode<>(R);
        if (digit == key.length())
        {
            node.setValue(value);
            return node;
        }
        int index = alphabet.toIndex(key.charAt(digit));
//        char x = alphabet.toChar(index);
         node.getNodes()[index] = put (node.getNodes()[index],key,value,digit+1);
         return node;
    }

    public void delete(String key){
        root = delete(key,root,0);
    }

    public StringTreeNode<T> delete(String key,StringTreeNode<T> node,int digit){
        //找不到目标结点
        if (node == null)
            return null;
        //找到目标结点，将其删除，记得继续检查子节点
        if (digit == key.length())
            node.setValue(null);
        else
        {
            int index = alphabet.toIndex(key.charAt(digit));
//            char x = alphabet.toChar(index);
            node.getNodes()[index] = delete(key,node.getNodes()[index],digit+1);
        }
        //被删除结点之前的结点。。
        if (node.getValue() != null)
            return node;
        //检查被删除结点含有非空子结点
        for (int i = 0; i < R; i++) {
            if (node.getNodes()[i] != null)
                return node;
        }
        //如果子节点都是空的，就把这个结点也删除
        return null;
    }

    //所有键
    public Iterable<String> keys(){
        return keysWithPrefix("");
    }

    //匹配前缀的所有键
    public Iterable<String> keysWithPrefix(String prefix){
        //用队列保存
        LinkedQueue<String> queue = new LinkedQueue<>();
        //从前缀开始查找
        collect(get(prefix,root,0),prefix,queue);
        return queue;
    }

    //匹配通配符的所有键
    public Iterable<String> keysWithMatch(String pattern){
        //用队列保存
        LinkedQueue<String> queue = new LinkedQueue<>();
        //开始查找
        collect(root,"",pattern,queue);
        return queue;
    }

    //收集键
    private void collect(StringTreeNode<T> node,String prefix,LinkedQueue<String> queue){
        //如果没有此结点，直接结束
        if (node == null)
            return;
        //如果有这个结点，加入前缀
        if (node.getValue() != null)
            queue.enQueue(prefix);
        //从结点继续向下查找
        for (int i = 0; i < R; i++)
        {
            char c = alphabet.toChar(i);
            collect(node.getNodes()[i],prefix+c,queue);
        }
    }

    private void collect(StringTreeNode<T> node,String prefix,String pattern,LinkedQueue<String> queue){
        //如果没有此结点，直接结束
        if (node == null)
            return;
        int len = prefix.length();
        //到达长度，看看是否匹配
        if (len == pattern.length() && node.getValue() != null)
            queue.enQueue(prefix);
        //到达长度，结束
        if (len == pattern.length())
            return;
        char x = pattern.charAt(len);
        //从结点开始，根据通配符继续向下查找
        for (int i = 0; i < R; i++)
        {
            char c = alphabet.toChar(i);
            if (x == c || x == '.')
                collect(node.getNodes()[i],prefix+c,queue);
        }
    }

    //根据字符串找出最长前缀
    public String longestPrefix(String alphabet){
        int len = search(root,alphabet,0,0);
        return alphabet.substring(0,len);
    }

    private int search(StringTreeNode<T> node,String str,int digit,int len){
        //如果没有此结点，直接结束
        if (node == null)
            return len;
        //如果有这个结点，则加长
        if (node.getValue() != null)
            len = digit;
        if (digit == str.length())
            return len;
        return search(node.getNodes()[str.charAt(digit)],str,digit+1,len);
    }

    public void print(){
        for (String key:
             keys()) {
            System.out.printf("%s[%d] ",key,(Integer)get(key));
        }
    }
}

4. 三向单词查找树

（1）定义

每个结点含有一个字符，一个值，以及三个链接，指向小于、等于、大于结点字符的键

（2）属性
  • 预定义的串的单词组成个数
  • 包含键值对和三个链接的结点
（3）特点
  • 占用空间小
  • 比较次数较少
/**
 * 三向单词查找树
 * @param <T>
 */
public class ThreeStringTree<T> {

    private int R;

    private Alphabet alphabet;

    private ThreeStringTreeNode<T> root;

    public ThreeStringTree() {
        this.alphabet = Alphabet.EXTENDED_ASCII;
        this.R = alphabet.R();
    }

    public ThreeStringTree(Alphabet alphabet) {
        this.alphabet = alphabet;
        this.R = alphabet.R();
    }

    //获取键值
    public T get(String key){
        ThreeStringTreeNode<T> node = get(key,root,0);
        if (node == null)
            return null;
        return node.getValue();
    }

    public ThreeStringTreeNode<T> get(String key,ThreeStringTreeNode<T> node,int digit){
        if (key.length() == 0)
            return root;
        if (node == null)
            return null;
        int index = alphabet.toIndex(key.charAt(digit));
        //对三个子节点进行比较
        if (alphabet.toChar(index) < node.getKey())
            return get(key, node.getLeft(), digit);
        else if (alphabet.toChar(index) > node.getKey())
            return get(key, node.getRight(), digit);
        //如果是中间结点，看看是不是够长度了
        else if (digit < key.length() - 1)
            return get(key, node.getMid(), digit+1);
        else
            return node;
    }

    public void put(String key,T value){
        root = put(key,value,root,0);
    }

    public ThreeStringTreeNode<T> put(String key,T value,ThreeStringTreeNode<T> node,int digit){
        if (node == null)
            node =  new ThreeStringTreeNode<T>(key.charAt(digit));
        int index = alphabet.toIndex(key.charAt(digit));
        //对三个子节点进行比较
        if (alphabet.toChar(index) < node.getKey())
            node.setLeft(put(key,value, node.getLeft(), digit));
        else if (alphabet.toChar(index) > node.getKey())
            node.setRight(put(key,value, node.getRight(), digit));
            //如果是中间结点，看看是不是够长度了
        else if (digit < key.length() - 1)
            node.setMid(put(key,value, node.getMid(), digit+1));
        else
            node.setValue(value);
        return node;
    }


    //所有键
    public Iterable<String> keys(){
        return keysWithPrefix("");
    }


    //匹配前缀的所有键
    public Iterable<String> keysWithPrefix(String prefix){
        //用队列保存
        LinkedQueue<String> queue = new LinkedQueue<>();
        //从前缀开始查找
        collect(get(prefix,root,0),prefix,queue);
        return queue;
    }
    //匹配通配符的所有键
    public Iterable<String> keysWithMatch(String pattern){
        //用队列保存
        LinkedQueue<String> queue = new LinkedQueue<>();
        //开始查找
        collect(root,"",pattern,queue,0);
        return queue;
    }

    //收集键
    private void collect(ThreeStringTreeNode<T> node,String prefix,LinkedQueue<String> queue){
        //如果没有此结点，直接结束
        if (node == null)
            return;
        //从左到右遍历一次
        collect(node.getLeft(),prefix,queue);
        //如果有这个结点，加入前缀
        if (node.getValue() != null)
            queue.enQueue(prefix + node.getKey());
        //从结点继续向下查找
        collect(node.getMid(),prefix+node.getKey(),queue);
        collect(node.getRight(),prefix,queue);
    }

    private void collect(ThreeStringTreeNode<T> node,String prefix,String pattern,LinkedQueue<String> queue,int digit){
        //如果没有此结点，直接结束
        if (node == null)
            return;
        char x = pattern.charAt(digit);
        //从结点开始，根据通配符继从左到右查找
        char key = node.getKey();
        if (x < key || x == '.')
            collect(node.getLeft(),prefix,pattern,queue,digit);
        if (x == key || x == '.')
            //到达长度，看看是否匹配
        {
            if (digit == pattern.length() - 1 && node.getValue() != null)
                queue.enQueue(prefix + node.getKey());
            if (digit < pattern.length() - 1)
                collect(node.getMid(),prefix + node.getKey(),pattern,queue,digit + 1);
        }
        if (x > key || x == '.')
            collect(node.getRight(),prefix,pattern,queue,digit);
    }

    //根据字符串找出最长前缀
    public String longestPrefix(String alphabet){
        int len = search(root,alphabet,0,0);
        return alphabet.substring(0,len);
    }

    private int search(ThreeStringTreeNode<T> node,String str,int digit,int len){
        //如果没有此结点，直接结束
        if (node == null)
            return len;
        //如果有这个结点，则加长
        if (node.getValue() != null)
            len = digit + 1;
        if (digit == str.length())
            return len;

        char c = str.charAt(digit);
        char key = node.getKey();
        if (c < key)
            return search(node.getLeft(),str,digit,len);
        else if (c > key)
            return search(node.getRight(),str,digit,len);
        else
            return search(node.getMid(),str,digit+1,len);
    }

    public void print(){
        for (String key:
                keys()) {
            System.out.printf("%s[%d] ",key,(Integer)get(key));
        }
        System.out.println();
    }
}

五：匹配字符串

1. 模式匹配算法

对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。

  1. 用 i 表示主串下标，用 j 表示子串下标。
  2. 判断 i 和 j 是否在串的范围内
  3. 如果主串和子串的字母相等，则下标增加。
  4. 否则 i 退回原来的下一位， j 退回原位

2. KMP算法

（1）：定义

对于在子串中有重复的字符，可以省略一部分不必要的判断步骤。
i可以不用回溯，j可以回溯到合适的地方。

（2）：获取 next[j] 数组
  1. 获取字符串T从1到 j-1 中的子串S
  2. 如果S = 0，则next[j] = 0
  3. 如果S中没有相同的字符，则next[j] =1
  4. 如果S中前缀字符串与后缀字符串相同，则next[j] = 相同的字符个数+1
零号元素
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法课堂手写笔记
10-13
数据结构与算法课堂手写笔记整理，希望帮助到可以用到的人！
数据结构学习笔记——单链表
12-21
数据结构是计算机科学中至关重要的基础概念，它们用于有效地组织和管理数据，以便进行高效的存储、检索和操作。本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构...
数据结构之串
qq_61884165的博客
03-13 3155
串是一种数据元素受限的线性表，它的每个数据元素限定为仅由一个字符组成。因此，串是n个字符的有限序列。串的一些相关概念如下： 1.将串中所含字符的个数n称为串的长度。2.将不包含任何字符的串称为空串。3.将由一个或多个空格组成的串称为空格串，这点空串和空格串是有区别的。4.将串中任意哥连续字符组成的子序列称为该串的子串，将包含这个子串的串叫做主串。5.字符在串中的位置是指字符在字符序列中的位序，子串在主串中的位置是子串在主串中第一次出现时，其首字母在主串中的位置。6.当且仅当两个串的串值相等时，才称这两个串
数据结构：串
qq_45868793的博客
04-20 499
串（string） 是由零个或多个字符组成的有限序列，又名叫 字符串。 串 的逻辑结构和线性表很相似，不同之处在于串针对的是字符集，也就是串中的元素都是字符。因此，对于串的基本操作与线性表是有很大差别的。线性表更关注的是单个元素的操作，比如查找一个元素，插入或删除一个元素，但串中更多的是查找子串位置，得到指定位置子串，替换子串等操作。 串 的存储结构与线性表相同，分为两种： 串的顺序存储结构：串的...
数据结构——串
fazstyle的博客
04-27 1170
1、串的定义 串(string)是由零个或多个字符组成的有限序列，又名叫字符串。 一般记为s=“a1a2……an”(n>0)，其中，s是串的名称，用双引号(有些书中也用单引号)括起来的字符序列是串的值。注意双引号不属于串的内容。ai(1≤i≤n)可以是字母、数字或其他字符，i就是该字符在串中的位置。串中的字符数目n称为串的长度，定义中谈到"有限"是指n是一个有限数值。零个字符的串称为空串(n...
Python学习笔记7——数据清洗之多表合并
12-20
在Python中，最常用的数据处理库是Pandas，它提供了丰富的数据结构和函数，方便我们进行数据清洗与分析。因此，确保你已经安装了Pandas库，如果没有，可以通过以下命令安装： ```bash pip install pandas ``` 接...
数据结构学习笔记——使用draw.io绘制的树结构图
04-29
树结构 draw.io图 二叉树、顺序树、树的链式存储结构、树的数组存储结构、欧拉树 绘图软件为免费开源软件draw.io
Python学习笔记（七）——–Python数据结构
01-20
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 Python中的绝大部分数据结构可以最终分解成三种类型：集合（Set），序列（Sequence），映射（Mapping）。 1...
C语言学习笔记——小浪神
10-04
C语言学习笔记——小浪神 本笔记是关于C语言的学习笔记，涵盖了C语言的基本概念、历史发展、语言特点、数据类型、变量、常量、算法等方面的知识点。 计算机程序的概念 计算机程序是指一组能够被计算机识别和执行...
用v串替换s串中与t串相同的字串（定长顺序法）
05-31
用v串替换s串中与t串相同的字串（定长顺序法）
数据结构学习笔记
不疯魔不成活
06-04 501
　　这段时间开始复习数据结构，疯狂恶补相关知识，做了一些笔记。1、构造函数，是一种特殊的方法。主要用来在创建对象时初始化对象，即为对象成员变量赋初值，总与new运算符一起运用在创建对象的语句中。特别的事，一个类可以有多个构造函数，根据其参数个数的不同或参数类型的不同来区分它们，即构造函数的重载。2、cout&lt;&lt;endl ;中，endl表示的是输出流的一个manipulator，在输出后...
【数据结构】串的介绍
WINGREZ‘S BLOG
08-31 1799
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 串的介绍 基本概念 1、串：串是由零个或多个字符组成的有限序列，一般记为s='a1a2...an'（n≥0），其中...
数据结构中的字符串
huanhuan59的博客
12-05 2186
1.数据结构中提到的串，即字符串，由 n 个字符组成的一个整体（ n &gt;= 0 ）。这 n 个字符可以由字母、数字或者其他字符组成。 例如，S = ”BEIJING” ，S 代表这个串的串名，BEIJING 是串的值。双引号不是串的值，作用只是为了将串和其他结构区分开。 2.特殊的串 空串：含有零个字符的串。例如：S = “”（双引号中没有任何东西），一般直接用 Ø 表示。空格串：只包含...
数据结构——8.串
qq_51330164的博客
06-05 1098
数据结构 8.串 1.1串 从数据结构角度看，串也属于线性结构，具有线性结构的共同特征； 串的个性是：串中的元素是字符； 操作的对象往往不再是单个数据元素，而是一组数据元素 串（String）：由零个或多个字符组成的有限序列。记为： S=a0a1……an−1（n≥0） S=a_0a_1……a_{n-1} （n≥0）S=a0​a1​……an−1​（n≥0） 概念： 元素$ a_i$是字符，n为串的长度，n=0时是空串（Null String） 子串：串中任意连续个字符组成的子序列被称为该串的子串，包含子串的串
神奇少年的数据结构学习笔记四(串)
神奇少年的博客
09-17 227
串的定义：零个或多个字符组成的有限序列，又称字符串。 1.串的比较 比较字符串之间的ASCII码的大小， 比如s="happy",t="happen",因为前面4个字母相同，所以比较第五位的字母的ASCII码值， y的ASCII码值是121，e的ASCII码值是101,121>101所以串s>t. 英语词典就是按着这样排列的。 2.朴素的模式匹配算法 在一篇文章中找一个...
【数据结构——串】结构体定义和基本操作
qq_43506256的博客
12-09 876
（1）串的结构体定义 //定长顺序存储表示 typedef struct{ char str[maxSize+1]; //多出一个‘\0’作为结束标记 int length; }Str; //变长分配存储表示 typedef struct{ char *ch; //指向动态分配存储区首地址的字符指针 int length; }Str; （2）串的基本操作 //赋值操作 int fuzhi(Str &str, char *ch){ if(str.ch){ free(str.
串
qq_20916553的博客
03-19 122
select level from dual connect by level <=5; select regexp_count('ab,de,fg',',') from dual; select regexp_count('ab$cd$ef','\$') from dual; select length(regexp_replace('ab,de,fg','[^,]')) from dua...
NGN学习笔记1——NGN的基本概念和体系结构
最新发布
06-10
NGN，即下一代网络（Next Generation Network），是一种基于IP（Internet Protocol）的全新的通信网络架构，它的目的是将语音、数据和视频等各种通信服务集成到一个统一的网络中，提供更加高效、灵活、可靠、安全和经济的通信服务。 NGN的体系结构包括三个层次：应用层、服务层和传输层。 1. 应用层：提供各种通信应用服务，如语音、数据和视频等。 2. 服务层：提供各种通信服务，如呼叫控制、用户认证、计费等。 3. 传输层：提供基础的传输网络功能，如路由、转发和QoS（Quality of Service）等。 NGN的基本概念包括以下几个方面： 1. 灵活性：NGN能够支持各种不同的通信服务，并且能够根据用户的需求进行灵活配置和调整。 2. 可靠性：NGN采用了多种技术手段来提高网络的可靠性，如冗余备份、错误纠正和恢复等。 3. 安全性：NGN能够提供更加安全的通信服务，如加密、认证和防火墙等。 4. 经济性：NGN采用了一些新的技术和管理方式，能够降低网络建设和运营成本，提高网络的利润和效益。 总之，NGN是一种全新的通信网络架构，它具有很多优点和特点，能够提供更加高效、灵活、可靠、安全和经济的通信服务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值