字符串

最新推荐文章于 2024-05-28 10:28:45 发布
最新推荐文章于 2024-05-28 10:28:45 发布
阅读量448 收藏
点赞数
分类专栏： 数据结构算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/twxyz123/article/details/9464931
版权

MyString.h

//MyString.h

#ifndef MYSTRING_H
#define MYSTRING_H

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXSIZE 100

/**链表存储**/
typedef struct StrNode
{
	char ch;
	struct StrNode *next;
	int length;
}StrNode;

/******顺序表存储******/
typedef struct HString
{
	char ch[MAXSIZE];
	int length;
}HString;
void StrCreat(HString *T);//创建一个字符串，放入T中
void StrOut(HString *T);
void StrAssign(HString *T,char *chars);//生成一个其值等于常量chars的串T
int StrLength(HString S);//返回S的元素个数
int StrCompare(HString S,HString T);//两个串比较输出两串的长度差//如果两串相同，则输出111

void clearStr(HString *S);
void concat(HString *T,HString S1,HString S2);
void SubStr(HString *Sub,HString S,int pos,int len);//用sub返回串S的第pos个字符起长度为len的子串
												//Sub=(HString *)malloc(sizeof(HString));
int Index(HString S,HString T,int pos);//返回主串S中第pos个字符之后的存在与T
									//相等的第一个子串的 位置
void StrInsert(HString *S,int pos, HString T);//在串的的pos个字符之前插入串T
void StrDelete(HString *S,HString T);//从串S中删除与T相同所有的字符串
void StrReplace(HString *S,HString T,HString V);//用V替换S中所有T的字符
void StrCopy(HString *s,HString *h);

StrNode *LStrAssign();//链表创建一个字符串
void printStr(StrNode *S);//输出
void Strreplace(StrNode *S,StrNode T,StrNode V);//替换   ERROR

#endif

MyString.cpp 

//

//MyString.cpp

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"MyString.h"

/***********************检测完毕************1****************/
void StrCreat(HString *T)//创建一个字符串，放入T中
{  

	char c;
	int j=0;
	printf("\n请输入一个字符串，以*作为结束：");
	scanf("%c",&c);
	while(c!='*' && j<MAXSIZE)
	{
		T->ch[j]=c;
		j++;
		scanf("%c",&c);
	}
	T->ch[j]='\0';
	T->length=j-1;

}

/***********************检测完毕**********2******************/
void StrOut(HString *T)
{
	printf("\n");
	printf("字符串是%s\t**长度是%d\n",T->ch,T->length);
}


void StrAssign(HString *T,char *chars)//生成一个其值等于常量chars的串T
{
	int i,j;char c[MAXSIZE];i=0;
	if(T->ch)free(T->ch);
	if(!(T=(HString *)malloc(sizeof(HString))))printf("ERROR");
	while(c[i]){c[i]=*chars;chars++;i++;printf(" %c ",c[i]);}
	if(i==0) printf("NULL");
	else{
		for(j=0;j<=i;j++)
		{T->ch[j]=c[j];}
		T->ch[j+1]='\0';
		T->length=i;

	}
}

int StrLength(HString S)//返回S的元素个数
{
	return (S.length);
}


/***************************检测完毕*********************/                                          
int StrCompare(HString S,HString T)//两个串比较输出两串的长度差
{                                  //如果两串相同，则输出111

	int i;i=0;

	while(i<S.length && i<T.length)
	{
		i++;
		if(S.ch[i]!=T.ch[i]) 
			return (S.length-T.length);
		else 
			return 111;//两个串相等，返回111
	}
}

void clearStr(HString *S)
{
	if(S->ch){free(S->ch);}//S->ch=NULL;}
	S->length=0;
}

/***************************检测完毕*********************/   
void concat(HString *T,HString S1,HString S2)//用T返回由S1和S2连接而成的新串
{

	int i;
	if(T->ch) free(T->ch);
	if(S1.length+S2.length<=MAXSIZE)
	{for(i=0;i<=S1.length;i++) {T->ch[i]=S1.ch[i];}
	for(i=S1.length+1;i<=S1.length+S2.length;i++)  {T->ch[i]=S2.ch[i-S1.length];}
	T->ch[S1.length+S2.length+1]='\0';
	T->length=S1.length+S2.length;
	}
	else printf("OVERFLOW");
}

/****************************检测完毕******************************/
void SubStr(HString *Sub,HString S,int pos,int len)
{//用sub返回串S的第pos个字符起长度为len的子串
	//Sub=(HString *)malloc(sizeof(HString));

	int i;
	if(pos<1 || pos>S.length || len<0 || len>S.length-pos-1)
		printf("ERROR");
	if(Sub->ch)  free(Sub->ch);
	if(!len){/*Sub->ch=NUL;*/ Sub->length=0;}
	else
	{for(i=0;i<=len-1;i++){Sub->ch[i]=S.ch[pos+i];}
	Sub->ch[len]='\0';
	Sub->length=len;
	}
}

/***************************检测完毕*******************************/
int Index(HString S,HString T,int pos)//返回主串S中第pos个字符之后的存在与T
{                                      //相等的第一个子串的 位置
	int i,n,m,j,flag,k=0;
	//HString *sub;
	//sub=(HString *)malloc(sizeof(HString));
	if(pos>0)
	{
		n=S.length;
		m=T.length;
		i=pos;
		while(S.ch[i]!='\0')
		{
			i++;k=i;
			for(j=0;j<m;j++)
			{
				//printf("#%c#",S.ch[i+j]);
				//printf("\t!%c!\t",T.ch[j+1]);
				if(S.ch[i+j]==T.ch[j+1]) flag=1;
				else flag=0;
			} 
			if(flag==0) continue;

			if(flag==1)break;
			//return i;


			// return i;
		}
	}
	return k;
}

/*******************检测完毕****************************/
void StrInsert(HString *S,int pos, HString T)
{//在串的的pos个字符之前插入串T

	int j,ns,ms,k,n;
	n=0;
	ns=S->length;
	ms=T.length;
	if(pos<1 || pos>S->length+1)
		printf("ERROR");
	if(T.length)
	{
		//if (!(S->ch=(char *)realloc(S->ch,(S->length+T.length+1) *sizeof(char)))
		//printf("ERROR");   
		/*for(i=S->length+1;i>pos+1;--i)
		{ S->ch[i+T.length]=S->ch[i];}
		for(i=0;i<T.length;i++)
		{S->ch[pos+i]=T.ch[i];}
		S->length+=T.length;*/
		k=ns+ms+1;
		for(j=ns+1;j>=pos;k--,j--)
		{S->ch[k]=S->ch[j];}
		for(k=1;k<=ms && T.ch[n]!='\0';k++)
		{S->ch[pos+k-1]=T.ch[k];
		++n;
		}
		S->length+=T.length;
	}
}

/********************检测完毕******************************/
void StrDelete(HString *S,HString T)
{//从串S中删除与T相同所有的字符串

	int ns,nt,i,flag,n;
	n=0;
	ns=S->length;
	nt=T.length;
	if(nt>ns || ns<0 || nt<0) printf("ERROR");
	//for(n=0;n<ns;n++)
	while(S->ch[n]!='\0')
	{
		n++;
		for(i=0;i<nt;i++)
			if(S->ch[n+i]==T.ch[i]) flag=1;
			else flag=0;


			if(flag==1)
			{
				for(i=0;i<ns;i++)
				{
					//printf("&%c&",S->ch[n+i+1]);
					S->ch[n+i+1]=S->ch[n+nt+i+1];
					//printf("#%c#",S->ch[n+i+1]);
				}//for
				printf("\t\t");
				ns=ns-nt;
				S->ch[ns+i]='\0';
				n=0;
				S->length=ns;
			}
			//else printf("你要删除的字符不存在！");
	}
}

/******************检测完毕**********************************/
void StrReplace(HString *S,HString T,HString V)
{//用V替换S中所有T的字符
	int ns,nt,nv,nc,i,flag,n,j=0;
	n=0;
	ns=S->length;
	nt=T.length;
	nv=V.length;
	nc=nt-nv;
	if(nt>ns || ns<0 || nt<0 || nv<0 || nv>ns) printf("ERROR");
	//for(n=0;n<ns;n++)
	while(S->ch[n]!='\0')
	{
		n++;
		for(i=0;i<nt;i++)
		{if(S->ch[n+i]==T.ch[i]) flag=1;
		else flag=0;}


		if(flag==1)
		{
			if(nt==nv)//完成
			{

				for(i=0;i<nv;i++)
				{printf("#%c#",S->ch[n+i+1]);
				S->ch[n+i+1]=V.ch[i+1];
				printf("\t\t!%c!\t\t",V.ch[i+1]);}
			}
			if(nv>nt)//abcdefghijk* de* abcd*  错误
			{
				for(i=ns-nc;i>n+nv;i--)
				{
					//printf("#%c#",S->ch[i]);
					S->ch[i]=S->ch[i+nc];//printf("\t!%c!\t",S->ch[i]);
				}

				//printf("\n/*************************/\n");
				for(j=0;j<nv;j++)
				{
					//printf("#%c#",S->ch[n+j+1]);
					S->ch[n+j+1]=V.ch[j+1];//printf("\t\t!%c!\t\t",S->ch[n+j+1]);
				}
				ns=ns+nv-nt;
				S->ch[ns-nc+1]='\0';
				S->length=ns;
			}
			if(nv<nt)//完成
			{
				while(V.ch[j+1]!='\0')
				{//printf("#%c#",S->ch[n+j+1]);
					S->ch[n+j+1]=V.ch[j+1];//printf("\t\t!%c!\t\t",S->ch[n+j+1]);
					j++;
				}
				printf("\n/*************************/\n");
				for(i=n+nt;i<=ns;i++)
				{
					//printf("#%c#",S->ch[i+1-nc]);
					S->ch[i+1-nc]=S->ch[i+1];//printf("\t\t!%c!\t\t",S->ch[i+1]);
				}
				S->length=S->length+nv-nt;
				S->ch[S->length+1]='\0';
				j=0;
			}
		}
		//else printf("你要找的字符不存在！");

	}
}

void StrCopy(HString *s,HString *h)
{
	int i;i=0;
	if(s->ch)  free(s);
	s=(HString *)malloc(sizeof(HString));
	while(h->ch[i]!='\0')
	{
		s->ch[i]=h->ch[i];i++;
	}
	s->ch[i]='\0';
	s->length=h->length;
}

/*********************检测完毕*****************************/
StrNode *LStrAssign()
{//链表创建
	StrNode *S,*p,*r;
	char c;
	int i=0;
	S=r=NULL;
	printf("\n\n\t\t请输入一个字符串，已*作为结束：");
	c=getchar();
	while(c!='*')
	{
		i++;
		p=(StrNode *)malloc(sizeof(StrNode));

		p->ch=c;
		if(S==NULL) S=p;
		else r->next=p;
		r=p;
		c=getchar();
	}
	if(r) r->next=NULL;
	S->length=i-1;
	return S;
}

/***********************检测完毕***************************/
void printStr(StrNode *S)
{
	StrNode *p;
	p=S;
	printf("\n输入的字符串是：");
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%c",p->ch);

	}
	printf("\n字符串的长度是：%d\n",S->length);
}

void Strreplace(StrNode *S,StrNode T,StrNode V)
{//用V替换S中T的所有字符
	int ls,lt,lv,flag;//分别为S、T、V的长度
	StrNode *p,*q,*n,*p1,*p2,*q1;
	p=S;q=&T;n=&V;
	ls=S->length;
	lt=T.length;
	lv=V.length;
	while(p->next!=NULL)
	{
		p=p->next;
		p1=p;q1=q->next;
		while(q->next)
		{
			if(p1->next->ch==q1->ch) flag=1;
			else flag=0;
			p1=p1->next;q1=q1->next;
			p1=p1->next;
		}
		if(flag==1)
		{
			p->next=n;
			while(n->next){n=n->next;}
			n->next=p2;
		}
		S->length=S->length-T.length+V.length;
	}
}

测试程序main.cpp 

#include<stdio.h>
#include<malloc.h>
#include <malloc.h>
#include "MyString.h"

void main()
{
	char choice,*cs;int l,a,b,c,d;
	HString *th,*ch,*sh,*xh,s,*sub;
	StrNode *ss,*ts,*vs;char chs;
	do
	{//cs=(char *)malloc(100*sizeof(char));
		printf("选择要进行的操作 \n");
		printf("======================================\n");
		printf("\t\t1.构建一个字符串\n");//完成
		printf("\t\t2.返回字符串的长度\n");//完成
		printf("\t\t3.两个字符串相比较\n");//完成
		printf("\t\t4.连接两个字符串\n");//完成
		printf("\t\t5.取出字符\n");//完成
		printf("\t\t6.从T字符串删除S字符串\n");//完成
		printf("\t\t7.从s中返回第i个与t相等的字符的位置\n");//完成
		printf("\t\t8.在串的的pos个字符之前插入串T\n");//完成
		printf("\t\t9.替换字符\n");
		printf("\t\ta.字符串初始化\n");//链式存储  完成
		printf("\t\tb.复制一个字符串\n");
		printf("\t\t0.退出\n");
		printf("======================================\n");

		printf("(0,1,2,3,4,5,6,7,8,9)");
		th=(HString *)malloc(sizeof(HString));
		sh=(HString *)malloc(sizeof(HString));
		ss=(StrNode *)malloc(sizeof(StrNode));
		choice=getchar();
		switch(choice)
		{case '1':StrCreat(th);StrOut(th);
		break;
		case '2':StrCreat(th);StrOut(th);
			l=StrLength(*th);
			printf("%d\n",l);
			break;
		case '3':StrCreat(th);StrOut(th);
			StrCreat(sh);StrOut(sh);
			l=StrCompare(*th,*sh);
			if(l!=111){printf("长度比较结果是%d\n",l);}
			else printf("两字符串完全相同！");
			break;
		case '4':xh=(HString *)malloc(sizeof(HString));
			ch=(HString *)malloc(sizeof(HString));
			StrCreat(xh);StrOut(xh);
			StrCreat(ch);StrOut(ch);
			concat(sh,*xh,*ch);
			StrOut(sh);
			break;
		case '5':StrCreat(&s);StrOut(&s);
			sub=(HString *)malloc(sizeof(HString));
			printf("取出的位置与长度：");
			scanf("%d%d",&a,&b);
			SubStr(sub,s,a,b);
			StrOut(sub);
			break;
		case '6':StrCreat(th);StrOut(th);
			StrCreat(sh);StrOut(sh);
			StrDelete(th,*sh);
			StrOut(th);
			break;
		case '7':printf("主串：\n");
			StrCreat(th);StrOut(th);
			printf("要找的字符：\n");
			StrCreat(sh);StrOut(sh);
			printf("第i个，i=\n");scanf("%d",&c);
			l=Index(*th,*sh,c);
			printf("你找的字符所在位置为%d\n",l);
			break;
		case '8':StrCreat(th);StrOut(th);
			printf("插入的字符串：");
			StrCreat(sh);StrOut(sh);
			printf("插入位置");scanf("%d",&d);
			StrInsert(th,d,*sh);
			StrOut(th);
			break;
		case 'a':
			ss=LStrAssign();
			printStr(ss);
			break;
		case '9':/*ss=LStrAssign();
				 printStr(ss);
				 printf("要替换的字符："); ts=LStrAssign();
				 printf("替换成：");vs=LStrAssign();
				 StrReplace(ss,*ts,*vs);
				 printf("替换后的字符串是："); printStr(ss);*/
			StrCreat(th);StrOut(th);
			printf("要替换的字符：");StrCreat(sh);
			ch=(HString *)malloc(sizeof(HString));
			printf("替换成：");StrCreat(ch);
			StrReplace(th,*sh,*ch);
			printf("替换后的字符串是：");StrOut(th);
			break;
		case 'b':
			StrCreat(th);StrOut(th);
			StrCopy(sh,th);
			StrOut(sh);
			break;
		case '0':return;
		}
		printf("\n\n\t\t==按任意键返回主菜单==\n\t\t");
		fflush(stdin);
		scanf("%c",&chs);
	}while(choice!='0');
}


twxyz123
关注
专栏目录
数据结构理论基础-4—字符串
toutuo
11-27 827
Table of Contents 串 串的存储结构 朴素的模式匹配算法 KMP模式匹配算法 KMP模式匹配算法改进 C语言具体实现见：数据结构C语言实现-4—字符串 串 串（string）是由零个货多个字符组成的有限序列，又名叫字符串 一般记为：，其中，s 是串的名称，可以是字母、数字或其他字符，i 就是该字符在串中的位置。串的长度为 n。 串的抽象数据类型 ADT串（s...
数据结构：串、数组和广义表
qq_63042305的博客
10-17 1624
学习数据结构后总结了串，数组和广义表的基础内容,如存储结构，和相关的基本算法（如KMP算法与BF算法）
遍历字符串
GM2460080540的博客
08-09 3201
遍历字符串 要求： 键盘录入一个字符串，使用程序实现在控制台遍历该字符串 思路： 1.键盘录入一个字符串，用scanner实现 2.遍历字符串，首先哟啊能够获取到字符串中的每一个字符： public char charAt（int index）：返回指定索引处的char值，字符串的索引也是从0开始的 3.遍历字符串，其次要能够获取到字符串的长度 public int length（）：返回此字符串的长度 数组的长度：数组名.length 字符串的长度：字符串对象.length（） 字符串遍历通用格式： f
字符串排序
巨星博客
10-23 3946
1.在主函数中输入10个字符串，用另一个函数排序，在主函数中输出排好序的字符串；用指针数组处理； 解：首先要解决一个问题，怎么输入多个字符串？ //可以用指针数组保存多个字符串常量； char *str[] = {"China","Japan","America", "Korea","England","Germany", "France","Russia","...
模板字符串
qq_53716634的博客
11-27 1464
模板字符串
c++中字符串常见操作
Lucinda6的博客
05-27 4554
c++中字符串常见操作1.字符串赋值①用等号赋值②用C语言风格的字符串进行赋值③拷贝构造④多个重复项构造⑤用函数进行赋值2.字符串拼接①用+进行拼接②用函数进行拼接3.字符串查找子串4.字符串替换5.字符串比较6.字符串存取7.修改单个字符,只能修改单个字符8.字符串的插入9.字符串的删除子串操作10.获取字符串子串 1.字符串赋值 ①用等号赋值 string str1 = "hello world"; str1 = "你好，世界"； str = 'h'; 在定义字符串时，就可以直接对其进行赋值；后边还可
C中字符串常量&字符数组&字符常量
wuwuku123的博客
12-17 4万+
在 C 语言中，字符串有两种存储方式，一种是通过字符数组存储，另一种是通过字符指针存储。 一、字符常量： 一个用单引号括起来的单个字符（或字符转义序列或三字母词） 实质（含义）：是一个整形值。属于四大基本数据类型（分别是整型，浮点型，指针，聚合类型）中的整型（integers）。 C语言字符常量与字符串常量 备注：字符常量和字符变量： 字符常量字符常量是用单引号括起来的一个字符，...
字符串常量池
编程就像打游戏，编出一个项目就打过了一个BOSS
10-08 4124
字符串常量池详解
字符串的长度
weixin_52985599的博客
01-07 2554
实验7-8 字符串的长度 题目来源：江西理工大学OJ 题目地址：http://oj.jxust.edu.cn/problems/1218 题目描述 设计函数，求一个字符串的长度。在主函数中输入字符串，并输出其长度。 输入 输入一个字符串 输出 输出该字符串的长度 样例输入 123456789！@# % 样例输出 15 这个题题目本来就有函数可以用的，所以感觉有点“脱裤子放屁”（画蛇添足）的感觉，但是题目要求我们这么做了，那我们就按它说的办。 上代码！！ #include <bits/stdc++.h&
字符串连接
CSDNChinaLUCKY的博客
03-20 1万+
分别用以下两种方法，将字符串srcStr连接到字符串dstStr的尾部。 （1）调用库函数，实现字符串的连接 （2）不调用库函数，实现字符串的连接 提示：先找到字符数组dstStr中存放字符串结束符’\0’的位置，再将字符数组srcStr中的字符依次复制到字符数组dstStr中。 注意： （1）连接后的字符串必须有结束标志’\0’。 （2）字符数组dstStr应定义的足够大，以便能存放连接后的字符串。 #include<stdio.h> #include<str.
Python3中将\uXXXX字符串转换为可见字符串的解决方案
热门推荐
weixin_43178406的博客
03-24 5万+
本文主要介绍了Python3中将\uXXXX字符串转换为可见字符串的解决方案，希望能对新手有所帮助。下图为成功转换后的截图，具体转换方法和代码见下文。 文章目录 1. 问题描述 2. 原理详解 3. 解决方案
C/C++ 检查一个字符串是否为另一个字符串的子字符串算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-27 7699
检查一个字符串是否为另一个字符串的子字符串的算法，可以使用两个指针来遍历两个字符串，同时比较对应位置上的字符是否相同，直到找到完全匹配或者其中一个字符串结束。
C/C++ 确定一个字符串是否是另一个字符串的排列算法详解及源码
最新发布
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-28 7459
确定一个字符串是否是另一个字符串的排列，首先需要理解什么是字符串的排列。字符串的排列是指将字符串中的字符重新排列，形成一个新的字符串。如果两个字符串包含相同的字符，但顺序不同，则它们是彼此的排列。这种算法的优点是简单高效，时间复杂度为O(n)，其中n为字符串的长度。同时，使用哈希表可以快速统计字符出现的次数。
C/C++ 字符串压缩算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-27 7707
Run-Length Encoding (RLE)：将连续重复出现的字符或字符序列用一个计数值和该字符表示。例如，字符串 “AAAABBBCCDAA” 可以被压缩为 “4A3B2C1D2A”。字符串压缩算法是一种用于减少字符串所占用存储空间的技术。其基本思想是将重复出现的字符或字符序列用更短的方式表示，从而减少存储空间的使用。Huffman 编码：根据字符出现的频率构建 Huffman 树，将出现频率高的字符用较短的编码表示，从而减少存储空间的使用。
字符串变换最小字符串
程序员阿甘的博客
10-28 7170
已支持（Java & JS & Python & C & C++），考察：逻辑分析
家谱树-树的利用
twxyz123的专栏
07-25 989
#include #include #include #include #define MAXSIZE 20 typedef struct TreeNode { int Num;//记录这个人的子女数 char name[20];//姓名 struct TreeNode *NextNode[MAXSIZE+1];//记录儿女结点 struct TreeNode *parent;/
顺序表
twxyz123的专栏
07-25 593
//MyList.h #ifndef MYLIST_H #define MYLIST_H #include #include #define MAXSIZE 20 typedef int ElemType; typedef struct { ElemType a[MAXSIZE]; int length; }SqList; void creat_list(SqList *L);//创
表达式求值-栈的利用
twxyz123的专栏
07-25 566
栈的功能 //栈的顺序存储 //stack.h #include #include #define MAXSIZE 100 typedef char ElemType; typedef struct //SqStack { ElemType a[MAXSIZE]; int top; }SqStack; void init_s(SqStack *s) { s=(SqStack *)m
文件操作
twxyz123的专栏
07-25 492
// ttt.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include #include typedef struct FileHead { double iVersion; char AuthorName[20]; long fileLen
Matlab字符串操作详解
此外，MATLAB还提供了丰富的字符串函数，如 `strfind`（查找子字符串）、`strcat`（连接字符串）、`strrep`（替换子字符串）等，用于更复杂的字符串处理和分析。理解并熟练运用这些功能，可以帮助用户在MATLAB环境中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值