return怎么返回字符串_数据结构的实践心得（字符串管理：mystring）

最新推荐文章于 2023-06-09 03:42:18 发布
最新推荐文章于 2023-06-09 03:42:18 发布
阅读量1.2k 收藏
点赞数
文章标签： return怎么返回字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39813009/article/details/111297149
版权

be5dfa671d55da486f1cbf0417ddd2f8.png

头文件(mystring.h)：

#pragma once

#include "seqList.h"

#define StringERROR -99999999

#define StringNumberLENGTH 20

// 取得字符串长度

int mystrlen(char *s);

// 进行内存初始化

char* mymemset(char *p, char val, size_t size);

// 对字符串进行拷贝

char* mystrcpy(char *s, char *outStr);

// 对字符串转换大写

char* myToUpper(char *s, char *outStr);

// 对字符串转换小写

char* myToLower(char *s, char *outStr);

// 取得字符的索引位置

int indexOf(char *s, char c);

// 取得字符串的索引位置

int indexOfStr(char *s, char *subStr);

// 字符串比较

int myEqual(char *s1, char *s2);

// 字符串比较(s1>s2返回1，s1

int mystrcmp(char *s1, char *s2);

// 字符串连接

char* mystrcat(char **s1Out, char *s2);

// 删除字符串

char* mystrdel(char *sOut, char *delStr);

// 替换字符串

char* myReplace(char *sOut, char oldC, char newC);

// 替换字符串(待替换的字符串长度必须相等)

char* myReplaceStr(char *sOut, char *oldStr, char *newStr);

// 字符串逆序输出

char* myReverse(char *s, char *outStr);

// 分割字符串(必须在外部释放顺序表seqList)

seqList mySplit(char *s, char c, char **strList);

// 字符串转换整型

int myatoi(char *s);

// 字符串转换浮点型

double myatof(char *s);

// 整型转换为字符串

char* myitoa(int num, char *outStr);

// 整型转换为字符串

char* myftoa(double num, char *outStr);

程序文件(mystring.c)：

#include

#include "mystring.h"

// 取得字符串长度

int mystrlen(char *s)

{

if (!s) return -1;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s[i])

{

i++;

}

return i;

}

// 进行内存初始化

char* mymemset(char *p, char val, size_t size)

{

if (!p) return p;

int i;

// 循环初始化内存

for (i = 0; i < size; i++)

{

p[i] = val;

}

return p;

}

// 对字符串进行拷贝

char* mystrcpy(char *s, char *outStr)

{

if ((!s) || (!outStr)) return outStr;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s[i])

{

outStr[i] = s[i]; i++;

}

// 补充结束符

outStr[i] = 0;

return outStr;

}

// 对字符串转换大写

char* myToUpper(char *s, char *outStr)

{

if ((!s) || (!outStr)) return outStr;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s[i])

{

if ((s[i] >= 97) && (s[i] <= 122))

{

outStr[i] = s[i] - 32;

}

else

{

outStr[i] = s[i];

}

i++;

}

// 补充结束符

outStr[i] = 0;

return outStr;

}

// 对字符串转换小写

char* myToLower(char *s, char *outStr)

{

if ((!s) || (!outStr)) return outStr;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s[i])

{

if ((s[i] >= 65) && (s[i] <= 90))

{

outStr[i] = s[i] + 32;

}

else

{

outStr[i] = s[i];

}

i++;

}

// 补充结束符

outStr[i] = 0;

return outStr;

}

// 取得字符的索引位置

int indexOf(char *s, char c)

{

if (!s) return -1;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s[i])

{

if (s[i] == c) break;

i++;

}

return i;

}

// 取得KMP算法的next数组

int* getNext(char *subStr, int subLen, int *outNext)

{

if ((!subLen) ||(!outNext)) return outNext;

// 长度是否有效

if (subLen <= 0) return outNext;

int j = 0, k = -1;

outNext[0] = -1;

while (j < subLen - 1)

{

if ((k == -1) || (subStr[j] == subStr[k]))

{

j++; k++;

// 记录前后缀相等的数量

outNext[j] = k;

}

else

{

k = outNext[k];

}

}

return outNext;

}

// 取得字符串的索引位置

int indexOfStr(char *s, char *subStr)

{

if ((!s) || (!subStr)) return -1;

// 取得待查找的字符串长度

int subLen = mystrlen(subStr);

// 如果长度为空，则退出

if (subLen <= 0) return -1;

// 取得字符串长度

int len = mystrlen(s);

// 如果长度小于待查找的字符串长度，则退出

if (len < subLen) return -1;

// 初始化KMP算法内存

int *next = (int *)malloc(sizeof(int) * subLen);

// 取得KMP算法的next数组

next = getNext(subStr, subLen, next);

int i = 0, j = 0, k;

int index = -1;

int findLen = len - subLen;

// 根据next数组中的值在主串中查找模式

while (i <= findLen)

{

k = i;

// 逐个比较字符

while (s[i] == subStr[j])

{

i++; j++;

// 比较到结束符，则跳出

if (!subStr[j]) break;

}

if (j == subLen)

{

index = k; break;

}

else if (next[j] == -1)

{

i++; j = 0;

}

else

{

j = next[j];

}

}

// 释放KMP算法内存

free(next);

return index;

}

// 字符串比较

int myEqual(char *s1, char *s2)

{

if ((!s1) || (!s2)) return 0;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s1[i])

{

// 一个字符不相等，则判定字符串不相等

if (s1[i] != s2[i]) return 0;

i++;

}

// 最后比较结束符

return (s1[i] == s2[i]);

}

// 字符串比较(s1>s2返回1，s1

int mystrcmp(char *s1, char *s2)

{

if ((!s1) || (!s2)) return -2;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (s2[i])

{

if (s1[i] > s2[i])

{

return 1;

}

else if (s1[i] < s2[i])

{

return -1;

}

i++;

}

// 最后比较结束符

return (s1[i] > s2[i]);

}

// 字符串连接

char* mystrcat(char **s1Out, char *s2)

{

if ((!*s1Out) || (!s2)) return *s1Out;

// 首先取得字符串长度

int len1 = mystrlen(*s1Out), len2 = mystrlen(s2);

// 如果长度为空，则退出

if ((len1 + len2) <= 0) return *s1Out;

// 重新分配内存地址

*s1Out = (char *)realloc(*s1Out, len1 + len2 + 1);

if (!*s1Out) return *s1Out;

int i;

// 循环字符串s2(包括结束符)

for (i = 0; i <= len2; i++)

{

(*s1Out)[i + len1] = s2[i];

}

return *s1Out;

}

// 删除字符串

char* mystrdel(char *sOut, char *delStr)

{

if ((!*sOut) || (!delStr)) return *sOut;

// 取得待删除的字符串长度

int delLen = mystrlen(delStr);

// 如果长度为空，则退出

if (delLen <= 0) return sOut;

// 取得字符串长度

int len = mystrlen(sOut);

// 如果长度小于待删除的字符串长度，则退出

if (len < delLen) return sOut;

// 初始化KMP算法内存

int *next = (int *)malloc(sizeof(int) * delLen);

// 取得KMP算法的next数组

next = getNext(delStr, delLen, next);

int i = 0, j = 0, k, m;

int findLen = len - delLen, tmpLen;

// 根据next数组中的值在主串中查找模式

while (i <= findLen)

{

k = i;

// 逐个比较字符

while (sOut[i] == delStr[j])

{

i++; j++;

// 比较到结束符，则跳出

if (!delStr[j]) break;

}

if (j == delLen)

{

tmpLen = len - k - delLen;

// 循环移动后续的字符内容(包括结束符)

for (m = 0; m <= tmpLen; m++)

{

sOut[k + m] = sOut[k + m + delLen];

}

// 重新比较移动后的字符，重新从第一个字符开始比较

i -= delLen; j = 0;

}

else if (next[j] == -1)

{

i++; j = 0;

}

else

{

j = next[j];

}

}

// 释放KMP算法内存

free(next);

return sOut;

}

// 替换字符串

char* myReplace(char *sOut, char oldC, char newC)

{

if (!sOut) return sOut;

int i = 0;

// 遍历字符数组，一直到结束符为止

while (sOut[i])

{

// 如果等于旧字符，则替换为新字符

if (sOut[i] == oldC) sOut[i] = newC;

i++;

}

return sOut;

}

// 替换字符串(待替换的字符串长度必须相等)

char* myReplaceStr(char *sOut, char *oldStr, char *newStr)

{

if ((!sOut) || (!oldStr) || (!newStr)) return sOut;

// 取得待替换的字符串长度

int oldLen = mystrlen(oldStr), newLen = mystrlen(newStr);

// 如果长度为空，或者替换的字符串长度不相等，则退出

if ((oldLen <= 0) || (oldLen != newLen)) return sOut;

// 取得字符串长度

int len = mystrlen(sOut);

// 如果长度小于待替换的字符串长度，则退出

if (len < oldLen) return sOut;

// 初始化KMP算法内存

int *next = (int *)malloc(sizeof(int) * oldLen);

// 取得KMP算法的next数组

next = getNext(oldStr, oldLen, next);

int i = 0, j = 0, k, m;

int findLen = len - oldLen;

// 根据next数组中的值在主串中查找模式

while (i <= findLen)

{

k = i;

// 逐个比较字符

while (sOut[i] == oldStr[j])

{

i++; j++;

// 比较到结束符，则跳出

if (!oldStr[j]) break;

}

if (j == oldLen)

{

// 循环替换新的字符内容

for (m = 0; m < newLen; m++)

{

sOut[k + m] = newStr[m];

}

// 重新从第一个字符开始比较

j = 0;

}

else if (next[j] == -1)

{

i++; j = 0;

}

else

{

j = next[j];

}

}

// 释放KMP算法内存

free(next);

return sOut;

}

// 字符串逆序输出

char* myReverse(char *s, char *outStr)

{

if ((!s) || (!outStr)) return outStr;

// 首先取得字符串长度

int len = mystrlen(s);

int i;

// 循环字符串的字符内容

for (i = 0; i < len; i++)

{

outStr[i] = s[len - i - 1];

}

// 补充结束符

outStr[i] = 0;

return outStr;

}

// 分割字符串(必须在外部释放顺序表seqList)

seqList mySplit(char *s, char c, char *strList)

{

seqList seq;

// 初始化顺序表(Null)

initializeSeqListNull(&seq);

if ((!s) || (!strList)) return seq;

int len = 0, num = 0;

// 遍历字符数组，一直到结束符为止

while (s[len])

{

// 计算有多少个待分割的字符

if (s[len] == c)

{

strList[len] = 0;

num++;

}

else

{

strList[len] = s[len];

}

len++;

}

// 补充结束符

strList[len] = 0;

// 没有待分割字符则退出

if (num <= 0) return seq;

// 初始化顺序表

initializeSeqList(&seq, num + 1);

// 记录第一个字符串指针地址

insertSeqList(&seq, seq.len, (seqElemType)strList);

int i;

// 循环字符串

for (i = 0; i < len; i++)

{

if (!strList[i])

{

// 记录每个字符串指针地址

insertSeqList(&seq, seq.len, (seqElemType)(strList + i + 1));

}

}

// 返回字符串指针数组(顺序表seqList)

return seq;

}

// 字符串转换为整型

int myatoi(char *s)

{

if ((!s)) return StringERROR;

// 首先取得字符串长度

int len = mystrlen(s);

int numRe = 0;

// 十位的进位

int dec = 1;

// 是否为负数

int minus = 0;

int i;

// 倒序循环字符串

for (i = len - 1; i >= 0; i--)

{

if ((s[i] >= 48) && (s[i] <= 57))

{

// 字符串转数值

numRe += ((s[i] - 48) * dec);

// 十位的进位

dec *= 10;

}

else if (s[i] == '-')

{

minus++;

}

}

// 判断是否为负数(出现了单数个负号)

if ((minus % 2) > 0) numRe = -numRe;

return numRe;

}

// 字符串转换为浮点型

double myatof(char *s)

{

if ((!s)) return StringERROR;

// 取得字符串长度

int len = mystrlen(s);

// 取得小数点的索引位置

int index = indexOf(s, '.');

double numRe = 0;

// 十分位的进位

double frac = 0.1;

// 是否为负数

int minus = 0;

int i;

// 从index开始循环字符串(小数部分)

for (i = index + 1; i < len; i++)

{

if ((s[i] >= 48) && (s[i] <= 57))

{

// 字符串转数值

numRe += ((s[i] - 48) * frac);

// 十分位的进位

frac *= 0.1;

}

else if (s[i] == '-')

{

minus++;

}

}

// 十位的进位

int dec = 1;

// 倒序循环字符串(整数部分)

for (i = index - 1; i >= 0; i--)

{

if ((s[i] >= 48) && (s[i] <= 57))

{

// 字符串转数值

numRe += ((s[i] - 48) * dec);

// 十位的进位

dec *= 10;

}

else if (s[i] == '-')

{

minus++;

}

}

// 判断是否为负数(出现了单数个负号)

if ((minus % 2) > 0) numRe = -numRe;

return numRe;

}

// 整型转换为字符串

char* myitoa(int num, char *outStr)

{

if ((!outStr)) return outStr;

char tmp[StringNumberLENGTH] = { 0 };

// 被除数

int div = num;

// 先转换为绝对值

if (div < 0) div = -div;

// 索引

int i = 0;

// 余数

int mod;

while (div > 0)

{

// 按位计算余数

mod = div % 10;

// 记录余数(数值转字符串)

tmp[i] = mod + 48;

// 按位计算被除数

div /= 10;

i++;

}

// 负数补充负号“-”

if (num < 0)

{

tmp[i] = '-'; i++;

}

// 对字符串逆序输出

return myReverse(tmp, outStr);

}

// 整型转换为字符串

char* myftoa(double num, char *outStr)

{

if ((!outStr)) return outStr;

char tmp[StringNumberLENGTH] = { 0 };

// 被除数

double div = num;

// 先转换为绝对值

if (div < 0) div = -div;

// 整数部分

int divInt = div;

// 小数部分

double divDec = div - divInt;

// 索引

int i = 0;

// 余数

int mod;

// 整数部分

while (divInt > 0)

{

// 按位计算余数

mod = divInt % 10;

// 记录余数(数值转字符串)

tmp[i] = mod + 48;

// 按位计算整数部分

divInt /= 10;

i++;

}

// 负数补充负号“-”

if (num < 0)

{

tmp[i] = '-'; i++;

}

// 对整数部分逆序输出

outStr = myReverse(tmp, outStr);

// 如果有小数则补充小数点“.”

if (divDec > 0)

{

outStr[i] = '.'; i++;

int count = 0;

// 小数部分

do 

{

// 按位计算小数部分

divDec *= 10;

// 按位取整

mod = divDec;

// 记录小数(数值转字符串)

outStr[i] = mod + 48;

// 重算小数

divDec -= mod;

// 小数最多只转换六位(避免浮点数小数一直不为零)

i++; count++;

}

while ((divDec > 0) && (count < 6));

// 补充结束符

outStr[i] = 0;

}

return outStr;

}

weixin_39813009
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言常见问题--return返回字符串
小豹Miss鲍的博客
03-24 5827
C语言常见问题–return返回字符串 问题来源： 想 C语言函数 返回（字符串）数据。 一、问题来源 demo： #include <stdio.h> #include <string.h> #include <stdlib.h> char * test() { char str[10] = {0}; strcpy(str, "abc"...
C语言return的返回值问题（字符串）
Shuimanjing的博客
07-28 3025
C语言return字符串
return怎么返回字符串_LintCode 题解丨微软面试题：字符串查找
weixin_39592137的博客
12-05 138
对于一个给定的 source 字符串和一个 target 字符串，你应该在 source 字符串中找出 target 字符串出现的第一个位置(从0开始)。如果不存在，则返回 -1。 在线评测地址：LintCode 领扣​www.lintcode.com说明在面试中我是否需要实现KMP算法？不需要，当这种问题出现在面试中时，面试官很可能只是想要测试一下你的基础应用能力。当然你需要先跟面试官确认清楚要...
return怎么返回字符串_【前端冷知识】如何正确判断一个字符串是数值？
weixin_39796116的博客
12-06 696
在网页中，我们从用户输入的内容中获取的值通常是字符串，但是有时候我们希望用户输入的内容一定要能转成数值：<inputid="userInput">userInput.addEventListener('change',(e)=>{constvalue=e.target.value;console.log(typeofvalue);// stri...
return 返回字符串
weixin_30693183的博客
10-27 835
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 6 namespace ConsoleApplication3 7 { 8 /*******************************************...
MyString_string_字符串处理_
09-30
string字符串处理，包括运算符重载、字符串拼接、倒序输出等。
C++类的封装之 字符串MyString类
01-06
mystring.h #ifndef MYSTRING_H #define MYSTRING_H #include using namespace std; class MyString { friend ostream& operator<>(istream& in,MyString& ob); private: char *str; int size; public: ...
数据结构实验报告 字符串.doc
09-29
四、实验原始纪录（源程序、数据结构等） public final class MyString implements Comparable<MyString>, java.io.Serializable { private final char[] value; //字符数组，私有最终变量，只能赋值一次 public ...
封装一个,完善字符串，字符串的基本操作
05-05
必须实现如下操作，字符串比较、求串的长度、判断串是否为空、将串置空、字符串赋值（包括两个字符串类复制，一个字符串赋值到CmyString对象）、求字符串中的一个字符或改变字符串中的一个字符（采用重载[]），完成...
最常见和最有用的字符串相关的方法详解
12-01
转换字符串 你可以转换一个数字，布尔值，或一个字符串的对象： var myNumber = 24; // 24 var myString = myNumber.toString(); // "24" var myNumber = 24; // 24 var myString = String(myNumber); // "24" 将...
C语言实现返回字符串函数的四种方法
12-25
前言 C语言返回字符串函数共有四种方式，分别如下：       使用堆空间，返回申请的堆地址，注意释放       函数参数传递指针，返回该指针       返回函数内定义的静态变量（共享）       返回全局变量 下面来看看详细的介绍 其实就是要返回一个有效的指针，尾部变量退出后就无效了。 使用分配的内存，地址是有效 char *fun() { char* s = (char*)calloc(100, sizeof(char*) ); if (s) strcpy ( s , "abc " ); return s; } 但这种方式需要注意，必须由使
return怎么返回字符串_JavaScript Api系列之字符串方法操作集合(match、模版字符串、隐式包装)...
weixin_39729837的博客
12-03 897
前言 字符串是一个或多个字符的序列，可以由字母，数字或符号组成。JavaScript 中的字符串是基本数据类型，在业务开发中，单独操作字符串的场景相对较少，但却是不可忽略的基础，本文整理了比较常用的字符串方法，希望本文对你有所帮助。常用的String原型方法 字符串包含includes检查字符串是否包含指定的字符conststr='你好，欢迎来到海洋里的魔鬼鱼';console.l...
43. Multiply Strings
weixin_40801853的博客
07-12 108
将两字符串转换为数字，相乘转化为字符串返回 class Solution(object): def multiply(self, num1, num2): """ :type num1: str :type num2: str :rtype: str """ n1 = 0 ...
return返回值问题和字符串问题
chengchaonan的博客
04-07 3602
在 C 语言中下面那个语句的结果是 1 ？ 1.return 7&1; 2.char *p="hello"; return p == "hello"; 首先，这两条语句的返回值都是1，因为如果return的表达式中有计算，需要先计算出结果。 对于char *p="hello",在常量区存放这个字符串，指针p指向这个字符串，也就是指针p中存放的是hello字符串的地址，...
chatgpt赋能python：Python如何返回字符串：从基础概念到高级技巧
最新发布
tutan123321的博客
06-09 598
在Python中，字符串是指由字符组成的有序集合，用于表示文本。name = 'Alice' # 单引号address = "123 Main St" # 双引号memo = '''这是一个长文本，包含多行文字。''' # 三引号在Python中，字符串是不可变对象，也就是说，一旦创建就不能修改。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT。
函数 return，文档字符串，函数作用域和命名空间以及递归函数详解
weixin_46700209的博客
02-03 372
1.函数的返回值 1.返回值就是函数以后返回的结果 2.通过return来指定函数的返回值 3.return后面可以跟任意的函数 *其中return r的返回值 和print（fun（1，2，3，4））的值相同 因为函数fun2（）没有返回值所有时None 1.return的特性 在函数中，return后面的代码都不会执行，return一旦执行，函数自动结束 2.文档字符串 也可以叫做长字符串 运用于对函数或者面向对象做功能，参数等说明帮助文档 help（print） help（input）等
c语言return 11,《数据结构》(C语言版)实验11.doc
weixin_31869917的博客
05-19 171
最新精品文档，知识共享！！PAGE《数据结构》实验信息工程学院2015预备实验 C语言的函数数组指针结构体知识一、实验目的1、复习C语言中函数、数组、指针、结构体与共用体等的概念。2、熟悉利用C语言进行程序设计的一般方法。二、实验预习说明以下C语言中的概念函数：数组：3、指针：4、结构体5、共用体三、实验内容和要求1、(1)调试以下程序：输出100以内所有的素数(用函数实现)。#include...
返回字符串的四种方法
qq_41557631的博客
12-05 3531
看到一篇好文章，但是菜鸡不会转载，只好截图贴过来了。。。下面是原博客的链接。 https://blog.csdn.net/luna_zhan/article/details/80433196
【数据结构与算法】回溯算法
your_棒棒糖的博客
04-23 101
回溯法框架 1、 路径： 也就是已经做出的选择。 2、 选择列表： 也就是你当前可以做的选择。 3、 结束条件： 也就是到达决策树底层， ⽆法再做选择的条件。 回溯法框架： result = [] def backtrack(路径, 选择列表): if 满⾜结束条件: result.add(路径) return for 选择 in 选择列表: 做选择 backtrack(路径, 选择列表) 撤销选择 回溯法核心框架 for 选择 in 选择列表: # 做选择 将该选择从选择列表移除
设计实现一个字符串类mystring
05-12
// 返回字符串长度 bool empty() const; // 判断字符串是否为空 void clear(); // 清空字符串 const char* c_str() const; // 返回C风格字符串 mystring& operator=(const mystring& s); // 赋值运算符重载 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值