数据结构（串）

于 2023-03-22 22:48:48 发布
阅读量171 收藏 1
点赞数 1
文章标签： 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SnowDreamXUE/article/details/129721164
版权

数据结构（串）

《数据结构教程》第6版 p136页上机作业

exp4-1

//
// Created by Snow on 2023/3/21.
//
#include"sqstring.cpp"
int main()
{
    PrintCommand();
    exp();
    return 0;
}

//
// Created by Snow on 2023/3/21.
//
#include<cstdio>
#include<windows.h>
#define MaxSize 40
typedef struct
{
    char data[MaxSize];
    int length;
}SqString;
void PrintCommand()
{
    printf("1.建立串s=”abcdefghijklmn“和串s1=“xyz”            2.输出串s\n");
    printf("3.输出串s的长度                                   4.在串s的第9个字符位置插入串s1而产生s2\n");
    printf("5.输出串s2                                        6.删除串s的第2个字符开始的5个字符而产生串s2\n");
    printf("7.输出串s2                                        8.将串s的第2个字符开始的5个字符替换成串是而产生串s2\n");
    printf("9.输出串s2                                        10.提取串s的第2个字符开始的10个字符而产生串s3\n");
    printf("11.输出串s3                                       12.将串s1和串s2连接起来而产生的串s4\n");
    printf("12.输出串s4\n");
}
void StrAssign(SqString &s,const char str[])
{
    int i;
    for(i=0;str[i]!='\0';i++)
        s.data[i]=str[i];
    s.length=i;
}
int StrLength(SqString s)
{
    return(s.length);
}
SqString Sub(SqString s,int i,int j)
{
    int k;
    SqString str;
    str.length=0;
    if(i<=0||i>s.length||j<0||i+j-1>s.length)
        return str;
    for(k=i-1;k<i+j-1;k++)
        str.data[k-i+1]=s.data[k];
    str.length=j;
    return str;
}
SqString InsStr(SqString s,int i,SqString t)
{
    int j;
    SqString str;
    str.length=0;
    if(i<=0||i>s.length+1)
        return str;
    for(j=0;j<i-1;j++)
        str.data[j]=s.data[j];
    for(j=0;j<t.length;j++)
        str.data[j+i-1]=t.data[j];
    for(j=i-1;j<s.length;j++)
        str.data[j+t.length]=s.data[j];
    str.length=s.length+t.length;
    return str;
}
SqString RepStr(SqString s,int i,int j,SqString t)
{
    int k;
    SqString str;
    str.length=0;
    if(i<=0||i>s.length||i+j-1>s.length)
    {
        return str;
    }
    for(k=0;k<i-1;k++)
        str.data[k]=s.data[k];
    for(k=0;k<t.length;k++)
        str.data[k+i-1]=t.data[k];
    for(k=i-1+j;k<s.length;k++)
        str.data[k+t.length-j]=s.data[k];
    str.length=s.length+t.length-j;
    return str;
}
SqString DelStr(SqString s,int i,int j)
{
    int k;
    SqString str;
    str.length=0;
    if(i<=0||i>s.length||i+j>s.length+1)
        return str;
    for(k=0;k<i-1;k++)
        str.data[k]=s.data[k];
    for(k=i+j-1;k<s.length;k++)
        str.data[k-j]=s.data[k];
    str.length=s.length-j;
    return str;
}
SqString Concat(SqString s,SqString t)
{
    SqString str;
    int i;
    str.length=s.length+t.length;
    for(i=0;i<s.length;i++)
        str.data[i]=s.data[i];
    for(i=0;i<t.length;i++)
        str.data[s.length+i]=t.data[i];
    return str;
}
void DispStr(SqString s)
{
    int i;
    if(s.length>0)
    {
        for(i=0;i<s.length;i++)
            printf("%c",s.data[i]);
        printf("\n");
    }
    else
        printf("空串！\n");
}
void exp()
{
    char str1[]="abcdefghijklmn",str2[]="xyz";
    SqString s,s1,s2,s3,s4;
    StrAssign(s,str1);
    StrAssign(s1,str2);
    printf("\ns=");
    DispStr(s);
    printf("\n串s的长度为%d\n", StrLength(s));
    s2=InsStr(s,9,s1);
    printf("\n在串s的第9个字符位置插入串s1而产生s2为  ");
    DispStr(s2);
    s2=DelStr(s,2,5);
    printf("\n删除串s的第2个字符开始的5个字符而产生串s2为  ");
    DispStr(s2);
    s2=RepStr(s,2,5,s1);
    printf("\n将串s的第2个字符开始的5个字符替换成串是而产生串s2为  ");
    DispStr(s2);
    s3=Sub(s,2,10);
    printf("\n提取串s的第2个字符开始的10个字符而产生串s3为  ");
    DispStr(s3);
    s4=Concat(s1,s2);
    printf("\n将串s1和串s2连接起来而产生的串s4为  ");
    DispStr(s4);
    system("pause");
}

exp4-2

//
// Created by Snow on 2023/3/22.
//
#include"listring.cpp"
int main()
{
    PrintCommand();
    exp();
    return 0;
}

//
// Created by Snow on 2023/3/22.
//
#include<cstdio>
#include<cstdlib>
typedef struct SNode
{
    char data;
    struct SNode *next;
}LinkStrNode;
void PrintCommand()
{
    printf("1.建立串s=”abcdefghijklmn“和串s1=“xyz”            2.输出串s\n");
    printf("3.输出串s的长度                                   4.在串s的第9个字符位置插入串s1而产生s2\n");
    printf("5.输出串s2                                        6.删除串s的第2个字符开始的5个字符而产生串s2\n");
    printf("7.输出串s2                                        8.将串s的第2个字符开始的5个字符替换成串是而产生串s2\n");
    printf("9.输出串s2                                        10.提取串s的第2个字符开始的10个字符而产生串s3\n");
    printf("11.输出串s3                                       12.将串s1和串s2连接起来而产生的串s4\n");
    printf("12.输出串s4\n");
}
void StrAssign(LinkStrNode *&s,char const str[])
{
    int i;
    LinkStrNode *p,*r;
    s=(LinkStrNode*)malloc(sizeof(LinkStrNode));
    r=s;
    for(i=0;str[i]!='\0';i++)
    {
        p=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        p->data=str[i];
        r->next=p;
        r=p;
    }
    r->next=nullptr;
}
bool DestroyStr(LinkStrNode *&s)
{
    if(s==nullptr)
    {
        printf("链串不存在!\n");
        return false;
    }
    LinkStrNode *p=s->next,*pre=s;
    while(p!=nullptr)
    {
        free(pre);
        pre=p;
        p=p->next;
    }
    free(pre);
    return true;
}
int StrLength(LinkStrNode *s)
{
    int i=0;
    LinkStrNode *p=s->next;
    while(p!=nullptr)
    {
        p=p->next;
        i++;
    }
    return i;
}
LinkStrNode *Concat(LinkStrNode *s,LinkStrNode *t)
{
    LinkStrNode *str,*p=s->next,*r,*q;
    str=(LinkStrNode*)malloc(sizeof(LinkStrNode));
    r=str;
    while(p!=nullptr)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p->data;
        r->next=q;
        r=q;
        p=p->next;
    }
    p=t->next;
    while(p!=nullptr)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p->data;
        r->next=q;
        r=q;
        p=p->next;
    }
    r->next=nullptr;
    return str;
}
LinkStrNode *SubStr(LinkStrNode *s,int i,int j)
{
    int k;
    LinkStrNode *str,*p=s->next,*q,*r;
    str=(LinkStrNode*)malloc(sizeof(LinkStrNode));
    str->next=nullptr;
    r=str;
    if(i<=0||i>StrLength(s)||i+j-1>StrLength(s))
    {
        printf("参数错误!\n");
        return str;
    }
    for(k=1;k<i;k++)
        p=p->next;
    for(k=1;k<=j;k++)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p->data;
        r->next=q;
        r=q;
        p=p->next;
    }
    r->next=nullptr;
    return str;
}
LinkStrNode *InsStr(LinkStrNode *s,int i,LinkStrNode *t)
{
    int k;
    LinkStrNode *str,*p1=s->next,*p2=t->next,*q,*r;
    str=(LinkStrNode*)malloc(sizeof(LinkStrNode));
    str->next=nullptr;
    r=str;
    if(i<=0||i>StrLength(s)+1)
    {
        printf("参数错误!\n");
        return str;
    }
    for(k=1;k<i;k++)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p1->data;
        r->next=q;
        r=q;
        p1=p1->next;
    }
    while(p2!=nullptr)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p2->data;
        r->next=q;
        r=q;
        p2=p2->next;
    }
    while(p1!=nullptr)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p1->data;
        r->next=q;
        r=q;
        p1=p1->next;
    }
    r->next=nullptr;
    return str;
}
LinkStrNode *DelStr(LinkStrNode *s,int i,int j)
{
    int k;
    LinkStrNode *str,*p=s->next,*q,*r;
    str=(LinkStrNode*)malloc(sizeof(LinkStrNode));
    str->next=nullptr;
    r=str;
    if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))
    {
        printf("参数错误!\n");
        return str;
    }
    for(k=1;k<i;k++)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p->data;
        r->next=q;
        r=q;
        p=p->next;
    }
    for(k=0;k<j;k++)
        p=p->next;
    while(p!=nullptr)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p->data;
        r->next=q;
        r=q;
        p=p->next;
    }
    r->next=nullptr;
    return str;
}
LinkStrNode *RepStr(LinkStrNode *s,int i,int j,LinkStrNode *t)
{
    int k;
    LinkStrNode *str,*p1=s->next,*p2=t->next,*q,*r;
    str=(LinkStrNode*)malloc(sizeof(LinkStrNode));
    str->next=nullptr;
    r=str;
    if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))
    {
        printf("参数错误!\n");
        return str;
    }
    for(k=1;k<i;k++)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p1->data;
        r->next=q;
        r=q;
        p1=p1->next;
    }
    for(k=0;k<j;k++)
        p1=p1->next;
    while(p2!=nullptr)
        while(p2!=nullptr)
        {
            q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
            q->data=p2->data;
            r->next=q;
            r=q;
            p2=p2->next;
        }
    while(p1!=nullptr)
    {
        q=(LinkStrNode*)malloc(sizeof(LinkStrNode));
        q->data=p1->data;
        r->next=q;
        r=q;
        p1=p1->next;
    }
    r->next=nullptr;
    return str;
}
bool DispStr(LinkStrNode *s)
{
    if(s==nullptr)
    {
        printf("链串不存在!\n");
        return false;
    }
    LinkStrNode *p=s->next;
    while(p!=nullptr)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
    return true;
}
void exp()
{
    char str1[]="abcdefghijklmn",str2[]="xyz";
    LinkStrNode *s,*s1,*s2,*s3,*s4;
    StrAssign(s,str1);
    StrAssign(s1,str2);
    printf("\ns=");
    DispStr(s);
    printf("\n串s的长度为%d\n", StrLength(s));
    s2=InsStr(s,9,s1);
    printf("\n在串s的第9个字符位置插入串s1而产生s2为  ");
    DispStr(s2);
    DestroyStr(s2);
    s2=DelStr(s,2,5);
    printf("\n删除串s的第2个字符开始的5个字符而产生串s2为  ");
    DispStr(s2);
    DestroyStr(s2);
    s2=RepStr(s,2,5,s1);
    printf("\n将串s的第2个字符开始的5个字符替换成串是而产生串s2为  ");
    DispStr(s2);
    s3=SubStr(s,2,10);
    printf("\n提取串s的第2个字符开始的10个字符而产生串s3为  ");
    DispStr(s3);
    s4=Concat(s1,s2);
    printf("\n将串s1和串s2连接起来而产生的串s4为  ");
    DispStr(s4);
    DestroyStr(s);
    DestroyStr(s2);
    DestroyStr(s3);
    DestroyStr(s4);
    system("pause");
}

exp4-3

//
// Created by Snow on 2023/3/22.
//
#include<cstdio>
#include<windows.h>
#define MaxSize 50
typedef struct
{
    char data[MaxSize];
    int length;
}SqString;
void StrAssign(SqString &s,char const str[])
{
    int i;
    for(i=0;str[i]!='\0';i++)
        s.data[i]=str[i];
    s.length=i;
}
void DispStr(SqString s)
{
    int i;
    if(s.length>0)
    {
        for(i=0;i<s.length;i++)
            printf("%c",s.data[i]);
        printf("\n");
    }
    else
        printf("空串!\n");
}
//BF算法
int BF(SqString s,SqString t)
{
    int i=0,j=0;
    while(i<s.length&&j<t.length)
    {
        if(s.data[i]==t.data[j])
        {
            j++;
            i++;
        }
        else
        {
            i=i-j+1;
            j=0;
        }
    }
    if(j>=t.length)
        return(i-t.length);
    else
        return -1;
}
//KMP算法
void GetNext(SqString t,int next[])
{
    int j=0,k=-1;
    next[0]=-1;
    while(j<t.length)
    {
        if(k==-1||t.data[j]==t.data[k])
        {
            j++;
            k++;
            next[j]=k;
        }
        else
            k=next[k];
    }
}
int KMPIndex(SqString s,SqString t)
{
    int next[MaxSize],i=0,j=0;
    GetNext(t,next);
    while(i<s.length&&j<t.length)
    {
        if(j==-1||s.data[i]==t.data[j])
        {
            i++;
            j++;
        }
        else
            j=next[j];
    }
    if(j>=t.length)
        return(i-t.length);
    else
        return -1;
}
//进阶KMP
void GetNextval(SqString t,int nextval[])
{
    int j=0,k=-1;
    nextval[0]=-1;
    while(j<t.length)
    {
        if(k==-1||t.data[j]==t.data[k])
        {
            j++;
            k++;
            if(t.data[j]!=t.data[k])
            {
                nextval[j]=k;
            }
            else
                nextval[j]=nextval[k];
        }
        else
            k=nextval[k];
    }
}
int KMPIndex1(SqString s,SqString t)
{
    int nextval[MaxSize],i=0,j=0;
    GetNextval(t,nextval);
    while(i<s.length&&j<t.length)
    {
        if(s.data[i]==t.data[j])
        {
            i++;
            j++;
        }
        else
            j=nextval[j];
    }
    if(j>=t.length)
        return(i-t.length);
    else
        return -1;
}
int main()
{
    char str[]="abcabcdabcdeabcdefabcdefg",arr[]="abcdeabcdefab";
    SqString s,t;
    StrAssign(s,str);
    StrAssign(t,arr);
    printf("建立目标串s和模式串t\n");
    printf("s=  ");
    DispStr(s);
    printf("t=  ");
    DispStr(t);
    printf("BF算法得出位置为:%d\n",BF(s,t));
    printf("KMP算法得出位置为:%d\n",KMPIndex(s,t));
    printf("进阶KMP算法得出位置为:%d\n", KMPIndex1(s,t));
}

GBK编码

SnowDreamXUE
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构第三次上机 第四章之顺序串
Haruno_Sakura的博客
11-16 3666
实验题1：实现顺序串的各种基本运算的算法。 内容： 编写一个程序sqstring.cpp,实现顺序串的各种基本运算，并在此基础上设计一个exp4-1.cpp完成以下功能。 （1）建立串s="abcdefghefghijklmn"和串s=“xyz”. （2）输出串s。 （3）输出串s的长度。 （4）在串s的第9个字符位置插入串s1而产生串s2。 （5）输出
数据结构顺序串的基本操作（C/C++实现）
热门推荐
JunsIr的技术栈
10-29 1万+
数据结构顺序串的基本操作（C/C++实现） 注意：本代码为了测试运行默认含有操作所需数据，如有需要可自己增删改相关数据 涉及基本运算流程 建立串 s = ‘’abcdefghijklnm’'和串s1 = ‘’xyz‘’ 输出串s 输出串s的长度 在串s的第9个字符位插入串s1而产生串s2 输出串s2 删除串s的第2个字符开始的5个字符而产生串s2 输出串s2 将串s的第2个字符开始的第5个字符替...
3.15 排列对称串
weixin_37289816的博客
03-18 453
筛选出对称字符串，然后将其排序。 输入样例： 123321 123454321 123 321 sdfsdfd 121212 \\dd\\ 输出样例 123321 \\dd\\ 123454321 #include #include #include #include using namespace std; bool isSymmetry(string);//判断
数据结构—顺序串
LY_624的专栏
04-17 1528
/* 编写一个程序，实现顺序串的各种基本运算，并完成如下功能： （1）建立串：s="abcdefghefghijklmn"和串s1="xyz"; （2）输出串s; （3）输出串的长度； （4）在串的第9个字符位置插入串s1而产生串s2； （5）输出串s2； （6）删除串s第2个字符开始的5个字符而产生串s2； （7）输出串s2; （8）将串s第2个字符开始的5个字符替换成串s1而产生s2； （9）
第八周项目2—建立链串的算法库
mlk5739_csdn的博客
10-21 461
copyright （c） 2016，烟台大学计算机学院    All rights reserved.    文件名称：1.cpp    作者：孟令康   完成日期：2016年9月12日    版本号：v1.0    问题描述：定义链串的存储结构，实现其基本运算，并完成测试。                     要求：（1）建立串s：abcdefghijklmn 和
头歌数据结构串的运算及应用
05-18
在计算机科学中，数据结构是组织和管理数据的重要工具，而字符串（串）作为一种基本的数据结构，广泛应用于文本处理、模式匹配等领域。本篇主要探讨的是在C语言环境下，如何实现字符串的子串截取以及模式匹配的相关...
数据结构 串
05-13
在众多的数据结构中，“串”（String）是一个基础且实用的类型，尤其在处理文本信息时不可或缺。本文将深入探讨“串”的概念、特性以及在实际编程中的应用。 串是由字符组成的序列，可以视为字符的数组。在大多数...
数据结构串知识点.cpp
03-08
数据结构串知识点.cpp
数据结构串的操作实例详解
08-30
数据结构串的操作实例详解 数据结构串的操作实例详解是计算机科学中的一种基本数据结构，串是一种特殊的线性表，它的每个结点是一个字符，所以串也称作字符串。串的操作是计算机科学中一种基本的数据结构操作，它...
数据结构之顺序串
Qy_T543的博客
10-05 1028
数据结构之顺序串
实现顺序串各种基本运算的算法
xiezhi123456的博客
07-22 2567
/** * 实验题目: * 实现顺序串各种基本运算的算法 * 实验内容: * 编写程序,实现顺序串的各种基本运算,并在此基础上设计一个主程序完成如下功能: * (1)建立串s="abcdefghefghijklmn"和串s1="xyz" * (2)输出串s * (3)输出串s的长度 * (4)在串s的第9个字符位置插入串s...
第八周 项目1-建立顺序串的算法库
zj2558562310的博客
10-23 240
/*   *Copyright(c) 2015, 烟台大学计算机学院   *All rights reserved.   *文件名称：建立顺序串的算法库.cpp   *作    者：周洁   *完成日期：2015年 10月23日   *版 本 号：   *   *问题描述：定义顺序串的存储结构，实现其基本运算，并完成测试。 　　要求： 　　1、头文件sqString
数据结构的在C语言中的类型定义
居上
12-22 2245
数据结构线性顺序表链表单链表双链表循环链表栈顺序栈链栈队列顺序队链队串顺序串链串树树双亲存储结构孩子存储结构孩子兄弟链存储结构二叉树顺序存储结构链式存储结构图邻阶矩阵存储方法邻接表存储方法 线性 顺序表 typedef struct ElemType data[MAXSIZE]; int length; }SqList;//顺序表类型 链表 单链表 typedef struct LNode { ElemType data; struct LNode* next; }LinkNode;//单链表结点
算法与数据结构----串
qq_57611608的博客
06-04 1460
实验三 串 一、实验目的和要求 1、理解串的存储结构及基本操作实现。 2、掌握串的模式匹配算法及应用。 二、实验仪器和设备 微型计算机 三、实验内容与过程 1、验证性实验：实现顺序串的基本操作 实验内容：编写一个程序sqstring.cpp (或.c)，实现顺序串的各种基本运算，并在此基础上编写一个程序exp4-1.cpp (或.c) 完成以下功能。 (1) 建立串s="abcdefghefghijklmn"和串s1="xyz"。 (2) 输出串s。 (3) 输出串s的长度。 ...
第八周上机实践项目5 - 计数的模式匹配
yxxhilda的博客
10-26 308
问题及代码： 测试函数：main.cpp，完成相关的测试工作； /* *Copyright(c)2015,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：test.cpp *作者：颜肖璇 *完成日期：2015年10月26日 *版本号：v1.0 /* *问题描述：采用顺序结构存储串
第八周 【项目四 -字符串加密】
sdlixiao6的博客
10-27 333
/* Copyright (c)2016,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：第8周项目4-字符串加密.cpp 作 者：李潇 完成日期：2016年10月27日 版 本 号：v1.0 问题描述：一个文本串可用事先编制好的字
第八周项目4——字符串加密
最好你搬过来
10-20 537
/* * Copyright (c)2016,烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称：wu.cpp * 作 者：武昊* 完成日期：2016年10月18日 * 版 本 号：v1.0 *问题描述：一个文本串可用事先编制好的字符映射表进行加密。例如，设字符映射表为： abc
数据结构复习 -- 字符串
森宝的博客
07-27 570
串 知识框架 **串的基本操作** StrAssion(&T,chars) ; 赋值操作,将串 T 赋值为 chars 。 StrCompare(S,T) ;比较操作。 Strlength(S) ; 求串的长度。 Concat(&T,S1,S2) : 串连接。用T返回由S1和S2连接而成的新串。 类型声明 : typedef struct{ char data[MaxSize]; int length; //串长 } SqString; 1 生成串 void StrAs
C++模式串匹配
alyh1314的博客
04-27 362
BF与KMP算法 #include<iostream> #define maxsize 50 using namespace std; typedef struct { char data[maxsize]; int length; }Sqstring; //创建目标串和模式串 void create(Sqstring &s) { int i=0; cin>>s.data; while(s.data[i]!='\0') { i++;
C语言数据结构串结构
最新发布
06-26
1. 字符数组：最基本的字符串数据结构是字符数组，比如`char str[] = "Hello";`，这里的str实际上就是一个字符数组，数组的第一个元素通常是空字符'\0'，表示字符串的结束。 2. 指针表示：由于字符串常量实际上是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值