数据结构-串

最新推荐文章于 2024-07-24 20:25:39 发布
最新推荐文章于 2024-07-24 20:25:39 发布
阅读量246 收藏
点赞数 2
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LWJLWJ_/article/details/125113808
版权

一、串

1.1串的基本概念

串是字符串的简称。它是一种在元素的。组成上具有一定约束条件的线性表，既要求组成线性表的所有元素都是字符。

二、 常用函数

  • String(); //无参构造

  • String(const char *str); //构造函数

  • String(const String &S); //拷贝构造

  • bool operator==(const String &str1) const; //重载==，用判断两个串是否相等

  • String &operator+(const String &str1); //重载+，用于合并俩个串

  • friend ostream &operator<<(ostream &cout, String &str1); //重载<<，用于输入串

  • friend istream &operator>>(istream &cin, String &str1); //重载<<，用于输入串

  • String &operator=(const String &str1); //重载=，把一个串的赋值

  • inline char &operator[](size_t index) const; //重载[]，通过下标运算取出字符

  • void resize(const int num); //扩大容量,默认空间*2

  • size_t capacity() const { return this->maxSize; } //返回串容量

  • size_t size() const { return strLength; } //求串的长度

  • bool empty() const { return strLength == 0; } //判空

  • int compare(const String &str1) const; //比较当前串和串s的大小

  • String subStr(int pos, int num) const; //从pos位置开始取长度为num的子串

三、代码实现

String.h

/**
 * @Author: lwj
 * @Date: 2022-06-01 15:54:01
 * @Description:实现串的基本功能
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/String/string.h
 **/

#include <iostream>
#include <cstring>
#include <assert.h>
using namespace std;
class String
{
private:
    char *data;    //存储串
    int maxSize;   //最大容量
    int strLength; //记录串的长度
public:
    String();                                                //无参构造
    String(const char *str);                                 //构造函数
    String(const String &S);                                 //拷贝构造
    ~String() { delete[] data; }                             //析构函数
    bool operator==(const String &str1) const;               //重载==，用判断两个串是否相等
    String &operator+(const String &str1);                   //重载+，用于合并俩个串
    friend ostream &operator<<(ostream &cout, String &str1); //重载<<，用于输入串
    friend istream &operator>>(istream &cin, String &str1);  //重载<<，用于输入串
    String &operator=(const String &str1);                   //重载=，把一个串的赋值
    inline char &operator[](size_t index) const;             //重载[]，通过下标运算取出字符
    void resize(const int num);                              //扩大容量,默认空间*2
    size_t capacity() const { return this->maxSize; }        //返回串容量
    size_t size() const { return strLength; }                //求串的长度
    bool empty() const { return strLength == 0; }            //判空
    int compare(const String &str1) const;                   //比较当前串和串s的大小
    String subStr(int pos, int num) const;                   //从pos位置开始取长度为num的子串
    int bfFind(const String &s) const;                       //朴素的模式匹配算法
    String &insert(int pos, const String &s);                //在pos位置插入子串s
    String &eraser(int pos, int num);                        //删除从pos位置开始的num个字符
    const char *getData() const { return data; };            //获取字符数组data
};
String::String()
{
    data = new char[0]; //创建一个空的空间
    maxSize = 0;
    strLength = 0;
}
String::String(const char *str)
{
    maxSize = 2 * strlen(str);    //设置容量
    data = new char[maxSize + 1]; //开辟空间,+1是为了存储‘\0’,在String中不算是字符
    strLength = strlen(str);      //计算串长度
    strcpy(data, str);            //把str拷贝到data中
}
void String::resize(const int num)
{
    char *tmp = nullptr;
    tmp = new char[num];
    strncpy(tmp, data, this->strLength);
    delete[] data;
    data = tmp;
    maxSize = num;
    tmp = nullptr;
}
bool String::operator==(const String &str1) const //重载==，用判断两个串是否相等
{
    if (this->strLength != str1.strLength)
    {
        return false;
    }
    return strcmp(data, str1.data) ? false : true;
}
String &String::operator+(const String &str1) //重载+，用于合并俩个串
{
    // assert((str1.strLength + strLength) < maxSize);
    if ((str1.strLength + strLength) > maxSize)
    {
        resize(str1.strLength + strLength);
    }
    strcat(data, str1.data);
    strLength += str1.strLength;
    return *this;
}
ostream &operator<<(ostream &cout, String &str1) //重载<<，用于输入串
{
    cout << str1.data;
    return cout;
}
istream &operator>>(istream &cin, String &str1) //重载<<，用于输入串
{
    char *tmp = new char[10000]; //申请一个临时空间
    cin >> tmp;
    str1.maxSize = 2 * strlen(tmp);         //为str1重新规定容量大小
    str1.data = new char[str1.maxSize + 1]; //+1是为了放‘\0’
    strcpy(str1.data, tmp);
    str1.strLength = strlen(tmp);
    delete[] tmp;
    return cin;
}
String &String::operator=(const String &str1) //重载=，把一个串的赋值
{
    if (str1.data == data)
    {
        return *this; //如果两个相等，直接返回自己
    }
    delete[] data;
    maxSize = str1.maxSize;
    data = new char[maxSize + 1];
    strcpy(data, str1.data);
    strLength = str1.strLength;
    return *this;
}
inline char &String::operator[](size_t index) const //重载[]，通过下标运算取出字符
{
    assert(index >= 0 && index < maxSize);
    return data[index];
}
int String::compare(const String &str1) const //比较当前串和串s的大小
{
    int i = 0;
    while (data[i] == str1.data[i] && data[i] && str1.data[i])
    {
        ++i;
    }
    return data[i] - str1.data[i]; //如果相等返回0，小于返回小于0的数，大于返回大于0的数
}
int String::bfFind(const String &s) const //朴素的模式匹配算法,找到串s，返回第一次出现的下标，没有返回-1
{
    if (s.strLength > strLength)
    {
        return -1;
    }
    int i = 0; //主串指针
    int j = 0; //子串指针
    while (i < strLength && j < s.strLength)
    {
        if (data[i++] == s.data[j++]) //相等的话下一个
        {
            // i++;
            // j++;
        }
        else //不相等的话，指针回溯
        {
            i = i - j + 1; //主串，i-j能知道，主串比较到哪个位置了，加+1就是下一个
            j = 0;         //子串
        }
    }

    if (s.strLength <= j)
    {
        return i - s.strLength;
    }
    else
    {
        return -1;
    }
}

String String::subStr(int pos, int num) const //从pos位置开始取长度为num的子串
{
    assert(pos >= 0 && pos < strLength);
    assert(num >= 0 && num <= strLength);
    String tmp;
    int i;
    if (strLength - pos < num)
    {
        num = strLength - pos;
    }
    delete[] tmp.data;
    tmp.maxSize = tmp.strLength = num;
    tmp.data = new char[num + 1];
    for (i = 0; i < num; i++)
    {
        tmp.data[i] = data[pos + i];
    }
    tmp.data[i] = '\0'; //记得在子串后面加
    return tmp;
}
String &String::insert(int pos, const String &s) //在pos位置插入子串s
{
    assert(pos >= 0 && pos < strLength);
    if (strLength + s.strLength > maxSize) //空间不够的话扩容
    {
        resize(strLength + s.strLength);
    }
    for (int i = strLength; i >= pos; i--) // data[strLength]为‘\0’,记得也后移
    {
        data[i + s.strLength] = data[i];
    }
    for (int j = 0; j < s.strLength; j++)
    {
        data[pos + j] = s.data[j];
    }
    strLength += s.strLength;
    return *this;
}
String &String::eraser(int pos, int num) //删除从pos位置开始的num个字符
{
    assert(pos >= 0 && pos < strLength);
    if (strLength - pos <= num)
    {
        data[pos] = '\0';
        strLength -= num;
    }
    for (int i = 0; i < strLength - pos; i++)
    {
        data[pos + i] = data[pos + num + i];
    }
    strLength -= num;
}

main.cpp

/**
 * @Author: lwj
 * @Date: 2022-06-01 15:54:31
 * @Description:测试串的功能
 * @FilePath: /Linux_C_C-plus-plus/数据结构（C++）/String/main.cpp
 **/
#include "String.h"

#include <iostream>
using namespace std;

//测试构造函数功能
void test01()
{
    //测试无参构造
    String a1;
    cout << "s1:maxSize = " << a1.capacity() << endl;
    //测试有参构造
    String a2("lwj");
    cout << "s2:maxSize = " << a2.capacity() << endl;
}
//测试重载函数
void test02()
{
    //重载==，用判断两个串是否相等
    String b1("abc");
    String b2("abcd");
    if (b1 == b2)
    {
        cout << "相等\n";
    }
    else
    {
        cout << "不相等\n";
    }

    //重载<<，用于输入串
    cout << "b1 = " << b1 << endl;
    cout << "b2 = " << b2 << endl;

    //重载>>，用于输出串
    String b3;
    cout << "请输入一个字符串> ";
    cin >> b3;
    cout << "输入的字符串为：" << b3 << endl;

    //重载[],重载=
    String s4("aaa");
    String s5("bbb");
    String s6;
    s6 = s4 + s5;
    cout << "s4 + s5 = " << s6 << endl;

    //重载[]，通过下标运算取出字符
    cout << "s4 = " << s4 << endl;
    cout << "s4[0] = " << s4[0] << endl;
    cout << "s4[5] = " << s4[5] << endl;
}

//
void test03()
{
    //测试扩容
    String s1("lwj");
    cout << "未扩容前s1的maxSize为：" << s1.capacity() << endl;
    s1.resize(9);
    cout << "扩容后s1的maxSize为：" << s1.capacity() << endl;

    //判断两个串是否相等
    // String s2("lww");
    // String s3("lww");
    String s2;
    String s3;
    String s4("lwj");
    s2 = s3 = "lwjddk";
    int b = s2.compare(s3);
    int c = s2.compare(s4);
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
}
//子串操作测试
void test04()
{
    //从pos位置开始取长度为num的子串
    String c1 = "hello";
    String c2 = c1.subStr(0, 2);
    String c3 = c1.subStr(1, 2);
    // String c4 = c1.subStr(9, 9);
    cout << "c2 = " << c2 << endl;
    cout << "c3 = " << c3 << endl;
    // cout << "c4 = " << c4 << endl;

    在pos位置插入子串s
    String d1("lllll");
    String d2("ddd");
    d1.insert(2, d2);
    cout << "d1 = " << d1 << endl;
    d1.insert(7, d2);
    cout << "d1 = " << d1 << endl;

    删除从pos位置开始的num个字符
    d1.eraser(7, 3);
    cout << "d1 = " << d1 << endl;
    d1.eraser(0, 2);
    cout << "d1 = " << d1 << endl;
    d1.eraser(3, 3);
    cout << "d1 = " << d1 << endl;
}
void test05()
{
    //朴素的模式匹配算法
    String s1 = "lwjlwjlwjlllwef";
    String s2 = "lwe";
    int index = s1.bfFind(s2);
    cout << "index = " << index << endl;
    index = s1.bfFind("ef");
    cout << "index = " << index << endl;
    
}
int main()
{
    // test01();
    // test02();
    // test03();
    // test04();
    test05();
    return 0;
}
千里狼～
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
数据结构笔记（四）——串Ⅰ：string类常用函数
weixin_43279709的博客
03-15 422
一般地，由n个字符构成的串记作：S="a0a1...an−1"S = "a_0 a_1...a_{n-1} "S="a0​a1​...an−1​"，其中0≤i≤n0\leq i \leq n0≤i≤n。 ·空串：长度为0，与只包含空格的串不同。 ·子串：串中任意个连续字符组成的子序列。 ·前缀：起始于位置0，长度为k的子串。 ·后缀：终止于位置n-1，长度为k的子串。 ·字符串除本身之外的所有...
数据结构——串
FREEDOM’s blog
07-08 4723
串的定义、基本操作、存储结构、模式匹配（朴素模式匹配算法、KMP算法）
常用数据结构的常用函数总结（leetcode）
希希雾里
03-20 1269
数组、字符串、哈希表、链表、栈与队列。常用函数（leetcode）
数据结构----串（基本操作函数）
Big_xbc的博客
04-12 620
串的基本操作函数 #include <stdio.h> #include <malloc.h> #include <string.h> /*===========串的动态数组结构体=======================*/ typedef struct{ char *str; int maxLength; int length; }DString; /*================初始化串===========================*/
数据结构6-串
m0_54591377的博客
07-09 461
串(String)是由零个或多个任意字符组成的有限序列，又名字符串。 是一种特殊的内容受限的线性表 相关术语：1)静态数组，字符串有最大长度限制。 2)动态分配内存，字符串的长度可以自动护展。 串的链式存储 串的匹配算法 算法目的：确定主串中所含子串(模式串)第一次出现的位置(定位) 主串： （模式串）子串：BF算法，即暴力（Brute Force)算法，是普通的模式匹配算法，BF算法的思想就是将主串SS的第一 个字符与模式串TT的第一个字符进行匹配，若相等，则继续比较SS的第二个字符和TT的第二个
数据结构-串、数组和广义表-PPT
02-04
"数据结构-串、数组和广义表-PPT" 本节，我们将详细介绍数据结构中串、数组和广义表的定义、特点和操作。 串的定义 串是一种特殊的线性表，其特殊性体现在数据元素是一个字符，也就是说，串是一种内容受限的...
漫话数据结构-串的存储及操作.pptx
11-03
【漫话数据结构-串的存储及操作】深入解析 数据结构是计算机科学中的核心概念，它涉及到如何高效地组织和存储数据以便于执行各种操作。在这个话题中，我们将聚焦于“串”的存储和操作，这是数据结构中的一个重要...
漫话数据结构-串的定义.pptx
11-03
在本文中，我们将深入探讨一个特定的数据结构——串（String），这是由零个或多个字符组成的有限序列。 串是数据结构的一种特殊类型，它属于线性结构，因为它的元素按照线性顺序排列。与其他线性结构如数组和链表...
漫话数据结构-串上的操作.pptx
11-03
在众多的数据结构中，"串"是一个基本且重要的元素，特别是在处理文本信息时。在本节中，我们将深入探讨串的存储结构以及其上的一些基本操作。 串，也被称为字符串，在许多编程语言中被广泛使用，它是字符的有序集合...
数据结构笔记——串
Robod的博客
04-03 1399
数据结构笔记——串
数据结构---串（整个部分）
weixin_63032791的博客
11-19 3441
串基本概念：串是由零个或者多个字符组成的有限序列，一半记作S='a1,a2,a3,a4.......'（n>=0，串的长度）1.S == 串的名字 n == 串当中字符串的个数，称为串的长度。1.空串（null string）：长度为零的串，它不包含任何字符。2.空格串(black string) :任由一个或多个空格组成的串，长度大于等于13.子串（sub string）:串中任意个连续字符的组成的子序列称为该串的“子串”
数据结构与算法(十）-- 串
qq_37504771的博客
04-17 1383
串 串是由零或多个字符构成的有限序列，记：s='a1a2…an'。其中 s 称为串名，'a1a2…an'称为串值。 计算串长(StrLength):串中字符个数。S = "Hello World!" 总长度为12。注意：引号不能省略 ...
数据结构学习：串
weixin_45632016的博客
07-31 647
数据结构学习：串 串，即字符串（String）是由零个或多个字符组成的有限序列。 一般记为：S = ‘a1 a2 ······an ’ （n ≥0） 其中，S是串名，单引号括起来的字符序列是串的值；ai 可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n = 0时的串称为空串（用∅表示）。 子串： 串中任意个连续的字符组成的子序列。 主串： 包含子串的串。 字符在主串中的位置： 字符在串中的序号。 子串在主串中的位置： 子串的第一个字符在主串中的位置 。 注意：位序从1开始而不是从0开始 M =
数据结构---串
zzqingyun的博客
07-20 604
这里我们需要掌握几个概念，串，串名，串长，子串，主串，字符在主串中的位置，子串在主串中的位置（从1开始的），空串，空格串（每个空格字符占1B）。比如S1=”I am a student” S2=”student”子串S2在S1中的位置是8。普通的线性表存放的数据类型是不限制的，而串存放的一般是字符，比如中文字符，英文字符，串的操作对象一般是子串。比如搜索引擎中我们一般输入的是字符串。a在字母表中的位置是小于o的，但是对于计算机来说，字符在计算机中的存储是二进制，这就涉及到字符集编码的问题。
数据结构（五）——串
L的博客
09-16 3204
一：串的概述 串是由零个或多个字符组成的线性表，又称为字符串。串用双引号括起来，但是双引号不属于串的内容。""称为空串，" "称为空格串。例如"ABC"就是一个串，是由A、B、C这三个字符组成的串 定义说串是一种线性表，它其实是一种特殊的线性表，它是由字符组成的 二：串的比较（字符编码概述） 串是通过字符编码进行比较的，计算机中的常用字符使用的是标准的ASCII编码，由7位二进制数表示一个字...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 748
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
"数据结构-串、数组和广义表-PPT：串的定义和特性
在数据结构的学习过程中，我们经常会接触到串、数组和广义表这三种数据结构。串是由零个或多个字符组成的有限序列，通常在计算机中用来表示文本和字符串类型的数据。数组是一种线性表，元素在内存中是连续存储的，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千里狼～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值