关于串的学习

已于 2023-02-18 13:34:46 修改
阅读量1.9k 收藏 7
点赞数 2
分类专栏： 数据结构（王道） 文章标签： 学习 java jvm
于 2022-10-26 00:25:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/127524551
版权

目录

一、定义

二、基本操作

（一）存储结构

（二）初始化

（三）检查空间 

（四）串赋值（把一个字符串常量赋值给顺序串S,成功返回true,否则返回FALSE，赋值前需要判空）

（五）串赋值（将T串赋给S）

（六）取子串（串S中从第pos个位置开始，取长度为len的子串T）

（七）子串定位（串的模式匹配：主串S中查找是否存在和串T值相同的子串，若存在返回true，否则返回false）

（八）插入子串（在第pos个元素之后插入子串）

（九）串连接（将顺序串T连接在顺序串S之后）

（十）删除子串

（十一）求串长

（十二）遍历

三、完整代码

四、完整代码2

一、定义

  • 串是零个或多个任意字符组成的有限序列
  • 串的特点：
  •       串是一种特殊的线性表，数据元素之间呈线性关系
  •       串是数据对象限定为字符集（如中文字符、英文字符、数字字符、标点符号等）
  • 子串：串中任意个连续字符组成的子序列称为该串的子串
  •         例如："abcde"的子串有：""、"a"、"ab"、"abc"、"abcd"和"abcde"等
  • 真子串：是指不包含自身的所有子串。
  • 主串：包含子串的串相应地称为主串。
  • 字符位置：字符在序列中的序号为该字符在串中的位置。
  • 子串位置：子串的第一个字符在主串中的位置。
  •            例如a='BEI'  b='BEIJING'，a在b中的位置是1
  • 空格串：由一个或多个空格组成的串，与空串不同。空串不含有任何字符。
  • 串相等：当且仅当两个串的长度相等并且各个对应位置上的字符都相等时，这两个串才是相等的。但是所有空串是相等的。 
  • 注意：
  • 串是一种线性表。
  • 串和线性表的不同点：
    • 串的数据元素是字符，即每个数据元素都是一个字符。
    • 线性表的操作主要是针对某个数据元素进行的，而串的操作则主要是针对串的整体或某一部分子串进行的 

二、基本操作

（一）存储结构

//静态存储
#define MaxLen 255
typedef struct
{
	char ch[MaxLen];//每个分量存储一个字符
	int length;//串的实际长度
}SString;

//动态存储
typedef struct
{
	char* ch;
	int Length;//实际长度
	int capacity;//最大容量
}SString;

以下操作针对动态存储 

（二）初始化

bool StrInit(SString& S)//初始化
{
	S.ch = NULL;
	S.Length =S.capacity= 0;
	return true;
}

（三）检查空间 

bool Check(SString& S)//检查空间容量
{
	if (S.capacity == S.Length)
	{
		int newcapacity = S.capacity == 0 ? 4 : S.capacity * 2;
		char* temp = (char*)realloc(S.ch, newcapacity * sizeof(char));
		if (temp == 0)
		{
			cout << "开辟空间失败！" << endl;
			exit(-1);
		}
		else
		{
			S.ch = temp;
			S.capacity = newcapacity;
		}
	}
	return true;
}

（四）串赋值（把一个字符串常量赋值给顺序串S,成功返回true,否则返回FALSE，赋值前需要判空）

bool StrAssign(SString& S, char* chars)//一个字符串常量赋值给顺序串S
{
	int i, j;
	char* c;
	for (i = 0, c = chars; *c; i++, c++);//计算一个字符串常量的长度
	if (i == 0)//说明字符串常量是0，就不用给SString开辟空间
		return false;
	else
	{
		Check(S);
		for (j = 0; j < i; j++)
		{
			S.ch[j] = chars[j];
			S.Length = i;
		}
	}
	return true;
}

（五）串赋值（将T串赋给S）

bool StrCopy(SString& S, SString T)
{
	if (S.ch != NULL)//先释放掉原来的空间
	{
		S.ch= NULL;
		free(S.ch);//注意此处虽然free函数进行了动态内存的释放和回收，但实际中未完全释放，S.ch依然会指向
		//动态开辟的空间，而非指向NULL。当第一次使用完空间，如果未退出继续运行代码，再次赋值就会发生错误，
		//只需在free函数前把S.ch进行赋值NULL操作即可
	}
	if (S.Length != 0)
	{
		StrInit(S);
	}
	for (int i = 0; i < T.Length; i++)
	{
		Check(S);
		if (S.ch == NULL)
			return false;
		S.ch[i] = T.ch[i];
		S.Length = T.Length;

	}
	return true;
}

（六）取子串（串S中从第pos个位置开始，取长度为len的子串T）

第一种
bool SubString(SString S, SString &T, int pos, int len)//取子串,此处pos代表元素下标
{
	if (pos<0 || pos>S.Length - 1 || len<0 || len>S.Length - pos)
		return false;
	else
	{
		if (T.ch != NULL)
		{
			T.ch = NULL;
			free(T.ch);
		}
		if (T.Length != 0)
			StrInit(T);
		int i;
		for (i = 0; i < len; i++)
		{
			Check(T);
			T.ch[i] = S.ch[pos + i];
			T.Length = len;
		}
		return true;
	}
	return true;
}


第二种
bool SubString(SString S, SString &T, int pos, int len)//取子串，此处pos代表元素的位置
//串S中从第POS个位置开始，取长度为len的子串T
{
	if (pos<1 || pos>S.Length  || len<0 || len>S.Length - pos+1)
		return false;
	else
	{
		if (T.ch != NULL)
		{
			T.ch = NULL;
			free(T.ch);
		}
		if (T.Length != 0)
			StrInit(T);
		int i;
		for (i = 0; i < len; i++)
		{
			Check(T);
			if (T.ch==NULL)
				return false;
			T.ch[i] = S.ch[pos -1+ i];
			T.Length = len;
		}
		return true;
	}
	return true;
}

（七）子串定位（串的模式匹配：主串S中查找是否存在和串T值相同的子串，若存在返回true，否则返回false）

 

//第一种方式
bool Index(SString S, SString T,int &m)//子串定位
{
	int k = 0;
	int i = k, j = 0;
	while (i<S.Length && j < T.Length)
	{
		if (S.ch[i] == T.ch[j])
		{
			i++;
			j++;
		}
		else
		{
			k++;
			i = k;
			j = 0;
		}
	}
	if (j == T.Length)//子串定位成功后，用m返回T串的第一个字符在S串中的下标
	{
		m = k+1;//因为k表示下标，所有k+1表示子串第一个字符在S串中的位置
		return true;
	}
	else
		return false;

}


//第二种方式
bool Index(SString S, SString T,int &pos)//子串定位
{
	int i = 0, j = 0;
	while (i<S.Length && j < T.Length)
	{
		if (S.ch[i] == T.ch[j])
		{
			i++;
			j++;
		}
		else
		{
			i=i-j+1
			j = 0;
		}
	}
	if (j == T.Length)//子串定位成功后，用m返回T串的第一个字符在S串中的下标
	{
		pos =i-j;//pos=i-T.Length
		return true;
	}
	else
		return false;

}

 

（八）插入子串（在第pos个元素之后插入子串）

 

bool Insert(SString& S, int pos, SString T)//插入子串,pos表示下标
{
	if (pos<0 || pos>S.Length)
		return false;
	if (T.ch != 0)
	{
		//S.ch = (char*)realloc(S.ch, T.Length * sizeof(char));//在S串后增加T.Length个空间
		int i;
		for (i = S.Length - 1; i >= pos; i--)
		{
			Check(S);
			S.ch[i + T.Length] = S.ch[i];//从S串的最后一个字符开始，依次向后移动T.Length长度
		}
		//方法二
		//for (i = 0; i < T.Length; i++) //从下标为pos的字符开始，每个字符向后移动T.Length长度
		//{
		//	S.ch[S.Length-1-i+T.Length]=S.ch[S.Length-1-i]
		//}
		for (i = 0; i < T.Length; i++)
		{
			S.ch[pos + i] = T.ch[i];
		}
		S.Length = S.Length + T.Length;
	}
	return true;
}

（九）串连接（将顺序串T连接在顺序串S之后）

bool StrConcat(SString& S, SString T)//串连接
{
	int i;
	if (T.Length != 0)
	{
		for (i = 0; i < T.Length; i++)
		{
			Check(S);
			S.ch[i + S.Length] = T.ch[i];
		}
		S.Length = S.Length + T.Length;
	}
	return true;

}

（十）删除子串

第一种：pos代表下标
bool StrDel(SString& S, int pos, int len)//删除子串
{
	int i;
	if (pos<0 || pos>S.Length-1 || len<0 || len>S.Length - pos)
		return false;
	else
	{
		for (i = pos + len; i < S.Length; i++)
		{
			S.ch[i - len] = S.ch[i];
		}
		S.ch = (char*)realloc(S.ch, (S.Length - len) * sizeof(char));
		if (S.ch == NULL)return false;
		S.Length = S.Length - len;
		return true;
	}

}

第二种：pos代表元素位置
bool StrDel2(SString& S, int pos, int len)//删除子串
{
	int i;
	if (pos<1 || pos>S.Length || len<0 || len>S.Length - pos+1)
		return false;
	else
	{
		for (i = pos + len-1; i < S.Length; i++)
		{
			S.ch[i - len] = S.ch[i];
		}
		S.ch = (char*)realloc(S.ch, (S.Length - len) * sizeof(char));
		if (S.ch == NULL)return false;
		S.Length = S.Length - len;
		return true;
	}

}

（十一）求串长

int StrLen(SString S)//求串长
{
	return S.Length;
}

（十二）遍历

bool Print(SString S)//打印
{
	for (int i = 0; i < S.Length; i++)
	{
		cout << S.ch[i];
	}
	cout << endl;
	return true;
}

三、完整代码

#pragma once
#include<cstring>
#include<cstdlib>
#include<stdbool.h>
#include<iostream>
using namespace std;
typedef struct
{
	char* ch;
	int Length;//实际长度
	int capacity;//最大容量
}SString;
bool StrInit(SString& S);//初始化
bool StrAssign(SString& S, char* chars);//一个字符串常量赋值给顺序串S
bool Check(SString& S);//检查空间容量
bool StrCopy(SString& S, SString T);//将T串赋给S
bool SubString(SString S, SString& T, int pos, int len);//取子串，此处pos代表元素的位置
//串S中从第pos个位置开始，取长度为len的子串T
bool Index(SString S, SString T, int &m);//子串定位
bool Insert(SString& S, int pos, SString T);//插入子串
bool StrConcat(SString& S, SString T);//串连接
bool StrDel(SString& S, int pos, int len);//删除子串，pos是元素下标
bool StrDel2(SString& S, int pos, int len);//删除子串，pos是元素的位置
int StrLen(SString S);//求串长
bool Print(SString S);//打印

#include"SString1.h"
bool StrInit(SString& S)
{
	S.ch = NULL;
	S.Length = S.capacity = 0;
	return true;
}
bool Check(SString& S)//检查空间容量
{
	if (S.capacity == S.Length)
	{
		int newcapacity = S.capacity == 0 ? 4 : S.capacity * 2;
		char* temp = (char*)realloc(S.ch, newcapacity * sizeof(char));
		if (temp == 0)
		{
			cout << "开辟空间失败！" << endl;
			exit(-1);
		}
		else
		{
			S.ch = temp;
			S.capacity = newcapacity;
		}
	}
	return true;
}
bool StrAssign(SString& S, char* chars)//一个字符串常量赋值给顺序串S
{
	int i, j;
	char* c;
	for (i = 0, c = chars; *c; i++, c++);//计算一个字符串常量的长度
	if (i == 0)//说明字符串常量是0，就不用给SString开辟空间
		return false;
	else
	{
		Check(S);
		for (j = 0; j < i; j++)
		{
			S.ch[j] = chars[j];
			S.Length = i;
		}
	}
	return true;
}

//方法二：将T串赋给S
//bool StrCopy(SString& S, SString T)
//{
//	if (S.ch == NULL)//先释放掉原来的空间
//
//		free(S.ch);
//	if (S.Length != 0)
//	{
//		S.Length = 0;
//		S.ch = NULL;
//	}
//	if (!(S.ch = (char*)malloc(sizeof(char))))
//		return false;
//	else
//	{
//		for (int i = 0; i < T.Length; i++)
//		{
//			S.ch[i] = T.ch[i];
//			S.Length = T.Length;
//		}
//	}
//	return true;
//}

bool StrCopy(SString& S, SString T)
{
	if (S.ch != NULL)//先释放掉原来的空间
	{
		S.ch= NULL;
		free(S.ch);//注意此处虽然free函数进行了动态内存的释放和回收，但实际中未完全释放，S.ch依然会指向
		//动态开辟的空间，而非指向NULL。当第一次使用完空间，如果未退出继续运行代码，再次赋值就会发生错误，
		//只需在free函数前把S.ch进行赋值NULL操作即可
	}
	if (S.Length != 0)
	{
		StrInit(S);
	}
	for (int i = 0; i < T.Length; i++)
	{
		Check(S);
		if (S.ch == NULL)
			return false;
		S.ch[i] = T.ch[i];
		S.Length = T.Length;

	}
	return true;
}

//bool SubString(SString S, SString &T, int pos, int len)//取子串,此处pos代表元素下标
//{
//	if (pos<0 || pos>S.Length - 1 || len<0 || len>S.Length - pos)
//		return false;
//	else
//	{
//		if (T.ch != NULL)
//		{
//			T.ch = NULL;
//			free(T.ch);
//		}
//		if (T.Length != 0)
//			StrInit(T);
//		int i;
//		for (i = 0; i < len; i++)
//		{
//			Check(T);
//			T.ch[i] = S.ch[pos + i];
//			T.Length = len;
//		}
//		return true;
//	}
//	return true;
//}
bool SubString(SString S, SString &T, int pos, int len)//取子串，此处pos代表元素的位置
//串S中从第POS个位置开始，取长度为len的子串T
{
	if (pos<1 || pos>S.Length  || len<0 || len>S.Length - pos+1)
		return false;
	else
	{
		if (T.ch != NULL)
		{
			T.ch = NULL;
			free(T.ch);
		}
		if (T.Length != 0)
			StrInit(T);
		int i;
		for (i = 0; i < len; i++)
		{
			Check(T);
			if (T.ch==NULL)
				return false;
			T.ch[i] = S.ch[pos -1+ i];
			T.Length = len;
		}
		return true;
	}
	return true;
}
bool Index(SString S, SString T,int &m)//子串定位
{
	int k = 0;
	int i = k, j = 0;
	while (i<S.Length && j < T.Length)
	{
		if (S.ch[i] == T.ch[j])
		{
			i++;
			j++;
		}
		else
		{
			k++;
			i = k;
			j = 0;
		}
	}
	if (j == T.Length)//子串定位成功后，用m返回T串的第一个字符在S串中的下标
	{
		m = k+1;//因为k表示下标，所有k+1表示子串第一个字符在S串中的位置
		return true;
	}
	else
		return false;

}
bool Insert(SString& S, int pos, SString T)//插入子串,pos表示下标
{
	if (pos<0 || pos>S.Length)
		return false;
	if (T.ch != 0)
	{
		//S.ch = (char*)realloc(S.ch, T.Length * sizeof(char));//在S串后增加T.Length个空间
		int i;
		for (i = S.Length - 1; i >= pos; i--)
		{
			Check(S);
			S.ch[i + T.Length] = S.ch[i];//从S串的最后一个字符开始，依次向后移动T.Length长度
		}
		//方法二
		//for (i = 0; i < T.Length; i++) //从下标为pos的字符开始，每个字符向后移动T.Length长度
		//{
		//	S.ch[S.Length-1-i+T.Length]=S.ch[S.Length-1-i]
		//}
		for (i = 0; i < T.Length; i++)
		{
			S.ch[pos + i] = T.ch[i];
		}
		S.Length = S.Length + T.Length;
	}
	return true;
}
bool StrConcat(SString& S, SString T)//串连接
{
	int i;
	if (T.Length != 0)
	{
		for (i = 0; i < T.Length; i++)
		{
			Check(S);
			S.ch[i + S.Length] = T.ch[i];
		}
		S.Length = S.Length + T.Length;
	}
	return true;

}
bool StrDel(SString& S, int pos, int len)//删除子串
{
	int i;
	if (pos<0 || pos>S.Length-1 || len<0 || len>S.Length - pos)
		return false;
	else
	{
		for (i = pos + len; i < S.Length; i++)
		{
			S.ch[i - len] = S.ch[i];
		}
		S.ch = (char*)realloc(S.ch, (S.Length - len) * sizeof(char));
		if (S.ch == NULL)return false;
		S.Length = S.Length - len;
		return true;
	}

}

bool StrDel2(SString& S, int pos, int len)//删除子串
{
	int i;
	if (pos<1 || pos>S.Length || len<0 || len>S.Length - pos+1)
		return false;
	else
	{
		for (i = pos + len-1; i < S.Length; i++)
		{
			S.ch[i - len] = S.ch[i];
		}
		S.ch = (char*)realloc(S.ch, (S.Length - len) * sizeof(char));
		if (S.ch == NULL)return false;
		S.Length = S.Length - len;
		return true;
	}

}

int StrLen(SString S)//求串长
{
	return S.Length;
}
bool Print(SString S)//打印
{
	for (int i = 0; i < S.Length; i++)
	{
		cout << S.ch[i];
	}
	cout << endl;
	return true;
}
#include"SString1.h"
int main()
{

	SString S1;
	SString S2;
	StrInit(S1);
	StrInit(S2);
	char a[] = "qwertyabcduiop";
	char b[] = "abcd";
	StrAssign(S1, a);//一个字符串常量赋值给顺序串S
	cout << StrLen(S1) << endl;
	Print(S1);
	StrAssign(S2, b);

	StrCopy(S1, S2);//将T串赋给S
	Print(S1);

	SubString(S1, S2, 1, 4);//取子串，此处pos代表元素的位置
	Print(S1);
	Print(S2);

	StrConcat(S1, S2);//串连接
	Print(S1);

	Insert(S1, 3, S2);//插入子串
	Print(S1);


	int M;
	Index(S1, S2, M);//子串定位
	cout << M << endl;
	Print(S1);


	//删除子串，pos是元素的位置
	SString S3;
	S3.ch = (char*)malloc(15 * sizeof(char));
	int j = 0;
	int i = 14;
	for (j = 0; j < i; j++)
	{
		S3.ch[j] = a[j];
		S3.Length = i;
	}
	Print(S3);
	StrDel2(S3, 3, 4);
	Print(S3);
	return 0;
}

四、完整代码2

#pragma once
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<malloc.h>
using namespace std;
typedef struct {
    char* ch;                  // 先存放非空串的首地址，不分配内存
    int Length;                  // 存放串的当前长度
}SString;                    

bool StrInit(SString& S);//初始化
bool StrAssign(SString& S, char* chars);//一个字符串常量赋值给顺序串S
bool StrCopy(SString& S, SString T);//将T串拷贝给S串
bool SubString(SString S, SString& T, int pos, int len);//取子串,此处pos代表元素下标
bool SubString2(SString S, SString& T, int pos, int len);//取子串，此处pos代表元素的位置
//串S中从第POS个位置开始，取长度为len的子串T
bool Index(SString S, SString T, int& pos);//子串定位
bool Insert(SString& S, int pos, SString T);//插入子串,pos表示下标
int StrLen(SString S);//求串长
bool Print(SString S);//打印


#include"SString.h"
bool StrInit(SString& S)//初始化
{
	S.ch = NULL;
	S.Length = 0;
	return true;
}

bool StrAssign(SString& S, char* chars)//一个字符串常量赋值给顺序串S
{
	int i, j;
	char* c;
	for (i = 0, c = chars; *c; i++, c++);//计算一个字符串常量的长度
	if (i == 0)//说明字符串常量是0，就不用给SString开辟空间
		return false;
	else
	{
		S.ch = (char*)malloc(i * sizeof(char));//申请空间
		if (S.ch == NULL)
		{
			exit(0);
		}
		for (j = 0; j < i; j++)
		{
			S.ch[j] = chars[j];
			S.Length = i;
		}
	}
	return true;
}

bool StrCopy(SString& S, SString T)//将T串拷贝给S串
{
	if (S.ch != NULL)//先释放掉原来的空间
	{
		S.ch = NULL;
		free(S.ch);//注意此处虽然free函数进行了动态内存的释放和回收，但实际中未完全释放，S.ch依然会指向
		//动态开辟的空间，而非指向NULL。当第一次使用完空间，如果未退出继续运行代码，再次赋值就会发生错误，
		//只需在free函数前把S.ch进行赋值NULL操作即可
	}
	if (S.Length != 0)
	{
		StrInit(S);
	}
	for (int i = 0; i < T.Length; i++)
	{
		S.ch = (char*)malloc(T.Length * sizeof(char));
		if (S.ch == NULL)
			return false;
		S.ch[i] = T.ch[i];
		S.Length = T.Length;

	}
	return true;
}


bool SubString(SString S, SString& T, int pos, int len)//取子串,此处pos代表元素下标
{
	if (pos<0 || pos>S.Length - 1 || len<0 || len>S.Length - pos)
		return false;
	else
	{
		if (T.ch != NULL)
		{
			T.ch = NULL;
			free(T.ch);
		}
		if (T.Length != 0)
			StrInit(T);
		int i;
		T.ch = (char*)malloc(len * sizeof(char));
		if (T.ch == NULL)
			return false;
		for (i = 0; i < len; i++)
		{
			T.ch[i] = S.ch[pos + i];
			T.Length = len;
		}
		return true;
	}
	return true;
}



//第二种
bool SubString2(SString S, SString& T, int pos, int len)//取子串，此处pos代表元素的位置
//串S中从第POS个位置开始，取长度为len的子串T
{
	if (pos<1 || pos>S.Length || len<0 || len>S.Length - pos + 1)
		return false;
	else
	{
		if (T.ch != NULL)
		{
			T.ch = NULL;
			free(T.ch);
		}
		if (T.Length != 0)
			StrInit(T);
		int i;
		T.ch = (char*)malloc(len * sizeof(char));
		for (i = 0; i < len; i++)
		{
			if (T.ch == NULL)
				return false;
			T.ch[i] = S.ch[pos - 1 + i];
			T.Length = len;
		}
		return true;
	}
	return true;
}

bool Index(SString S, SString T, int& pos)//子串定位
{
	int i = 0, j = 0;
	while (i < S.Length && j < T.Length)
	{
		if (S.ch[i] == T.ch[j])
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 1;
				j = 0;
		}
	}
	if (j == T.Length)//子串定位成功后，用m返回T串的第一个字符在S串中的下标
	{
		pos = i - j;//pos=i-T.Length
		return true;
	}
	else
		return false;

}


bool Insert(SString& S, int pos, SString T)//插入子串,pos表示下标
{
	if (pos<0 || pos>S.Length)
		return false;
	if (T.ch != 0)
	{
		S.ch = (char*)realloc(S.ch, (S.Length + T.Length) * sizeof(char));//在S串后增加T.Length个空间
		int i;
		for (i = S.Length - 1; i >= pos; i--)
		{
			S.ch[i + T.Length] = S.ch[i];//从S串的最后一个字符开始，依次向后移动T.Length长度
		}
		//方法二
		//for (i = 0; i < T.Length; i++) //从下标为pos的字符开始，每个字符向后移动T.Length长度
		//{
		//	S.ch[S.Length-1-i+T.Length]=S.ch[S.Length-1-i]
		//}
		for (i = 0; i < T.Length; i++)
		{
			S.ch[pos + i] = T.ch[i];
		}
		S.Length = S.Length + T.Length;
	}
	return true;
}

bool StrConcat(SString& S, SString T)//串连接
{
	int i;
	if (T.Length != 0)
	{
		S.ch = (char*)realloc(S.ch,(S.Length + T.Length) * sizeof(char));
		if (S.ch == NULL)
			return false;
		for (i = 0; i < T.Length; i++)
		{
			S.ch[i + S.Length] = T.ch[i];
		}
		S.Length = S.Length + T.Length;
	}
	return true;

}

int StrLen(SString S)//求串长
{
	return S.Length;
}

bool Print(SString S)//打印
{
	for (int i = 0; i < S.Length; i++)
	{
		cout << S.ch[i];
	}
	cout << endl;
	return true;
}
#include"SString.h"
int main()
{
	SString S1;
	SString S2;
	StrInit(S1);
	StrInit(S2);
	char a[] = "qwertyabcduiop";
	char b[] = "abcd";
	StrAssign(S1, a);//一个字符串常量赋值给顺序串S
	cout << StrLen(S1) << endl;
	Print(S1);

	SubString(S1, S2, 3, 5);
	Print(S2);
	return 0;

}

莫忘、莫念
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【字符串】KMP算法
gzkeylucky的博客
09-11 1529
学习字符串KMP匹配算法
Python字符串学习
12-21
以下是一些关于Python字符串的重要知识点： 1. **字符串注释**：在Python中，可以使用井字号 (#) 来添加单行注释。在脚本的开头，`#!/usr/bin/env python` 是一个称为“shebang”的行，用来告诉系统使用哪个Python...
4.1 数据结构——串
weixin_45523296的博客
10-14 4291
串的定义、串的抽象数据类型、串的顺序存储结构和串的链式存储结构、串的模式匹配（BF算法、KMP算法）
数据结构-串
weixin_46441425的博客
04-26 4356
“子串”是个啥？
最新发布
jjmhx的专栏
04-29 254
一个字符串的任何部分，包括它本身，都可以被视为它的子串。" 本身是它的一个子串。这就好像说一个女人本身是自己的孩子一样。②空字符串（即不包含任何字符的字符串）是任何字符串的子串。这就好像说一个生不出孩子的女人也有自己的孩子，她的孩子是没有孩子。"，其中的 "ello", "World", "o, W" 等都是它的子串。子串（Substring）指的是一个字符串中连续的一段字符序列。有了这两条规定，世界顿时温暖了很多，因为任何一个人都至少有两个孩子，一个是他自己，一个是并不存在的孩子。
子串、真子串、非空子串、非空真子串的求解方法（数据结构）
m0_53777734的博客
06-19 1万+
** 字串、真子串、非空子串、非空真子串的求解方法 ** Eg：串S=“software” 子串的求解方法 n(n+1)/2 +1 此处n为8，所以串S的子串为37 真子串的求解方法 n(n+1)/2 此处n为8，所以S的真子串为36 非空子串的求解方法 n(n+1)/2 此处n为8，所以S的非空子串为36 非空真子串的求解方法 n(n+1)/2-1 此处n为8，所以S的非空真子串为35 ...
子串计数问题
qq_50748356的博客
03-22 6569
定义 子串的定义：将一个字符串从开头与结尾删去任意字符，形成新的字符串，称为原字符串的子串。 子序列的定义：将一个字符串删去任意字符，形成新的字符串，称为原字符串的子序列。 区别就是:子串在原串中是连续的，子序列不一定。 子串计数问题，一般是给定一个字符串，求满足条件的子串的个数。 一般解题方法 遍历该字符串中的每个字符(for(i=1;i<=n;i++))，不重不漏的计算出以该字符为开头的方案数。答案就是每个字符答案的累加。 关键在于不重不漏的算出包含该字符的方案数 例题1:01序列 链接 解法1：
php学习 字符串课件
10-30
- `strrchr()`：从后向前查找字符串，返回最后一次出现指定子字符串的位置及其后面的字符串。 - `strpos()`：从前向后查找字符串，返回第一次出现子字符串的位置，未找到返回false。 - `strrpos()`：从后向前查找子...
PHP学习之整理字符串
01-20
1. 访问单个字符在PHP中，可以把字符串当成一个字符的数组，可以直接用数组的访问方法来访问字符串。如$str[0]。在这里要注意的是，如果字符是ASCII码以外时，访问会有问题。因为这种访问只能取得一个字节。 2. 删除...
Java学习总结：飘逸的字符串
01-21
　相信不管我们运用Java语言来开发项目还是进行数据分析处理，都要运用到和字符串相关的处理方法。这个社会处处有着和字符串相关的影子：日志、文档、书籍等。既然我们离不开字符串，那么来好好认识一下吧。 　...
java学习笔记_关于字符串概述
08-30
【字符串概述】 在Java编程语言中，字符串是一个非常基础且重要的概念。字符串是字符的序列，通常用来存储和处理文本信息。Java中的字符串主要通过`String`类来表示，它是一个不可变对象，这意味着一旦创建了`...
真子串是指从原字符串中通过删除某些字符但不破坏余下字符的顺序而形成的新字符串。 输入n个字符串,统计出现某个字符串是另一个字符串的真子串的组数
xuchaoxin1375的博客
06-12 5216
/* 真子串是指从原字符串中 通过删除某些字符 但不破坏余下字符的顺序 而形成的新字符串。 输入n个 字符串，统计出现 某个字符串是另一个字符串的 真子串的 组数。 输入 输入n及n个字符串 输出 真子串数目 样例输入 3 abc cxajfkabjfkdc xjfabkdc 样例输出 3 两两握手的规模. #include <stdio.h> #include <string.h> #include <math.h> #include <st
子序列和子串问题算法的全面总结
qq_41633237的博客
05-08 1万+
1.分清楚什么是子串，什么是子序列 看文章前首先要搞清楚什么是子序列，什么是子串；子序列是指一个字串中非连续的字串，例如：字串A：123456789 它有一个子序列a：13579（非连续） 它有一个子串b：12345（连续）。 2.有关子串问题的算法 （1）最大子串 何为最大子串，例如：最大子串是要找出由数组成的一维数组中和最大的连续子串。比如{5,-3,4,2}的最大子串就是 {5,-3...
字符串的子串的个数
Shrimp_millet
06-25 5万+
字串：串中任意个连续的字符组成的子序列称为该串的字串。 空串属于字串 （1）长度为n的字符串，如果串中字符各不相同，则字串的个数为n(n+1)/2+1 解析： 包含1个字符的子串共n个 包含2个字符的子串共n-1个 包含3个字符的子串共n-2个 包含4个字符的子串共n-3个 .。。。。。 包含n个字符的子串共1个 空串1个 综上所述：子串个数共：1...
求字符串子串数目的方法
DPJune的博客
01-12 5万+
最近在做一些算法题，经常遇到字符串的问题，需要计算字符串子串的数目，字符串的子串数目为 n(n+1)/2 + 1，这个答案是如何求得的呢？ 我们都知道子串是一个字符串中连续的一段，其实你可以把它抽象为周围有边界的一串字符，如”abcde”，你可以把子串”bc”抽象为”a|bc|de”，这样一来计算子串数目的问题其实就转化成了计算字符串中放置边界的问题，一个长度为n的字符串中可以放置n个边界
求字符串的子串个数
weixin_66196012的博客
06-25 1万+
串(string)[或字符串]:是由零个或多个字符组成的有限序列。 子串:串中任意个连续的字符组成的子序列称为该串的子串。 长度为n的字符串: 1.子串:n(n+1)/2+1 2.非空子串与真子串:n(n+1)/2 3.非空真子串:n(n+1)/2-1 记住空串是子串也是真子串 可以类比集合记忆，空集是任何集合的子集 集合也是划分边界，那...
【数据结构】· 串、数组和广义表
麟-小白的博客
10-22 783
Hello大家好， 我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！！！如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多呀！❤❤❤爱你们！！！前言：1. 串1.1 串的定义串（String）：零个或多个任意字符组成的有限序列。几个术语：子串：串中任意个连续字符组成的子序列称为该串的子串。
字符串的全部子序列(递归)
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
03-28 1万+
在计算机科学中，子序列和子串的概念非常重要，这两个概念经常在数据处理，文本分析，编程算法等领域被广泛使用。理解子序列和子串的区别以及如何高效地处理它们对于成为一名有效的程序员是非常重要的。
求解字符串所包含子串的个数
热门推荐
只如初见0706的博客
03-01 7万+
1、子串：串中任意个连续的字符组成的子序列称为该串的子串（连续、连续、连续！重要的事情说三遍）备注：空串属于子串2、串中字符均不相同：n个字符构成的字符串，假设每个字符都不一样，问有多少个子串答案：n(n+1)/2+1友情提示：每个字符均不相同解析：包含1个字符的子串共n个包含2个字符的子串共n-1个包含3个字符的子串共n-2个包含4个字符的子串共n-3个.。。。。。包含n个字符的子串共1个空串1...
python字符串学习感悟
07-28
此外，我还学到了一些关于字符串的其他知识。例如，我了解到可以使用'''或"""来创建包含换行的字符串。我还了解到在字符串中嵌套引号也会被计算为字符数。另外，我还了解到可以使用str()内置类将其他类型的数据转换...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值