C语言数据结构-串-串替换-实现字符串替换操作

r囧r小猫 2022-11-16 04:54 389阅读 0赞

# 串替换 #

**不调用库函数**，自己实现字符串替换操作，函数原型为：

int str_replace(const char *in, char *out, int outlen, const char *oldstr, const char *newstr);

参数说明:

*  in， 原始字符串，保持不变  
    out, 存放替换结果的字符串  
    outlen，out空间的大小  
    oldstr，要替换的旧字符串  
    newstr，替换成的新字符串  
    函数返回成功替换的次数，即有多少个子串被成功替换

在替换过程中，任何情况下所得字符串（及结束符）不应该超过 outlen，如果某次替换所得字符串的长度超过 outlen，则不进行这次替换操作，整个替换操作结束。如：  
原始串为 "aaabbbccc"，outlen 为14, oldstr 为 "c"，newstr 为 "333" 时，两次替换后得 "aaabbb333333c"，此时字符串占用空间为14字节。  
如果再进行替换，则会超出 out 所占用的空间，所以停止替换操作。此时函数应该返回 2, out指向的串为 "aaabbb333333c"  
再如：原始串为 "aaabbbccc"，outlen 为10, oldstr 为 "bb"，newstr 为 "123456"，进行替换后所得的串应该为 "aaa123456" （长度为9）与结束符一共占 10 个字节，此时函数应该返回 1。

提供代码

#include<stdio.h>
    #include<stdlib.h>
    #include "dsstring.h"
    
    
    int str_replace(const char *in, char *out, int outlen, const char *oldstr, const char *newstr){
    
    }

参考代码

#define _CRT_SECURE_NO_WARNINGS
    #include<stdio.h>
    #include<stdlib.h>
    //#include "dsstring.h"
    #include<assert.h>
    
    void* Memset(void* s, int c, size_t n)
    {
    	if (NULL == s || n < 0)
    		return NULL;
    	char* tmpS = (char*)s;
    	while (n-- > 0)
    		*tmpS++ = c;
    	return s;
    }
    
    char* Strncat(char* dest, const char* source, int num)
    {
    	//assert(dest != NULL);
    	//assert(source != NULL);
    	char* ret = dest;
    
    	while (*dest != '\0')
    	{
    		dest++;
    	}
    	while (num && (*dest++ = *source++))
    	{
    		num--;
    	}
    	return ret;
    }
    
    char* Strcat(char* dest, const char* src)
    {
    	//assert(dest != NULL);
    	//assert(src != NULL);
    	char* ret = dest;
    	//1.找到目的字符串的'\0'
    	while (*dest != '\0')
    	{
    		dest++;
    	}
    	//2.追加
    	while (*dest++ = *src++)
    	{
    		;
    	}
    	return ret;
    }
    
    int Strlen(char* str)
    {
    	int count = 0;
    	while (*str != '\0')
    	{
    		str++;
    		count++;
    	}
    	return count;
    }
    
    int Strncmp(const char* str1, const char* str2, int size) {
    	for (int i = 0; i < size; ++i) {
    		if (*(str1 + i) > *(str2 + i)) {
    			return 1;
    		}
    		else if (*(str1 + i) < *(str2 + i)) {
    			return -1;
    		}
    		if (*(str1 + i) == 0 || *(str2 + i) == 0) {
    			break;
    		}
    	}
    	return 0;
    }
    
    int str_replace(const char* in, char* out, int outlen, const char* oldstr, const char* newstr) {
    	//assert(in && out  && oldstr && newstr && outlen);
    	Memset(out, 0, outlen);
    	int count = 0;
    	for (int i = 0; i < Strlen(in); i++) {
    		if (!Strncmp(in + i, oldstr, Strlen(oldstr))&&(Strlen(out) + Strlen(newstr) < outlen)) {
    				//查找到目标字符串
    				Strcat(out, newstr);
    				//把新字符串贴到缓冲字符串里
    				i += Strlen(oldstr) - 1;
    				count++;
    		}
    		else { //如果没有找到
    			Strncat(out, in + i, 1);//将该字符写入缓冲字符串数组
    		}
    		if (Strlen(out)+1>= outlen)
    			break;
    	}
    	return count;
    }
    
    
    void test01()
    {
    	int outlen = 14;
    	char* in = "aaabbbccc";
    	char* out = (char*)malloc(outlen);
    	char* oldstr = "cc";
    	char* newstr = "12345678";
    	int ret = str_replace(in,out,outlen,oldstr,newstr);
    	printf("%d\n", ret);
    	printf("%s\n", out);
    }
    
    int main()
    {
    	test01();
    	return 0;
    }