用指针的方式去替换数组

问题描述】

设计一个字符串子串替换函数，并实现子串的替换。

函数定义为如下格式：

bool replaceStr(char *str,char *sub);

要求按照规定的格式进行代码填空。

【输入形式】

第一行输入主串

第二行输入要替换的子串

第三行输入要替换的内容

【输出形式】

输出替换子串后的结果

【样例输入】

abcdcef

ce

ss

【样例输出】

abcdssf

这个代码有问题，有一些情况没有考虑到：比如刚刚好是100个元素的情况，还有就是替换的数组为空的情况（这种情况就是普通的删除）

//1、  设计一个字符串子串替换函数          将结果子串指针返回，用主程序验证。
//不用动态数组实现
/*
可能出现的情况：
1.在最前面，后面
2,三种空串的情况
3.子串和替换的字符串一模一样
4.要交换多次

*/


#include  <stdio.h>
#include  <string.h>
#include  <stdbool.h>

#define  STRING_INIT_SIZE        100        //串初始长度

//所有要用到的函数在这里声明
int getIndex(char *str, char *sub, int pos);
char*rplStr(char *str,char *sub,char *rpl);




int  main(){
        char  str[STRING_INIT_SIZE];        //主字符串
        char  sub[STRING_INIT_SIZE];        //被替换的子串
        char  rpl[STRING_INIT_SIZE];  //要替换的内容

        printf("Please  enter  the  main  string:\n");
        gets(str);

        printf("Please  enter  a  substring:\n");
        gets(sub);

        printf("Enter  what  to  replace:\n");
        gets(rpl);

        rplStr(str,sub,rpl);

        printf("Output  the  result  after  replacing:\n");
        printf("%s",str);

        return  0;

}
/*
BF算法求解模式匹配
参数：str 主串的首地址，sub字串的首地址，pos起始查找位置
返回值：返回子串sub在主串str中的下标位置。
        若不存在，则返回值为-1
        其中，若sub为空串，则返回0.
例主串为：abcdce，字串为ce，起始查找位置为0，则返回4
*/

int getIndex(char *str, char *sub, int pos){
    int i = pos;//开始匹配的位置
	int j = 0;
	if (pos<0 || pos>strlen(sub))
	{
		return -3;//输入的pos有错误
	}

    else	if(strlen(sub)==0)
    {

        return -2;//子串为零
    }

    else
   {
	while (j<=strlen(sub) && i<=strlen(str))
	{



		if (str[i]==sub[j])
		{


			i++;
			j++;
		}

		else
            {

           i=i-j+1;
           j=0;
              }//这里要有三个判断来对付第9中情况



	    if (j== strlen(sub))
		return i-strlen(sub);


	}
   }


		return -1;//不存在子串





}


/*
参数：str 主串的首地址，sub字串的首地址，rpl要替换的子串的首地址
返回值：如果子串不匹配主串，则不处理主串返回false
        如果子串匹配主串，则在主串中删掉子串的内容，并返回true
*/
char* rplStr(char *str,char *sub,char *rpl){

        int len1=strlen(str);
        int len2=strlen(sub);
        int len3=strlen(rpl);

        int idx=getIndex(str,sub,0);









        if(idx!=-2&&idx!=-1&&idx!=-3)

        {

            if(strcmp(sub,rpl)==0||len3==0)
            {
                return str;
            }
            else
            {




            char*p1=str+idx;
            char*p2=str+idx+len2-1;
            char*p3=p2+1;//子串后面那一个
            char*p4=p1+len3;//子串后面那一个在替换之后应该出现的位置




            char*p5=rpl;
            //先把后面的向后移
            for(;p3<str+len1;p3++)
            {
                *p4=*p3;
                 p4++;

            }





             char*newp1=p1;
            for(;newp1<p1+len3;newp1++)
            {
                *newp1=*p5;
                p5++;

            }

            *p4='\0';






               rplStr(str,sub,rpl);
               }
        }
        else
        {
            return str;
        }







}

//1、  设计一个字符串子串替换函数          将结果子串指针返回，用主程序验证。
//不用动态数组实现


#include  <stdio.h>
#include  <string.h>
#include  <stdbool.h>

#define  STRING_INIT_SIZE        100        //串初始长度

//所有要用到的函数在这里声明  
int getIndex(char *str, char *sub, int pos);
char*rplStr(char *str,char *sub,char *rpl);




int  main(){
        char  str[STRING_INIT_SIZE];        //主字符串
        char  sub[STRING_INIT_SIZE];        //被替换的子串
        char  rpl[STRING_INIT_SIZE];  //要替换的内容

        printf("Please  enter  the  main  string:\n");
        gets(str);

        printf("Please  enter  a  substring:\n");
        gets(sub);

        printf("Enter  what  to  replace:\n");
        gets(rpl);

        rplStr(str,sub,rpl);

        printf("Output  the  result  after  replacing:\n");
        printf("%s",str);

        return  0;

}
/*
BF算法求解模式匹配
参数：str 主串的首地址，sub字串的首地址，pos起始查找位置
返回值：返回子串sub在主串str中的下标位置。
        若不存在，则返回值为-1
        其中，若sub为空串，则返回0.
例主串为：abcdce，字串为ce，起始查找位置为0，则返回4
*/

int getIndex(char *str, char *sub, int pos){
    int i = pos;//开始匹配的位置
	int j = 0;
	if (pos<0 || pos>strlen(sub))
	{
		return -3;//输入的pos有错误
	}

    else	if(strlen(sub)==0)
    {

        return -2;//子串为零
    }

    else
   {
	while (j<=strlen(sub) && i<=strlen(str))
	{



		if (str[i]==sub[j])
		{


			i++;
			j++;
		}

		else
            {

           i=i-j+1;
           j=0;
              }//这里要有三个判断来对付第9中情况



	    if (j== strlen(sub))
		return i-strlen(sub);


	}
   }


		return -1;//不存在子串





}


/*
参数：str 主串的首地址，sub字串的首地址，rpl要替换的子串的首地址
返回值：如果子串不匹配主串，则不处理主串返回false
        如果子串匹配主串，则在主串中删掉子串的内容，并返回true
*/


char* rplStr(char *str,char *sub,char *rpl){

        char temp[100];
        char*tp=temp;
        int i;
        int len1=strlen(str);
        int len2=strlen(sub);
        int len3=strlen(rpl);

        int idx=getIndex(str,sub,0);

      
        char*p1=str+idx;
            char*p2=str+idx+len2-1;
            char*p3=p2+1;//子串后面那一个
            char*p4=p1+len3;//子串后面那一个在替换之后应该出现的位置





        if(idx!=-2&&idx!=-1&&idx!=-3)

        {

            if(strcmp(sub,rpl)==0||len1-len2+len3>=100)//不能超出长度
            {
                return str;
            }
            else  if(len3==0)
                 {

                  char*p6;

                    for(p6=p2+1;p6<str+len1;p6++)
                  {
                      *(p1)=*(p6);
                     p1++;
                  }
                      *p1='\0';
                rplStr(str,sub,rpl);
                 }
           




           else
            {




            
           



            char*p5=rpl;
            //先把后面的向后移,这里保险的话最好首先找一个新的数组储存一下

            for(;p3<str+len1;p3++)
            {
                *tp=*p3;
                tp++;
            }
            char*tp1=temp;

            for(;tp1<tp;tp1++)
            {
                *p4=*tp1;
                 p4++;
                
            }





             char*newp1=p1;
            for(;newp1<p1+len3;newp1++)
            {
                *newp1=*p5;
                p5++;

            }

            *p4='\0';






               rplStr(str,sub,rpl);
               }
        }
        else
        {
            return str;
        }

}