关于串的学习

已于 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
    评论
专栏目录
数据结构之------串
小小的学渣
12-19 1135
（一）串的基本概念 串（又称字符串）是一种特殊的线性表，它的每个结点仅由一个字符组成。 在早期的程序设计语言中，串仅在输入或输出中以直接量的形式出现，并不参与运算。随着计算机的发展，串在文字编辑、词法扫描、符号处理以及定理证明等许多领域得到越来越广泛的应用。在高级语言中开始引入了串变量的概念，如同整型、实型变量一样，串变量也可以参加各种运算。  1、串 串（String）是零个或多个字
数据结构之字符串
兮于怀
05-05 1000
前言： 串就是我们所说的字符串，计算机对数据的处理主要包括数值计算和非数值计算，在计算机发展的早期，数值计算比较普遍，然而随着社会的发展和计算需求的发展，在计算机上做非数值处理的计算越来越多，而在计算机上非数值处理大部分是对字符串的处理，处理这些字符串数据比起处理整型、浮点型数据都要复杂很多，所以把串作为一种独立的数据结构进行研究。 串（数据结构）前言：一.串导学1.课程结构2.知识点搜索3.串...
子字符串
芝麻开门的博客
11-06 392
ming_zi = "芝麻开门.py" if "芝麻" in ming_zi:#"芝麻" 子字符串 print("在") else: print("不在") if "芝麻门" in ming_zi:#不是 print("在") else: print("不在") if "芝麻门" not in mi
“子串”是个啥？
最新发布
jjmhx的专栏
04-29 308
一个字符串的任何部分，包括它本身，都可以被视为它的子串。" 本身是它的一个子串。这就好像说一个女人本身是自己的孩子一样。②空字符串（即不包含任何字符的字符串）是任何字符串的子串。这就好像说一个生不出孩子的女人也有自己的孩子，她的孩子是没有孩子。"，其中的 "ello", "World", "o, W" 等都是它的子串。子串（Substring）指的是一个字符串中连续的一段字符序列。有了这两条规定，世界顿时温暖了很多，因为任何一个人都至少有两个孩子，一个是他自己，一个是并不存在的孩子。
Java基础知识----字符串
程序研博客
10-23 7853
一、创建字符串 1、声明字符串 在Java语言中的字符串必须在一对“ ”（双引号）之内。 例如： "33"、"Hello"、"世界" 2、创建字符串 String类即字符串类型，并不是Java的基本数据类型，但可以像基本数据类型一样使用，用双引号括起来进行声明。 （1）String（char a[]）用数组创建字符串 char arr[]={'n','b','a'}; String str=new String(arr); //以上操作相等于 String str=new String(
java-字符串大小写转换
Subuprogrammer的博客
01-17 464
一、创建并初始化字符串对象 字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误” 创建对象要使用类的构造方法。 toLowerCase()方法用于将大写字母转换为小写字母 toUpperCase()方法用于将小写字母转换为大写字母 二、代码实现 import java.lang.String;//大小写字母转换 public class Reverse { public sta...
Python字符串学习
12-21
以下是一些关于Python字符串的重要知识点： 1. **字符串注释**：在Python中，可以使用井字号 (#) 来添加单行注释。在脚本的开头，`#!/usr/bin/env python` 是一个称为“shebang”的行，用来告诉系统使用哪个Python...
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`类来表示，它是一个不可变对象，这意味着一旦创建了`...
判定一个串是否为另一个串的子串
04-19
此程序为VC6.0实现判断一个字符串是否为另一个字符串的子串
SQL之提取子字符串--使用substr\charindex\patindex
qq_45577911的博客
11-17 4148
当我们要获取一个字符串的字串时，我们可以用substr函数来实现喔，现在我们来看看它的用法吧！ substr(string ,start, length) 1、string ：要被截取的字符串 2、start ：截取的字串开始的位置，【必填】，为正数时，是从左往右数的第start个字符，为负数时，是从右往左数的第| start | 个字符。它默认值是1，若是填错成0时，它会默认为默认值1。 3、length ：截取的字串的长度，【可选】，缺省时返回字符表达式的值结束前的全部字符。 我们来看一个简单的例子：
子串与子序列的区别
num_001的博客
07-12 2634
子串与子序列的区别
子串(大贤者福尔)
weixin_42048463的博客
07-05 2245
大贤者福尔的字符串研究取得了积极的进展，但他现在遇到了一个新的问题，他需要找到一个字符串的所有满足特殊条件的子串。他的问题具体来说是，对一个给定的字符串，按给定的子串大小N进行分割（N不超过字符串的长度），分割点位于依次位于字符串中相邻字符之间，使得最大子串的长度不超过N。同时，把分割后的所有子串依次拼接，就可以恢复为原始字符串。如给定字符串ABCDE，若N为1，则分割的子串为A B C D E；若N为2，根据起始分割点不同，可以有两种分割结果，分别为A BC DE和AB CD E。 福尔希望你能够帮他，
4-数据结构-串的学习
weixin_45694388的博客
04-15 570
4.1串类型的定义 1.串：（或字符串） 串是由多个字符组成的有限序列，记作：S=‘c1c2c3…cn’ (n>0) 其中S是串的名字，‘c1c2c3…cn’ 是串值 ci是串中字符 n是串的长度，表示字符的数目 空串：零个字符的串称为空串，记作“”（空） 2.子串 子串：串中任意连续字符组成的子序列 主串：包含子串的串 注意：空串是任意串的子串，任意串是他自身的子串。除它本身外，一个串的...
子串和子序列并不是一个意思
热门推荐
穿着裤衩跳
11-21 1万+
例如：一个字符串   awbcdewgh 他的子串：  awbc.   awbcd   awbcde   ....很多个子串  但是都是连续在一起   他的子序列： abc  .  abcd    abcde  ...  很多个子序列  但是子序列中的字符在字符串中不一定是连在一起的   所以  子串！=子序列...
举例说明子串和子序列的区别 ！！！
帅帅邬同学的博客
01-16 5933
定义： 子串：必须连续 子序列：可以不连续 举个栗子 给定字符串 "asdfghj" 子串是asd,asdf等很多个子串， 是连在一起的。 子序列是 asf,adf等很多个子序列 ，子序列中的字符在字符串中不一定是连在一起的。 怎么样，是不是很简单，你学会了吗 ？ 如果这篇文章能够帮助到您，希望您不要吝惜点赞 ???????? 和收藏 ????????，您的支持是我继续努力的动力 ????????！！！ ...
子串
weixin_33895516的博客
01-25 137
题目描述 对于一个字符串变量，例如"abcdefghijkl",它的子串就是像"cdefg"这样可以从中找到的连续的字符串。给定一个字符串和它的一个子串，求出这个子串在原串中不重叠得出现了几次。例如：原串为：aaaa 子串为：aa。那么子串在原串中出现了两次。 输入 输入数据的第一行为一个整数 T(0 < T < 20) 接下来 T 行每行为两个空格分隔的字符串，...
python字符串学习感悟
07-28
在学习Python字符串的过程中，我发现了一些有用的方法和技巧。首先，我学会了使用capitalize()方法将字符串的首字母大写，以及使用swapcase()方法将字符串的大小写互换。此外，我还学会了使用endwith()和startwith()方法来检查字符串是否以特定的结尾或开头开始。另外，我还学会了使用find()和rfind()方法来查找并返回字符串中特定字符的索引位置。我还学会了使用isnumeric()方法来检查字符串是否只包含数字字符。此外，我还学会了使用ljust()和rjust()方法来对齐字符串的左侧或右侧。我还学会了使用lstrip()和rstrip()方法来删除字符串左侧或右侧的字符。另外，我还学会了使用partition()方法来找到字符串中的特定子字符串并将字符串分成三个元组。如果字符串中不包含该子字符串，则后两个元组为空。我还学会了使用replace()方法将字符串中的旧字符替换为新字符，并可以指定替换的次数。此外，我还学会了使用strip()和split()方法来切割字符串。最后，我还学会了使用format()方法来格式化字符串。通过这些学习，我对Python字符串的使用有了更深入的理解。\[1\] 此外，我还学到了一些关于字符串的其他知识。例如，我了解到可以使用'''或"""来创建包含换行的字符串。我还了解到在字符串中嵌套引号也会被计算为字符数。另外，我还了解到可以使用str()内置类将其他类型的数据转换为字符串。例如，可以使用int()将字符串转换为整数。\[2\]\[3\] 总的来说，通过学习Python字符串，我对字符串的操作和处理有了更深入的了解，并且掌握了一些实用的方法和技巧。这些知识将对我在编程中处理字符串时非常有帮助。 #### 引用[.reference_title] - *1* [2020-9-20 Python 学习心得（字符串）](https://blog.csdn.net/qq_43478017/article/details/108700839)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [python字符串方法小结](https://blog.csdn.net/JaneFree/article/details/123242522)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值