将链串s中的所有子串"abc"删除

最新推荐文章于 2022-10-17 09:13:04 发布
最新推荐文章于 2022-10-17 09:13:04 发布
阅读量2.7k 收藏 11
点赞数 2
分类专栏： 算法 C++ 文章标签： 链串 struct 插入 删除 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sanqima/article/details/48863097
版权
C++ 同时被 2 个专栏收录
245 篇文章 8 订阅
订阅专栏
算法
52 篇文章 2 订阅
订阅专栏

　　用p、q、r、t分别指向链串s的连续4个结点，p首先指向头结点。当q、r、t所指结点的值分别为’a’、’b’、’c’时，删除这3个结点并释放其空间，在后移q、r和t指针；否则p、q、r和t指针分别后移一个结点，算法如下：　　

//删除子串"abc"
void delSub(LiString *&s){
    int n=0;
    LiString *p=s->next,*q,*r,*t;
    while (p!=NULL) //求串s长度n
    {
        p=p->next; n++;
    }
    if(n<3) return;  //少于3个字符时返回
    p=s; q=p->next; r=q->next; t=r->next;
    while (q!=NULL && r!=NULL && t!=NULL)
    {  //找到"abc"
        if (q->data=='a' && r->data=='b' && t->data=='c')
        {
            p->next=t->next; //q、r、t分别指向后面的3个结点
            free(q); free(r); free(t);
            q=p->next;
            if (q!=NULL)
            {
                r=q->next;
                if(r!=NULL)
                    t=r->next;
            }           
        }
        else{
            p=p->next;
            q=p->next;
            r=q->next;
            t=r->next;
        }
    }

}

完整代码如下：
//LinkString.cpp 

//LinkStringBase.h
#include <stdio.h>
#include <malloc.h>
typedef struct snode{ //链串定义
    char data;
    struct snode *next;
}LiString;

//创建串
void StrAssign(LiString *&s,char t[]){
    int i;
    LiString *r,*p;
    s=(LiString *)malloc(sizeof(LiString));
    s->next=NULL; 
    r=s;
    for (i=0;t[i]!='\0';i++)
    {
        p=(LiString *)malloc(sizeof(LiString));
        p->data=t[i];
        p->next=NULL;
        r->next=p; r=p;
    }

}

//复制串
void StrCopy(LiString *&s,LiString *t){
    LiString *p=t->next,*q,*r;
    s=(LiString *)malloc(sizeof(LiString));
    s->next=NULL; s->next=NULL; r=s;
    while (p!=NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }

}

//求两串是否相同
int StrEqual(LiString *s,LiString *t){
    LiString *p=s->next,*q=t->next;
    while (p!=NULL && q!=NULL && p->data==q->data)
    {
        p=p->next;
        q=q->next;
    }
    if(p==NULL && q==NULL)
        return 1;
    else
        return 0;

}

//求串的长度
int StrLength(LiString *s){
    int i=0;
    LiString *p=s->next;
    while (p!=NULL)
    {
        i++;
        p=p->next;
    }
    return i;

}

//比较两个字符串
LiString *Concat(LiString *s,LiString *t){
    LiString *str,*p=s->next,*q,*r;
    str=(LiString *)malloc(sizeof(LiString));
    while (p!=NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    p=t->next;
    while (p!=NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    return str;

}

//求串s中第i(1≤i≤n)的字符开始、长度为j的子串
LiString *SubStr(LiString *s,int i,int j){
    int k;
    LiString *str,*p=s->next,*q,*r;
    str=(LiString *)malloc(sizeof(LiString));
    str->next=NULL; r=str;
    if (i<=0 || i>StrLength(s) || j<0 || i+j-1 >StrLength(s))
    {
        printf("参数不正确\n");
        return str;
    }
    for(k=0;k<i-1;k++)
        p=p->next;
    for (k=1;k<=j;k++)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;      
    }
    return str;

}

//在串s的第i个位置插入将串t
LiString *InsStr(LiString *s,int i,LiString *t){
    int k;
    LiString *str,*p=s->next,*p1=t->next,*q,*r;
    str=(LiString *)malloc(sizeof(LiString));
    str->next=NULL; r=str;
    if (i<=0 || i>StrLength(s)+1)
    {
        printf("参数不正确\n");
        return str;
    }
    for (k=1;k<i;k++)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    while (p1 != NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p1->data; q->next=NULL;
        r->next=q; r=q;
        p1=p1->next;
    }
    while (p!=NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;

    }
    return str;

}

//删除串s中第i(1≤i≤n)个位置，长度为j的子串
LiString *DelStr(LiString *s,int i,int j){
    int k;
    LiString *str,*p=s->next,*q,*r;
    str=(LiString *)malloc(sizeof(LiString));
    str->next=NULL; r=str;
    if (i<=0 || i>StrLength(s) || j<0 || i+j-1 >StrLength(s))
    {
        printf("参数不正确\n");
        return str;
    }
    for (k=0;k<i-1;k++)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    for(k=0;k<j;k++)
        p=p->next;
    while (p!=NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    return str;
}

//在链串s中，用串t替换 s中的第i个位置长度为j的子串
LiString *RepStr(LiString *s,int i,int j,LiString *t){
    int k;
    LiString *str,*p=s->next,*p1=t->next,*q,*r;
    str=(LiString *)malloc(sizeof(LiString));
    str->next=NULL; r=str;
    if (i<=0 || i>StrLength(s) || j<0 || i+j-1 >StrLength(s))
    {
        printf("参数不正确\n");
        return str;
    }
    for (k=0;k<i-1;k++)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    for(k=0;k<j;k++)
        p=p->next;
    while (p1 != NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p1->data; q->next=NULL;
        r->next=q; r=q;
        p1=p1->next;
    }
    while (p!=NULL)
    {
        q=(LiString *)malloc(sizeof(LiString));
        q->data=p->data; q->next=NULL;
        r->next=q; r=q;
        p=p->next;
    }
    return str;

}

//输出串s
void DispStr(LiString *s){
    LiString *p=s->next;
    while (p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("\n");
}

//主函数.cpp
#include <stdio.h>
#include "LinkStringBase.h"

//删除子串"abc"
void delSub(LiString *&s){
    int n=0;
    LiString *p=s->next,*q,*r,*t;
    while (p!=NULL) //求串s长度n
    {
        p=p->next; n++;
    }
    if(n<3) return;  //少于3个字符时返回
    p=s; q=p->next; r=q->next; t=r->next;
    while (q!=NULL && r!=NULL && t!=NULL)
    {  //找到"abc"
        if (q->data=='a' && r->data=='b' && t->data=='c')
        {
            p->next=t->next; //q、r、t分别指向后面的3个结点
            free(q); free(r); free(t);
            q=p->next;
            if (q!=NULL)
            {
                r=q->next;
                if(r!=NULL)
                    t=r->next;
            }           
        }
        else{
            p=p->next;
            q=p->next;
            r=q->next;
            t=r->next;
        }
    }

}

//判断s中字符是否递增
int isAscend(LiString *s){
    LiString *p=s->next,*q;
    if (p!=NULL)
    {
        while (p->next!=NULL)
        {
            q=p->next;
            if(q->data>=p->data)
                p=q;
            else
                return 0;
        }
    }
    return 1;
}


void main(){
//  LiString *Lstr=(LiString *)malloc(sizeof(LiString));
//  Lstr->next=NULL;

    LiString *Lstr2;

//  char t[20]="helloworld";
    char t2[20]="helloabcabcWorld";

//  StrAssign(Lstr2,t);
//  Lstr3=SubStr(Lstr2,1,3);
// 
//  DispStr(Lstr2);
//  DispStr(Lstr3);

    StrAssign(Lstr2,t2);

    //原字符串
    printf("原字符串 \n");
    DispStr(Lstr2);
    //操作后:
    printf("操作后：\n");
    delSub(Lstr2);
    DispStr(Lstr2);

//  int n=-2;
//  n=isAscend(Lstr2);
//  if (n==1)
//  {
//      printf("s为递增！\n");
//  }
//  else{
//      printf("s非递增!\n");
//  }



}

效果如下：

这里写图片描述

删除串s=”helloabcabcWorld”, 得到”helloWorld”

sanqima
关注
专栏目录
将字符串中abc删除
weixin_42056607的博客
11-05 884
//设计一个算法，将一个链串s中的所有子串“abc”删除 #include&lt;iostream&gt; using namespace std; struct LinkNode //链串结点指针 { char data; //存放一个字符 LinkNode *next; //指向下一个结点的指针 }; class LinkStringClass //链串类 { LinkNode *h...
删除链串里面的abc三个字符
weixin_44077170的博客
09-14 165
#include #include<stdio.h> using namespace std; typedef class bunch { public: char a; bunch *next; }*LinkBunch,Link; void creat_LinkBunch(LinkBunch &L,char t[]); int StrLength(LinkBunch &amp...
删除字符串中的子串java
QQ_778的博客
06-22 1756
输入2个字符串S1和S2，要求删除字符串S1中出现的所有子串S2，即结果字符串中不能包含S2。 输入格式： 输入在2行中分别给出不超过80个字符长度的、以回车结束的2个非空字符串，对应S1和S2。 输出格式： 在一行中输出删除字符串S1中出现的所有子串S2后的结果字符串。 输入样例： Tomcat is a male ccatat cat 输出样例： Tom is a male import java.util.*; public class Main{ public stat
数据结构算法——1033. 删除子串
JamSlade的博客
10-06 1027
题目 out 3 abaabbabaabb ab abc abc ababababababa aba 思路 善用string库里面的subtr和operator== （用char比较也可以，就是函数得自己写罢了） substr(pos,n) pos表示位置，n表示截取的长度，pos后续不够n那就只截取不足的部分 if(s.substr(pos,n) == short) pos += short - 1; else cout << longn[pos]; 代码 #include<iostr
字符串处理——删除字符中的abc字符程序
Haley_Xu_ANN的博客
11-01 1576
前天帮同学做了一下面试题，题目要求如下： 读入一串字符，将该字符串中所有的“abc”字符串删除，并将处理后的字符串输出。 例如： 输入：asdfghjklabczxcv，输出：asdfghjklzxcv 程序如下： #include using namespace std; int main() { char str[100],*p,*q; cin>>str;
设计一个算法，将一个顺序串S中的所有子串“abc”删除。
最新发布
08-10
设计一个算法将一个顺序串S中的所有子串"abc"删除的方法如下： 1. 定义一个新的空串result，用于存储删除子串后的结果。 2. 定义一个变量i，初始值为0，用于遍历串S。 3. 当i小于串S的长度时，执行以下循环： i. ...
用java设计一个算法，将一个顺序串S中的所有子串“abc”删除。
04-19
可以使用Java中的replace()方法，通过递归将所有的“abc”子串替换为空字符串，代码示例如下： ``` public static String deleteABC(String s) { if (s.contains("abc")) { s = s.replace("abc", ""); s = ...
删除S串中与T相同的子串
05-31
删除S串中与T相同的子串~~~~~~~~
字符串消除 【string】
lzs_lazy
06-09 1203
Problem Description 小可爱推了推眼镜表示很不开心， 她最近在玩一个字符消除游戏。给定一个只包含大写字母”ABC”的字符串s，消除过程是如下进行的：1)如果s包含长度超过1的由相同字母组成的子串，那么这些子串会被同时消除，余下的子串拼成新的字符串。例如”ABCCBCCCAA”中”CC”,”CCC”和”AA”会被同时消除，余下”AB”和”B”拼成新的字符串”ABB”。2)上述消除会
字符串消除
大卫david的专栏
08-27 1807
依旧是庞果网上的一道题目，详情如下： 给定一个字符串，仅由a,b,c 3种小写字母组成。当出现连续两个不同的字母时，你可以用另外一个字母替换它，如 有ab或ba连续出现，你把它们替换为字母c； 有ac或ca连续出现时，你可以把它们替换为字母b； 有bc或cb 连续出现时，你可以把它们替换为字母a。 你可以不断反复按照这个规则进行替换，你的目标是使得最终结果所得到的字符串尽可能短，求最终结果的最短
直接删除s串中与t串相同的子串
05-31
直接删除s串中与t串相同的子串
从串s中删除所有和串t相同的子串的算法
积极奋斗的蜗牛
04-27 1万+
编写算法，从串s中删除所有和串t相同的子串。 StringType是串的一个抽象数据类型，它包含以下6种基本操作： void InitStr(StringType &s);   // 初始化s为空串。 void StrAssign(StringType &t, StringType s);   // 将s的值赋给t。s的实际参数是串变量。 int StrCompare(StringTy
Python：删除子串
WQ的博客
04-22 4894
【问题描述】编写程序实现在字符串s中删除子字符串c的功能。 说明：不考虑去掉子字符串c后形成的新的子字符串c。 例如：字符串s为abcabcd，子串c为bc，则调用该函数后，结果字符串s为aad。【输入形式】输入的第一行表示字符串s，第二行表示子串c。【输出形式】输出的一行表示处理后的结果。【样例输入】 abcabcd bc【样例输出】 aad s = input() c = input() print(s.replace(c, ...
串---删除字符串中的所有子串
qq_38904904的博客
03-30 1546
问题： 要求编写一个删除字符串"abcdeabdbcdaaabdecdf"中所有"abd"的程序。 算法分析： 创建两个字符串，使用gets(); 使用删除字符串的基本操作：DeleteString(SeqString *S, int pos, int len ) 首先找到要删除的起始字符位置，采用遍历的方式，如果第一个字符相同，则比较第二个，依次进行下去 代码： 顺序串头文件：“SeqStr...
7-1 删除字符串中的子串（附有详细解析）
wzy992981933的博客
10-17 2757
输入2个字符串S1和S2，要求删除字符串S1中出现的所有子串S2，即结果字符串中不能包含S2。
字符串中删除子串
兔子王
09-27 5842
【问题描述】编写一个程序，当在一个字符串中出现子串时就删除它（字符串的字符个数不超过1000）。 【输入形式】第一行输入一个字符串，第二行输入一个子串。 【输出形式】程序在下一行输出删除其中所有子串后的字符串。如果字符串不包含子串则输出原字符串本身。
原假设与备择假设的联系与区别
热门推荐
sanqima的专栏
05-03 6万+
1.假设的陈述 　　(1) 原假设与备择假设 　　在参数假设检验中，总体的分布类型已知，假设检验的目的是对总体参数进行检验，为此，研究者需要事先提出某个假设，才能根据样本统计量判断假设是否真实。在参数假设检验中，“假设”是对总体参数的具体数值所作的陈诉。为了使得作为证据的样本统计量必然支持且仅支持一个假设，要建立对于总体参数在逻辑上完备互斥的一对假设，即原假设(null hypothesis，
在Python里安装Jieba中文分词组件
sanqima的专栏
03-23 5万+
Jieba是一个中文分词组件，可用于中文句子/词性分割、词性标注、未登录词识别，支持用户词典等功能。该组件的分词精度达到了97%以上。下载介绍在Python里安装Jieba。 　　1）下载Jieba 　　官网地址：http://pypi.python.org/pypi/jieba/ 　　个人地址：http://download.csdn.net/detail/sanqima/9470715
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

sanqima

一键三连，多多益善

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

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

打赏作者

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

抵扣说明：

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

余额充值