顺序串的基本操作实验报告

合集下载

数据顺序栈实验报告

一、实验目的1. 理解顺序栈的定义、性质和基本操作。

2. 掌握顺序栈的顺序存储结构及其实现方法。

3. 熟练运用顺序栈解决实际问题，如进制转换、括号匹配等。

4. 提高编程能力和问题解决能力。

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发环境：Visual Studio三、实验内容1. 顺序栈的定义和性质2. 顺序栈的顺序存储结构及其实现3. 顺序栈的基本操作：入栈、出栈、判空、判满、取栈顶元素4. 顺序栈的应用：进制转换、括号匹配四、实验步骤1. 定义顺序栈的数据结构```c#define MAXSIZE 100 // 顺序栈的最大容量typedef struct {char data[MAXSIZE]; // 存储栈中元素的数据数组int top; // 栈顶指针} SeqStack;```2. 初始化顺序栈```cvoid InitStack(SeqStack S) {S->top = -1; // 初始化栈顶指针为-1，表示栈为空}```3. 判断栈是否为空```cint StackEmpty(SeqStack S) {return S.top == -1; // 栈顶指针为-1时，表示栈为空}```4. 判断栈是否满```cint StackFull(SeqStack S) {return S.top == MAXSIZE - 1; // 栈顶指针等于最大容量减1时，表示栈满}```5. 入栈操作```cvoid Push(SeqStack S, char x) {if (StackFull(S)) {printf("栈满\n");return;}S->data[++S->top] = x; // 将元素x压入栈顶}```6. 出栈操作```cchar Pop(SeqStack S) {if (StackEmpty(S)) {printf("栈空\n");return 0;}return S->data[S->top--]; // 返回栈顶元素，并将栈顶指针减1 }```7. 取栈顶元素```cchar GetTop(SeqStack S) {if (StackEmpty(S)) {printf("栈空\n");return 0;}return S.data[S.top]; // 返回栈顶元素}```8. 顺序栈的应用（1）进制转换```cvoid DecimalToBinary(SeqStack S, int num) {SeqStack binaryStack;InitStack(&binaryStack);while (num > 0) {Push(&binaryStack, (num % 2) + '0'); // 将余数压入栈中num /= 2;}printf("十进制数 %d 转换为二进制数为：", num);while (!StackEmpty(binaryStack)) {printf("%c", Pop(&binaryStack)); // 依次弹出栈中元素，得到二进制数}printf("\n");}```（2）括号匹配```cint BracketMatch(char str) {SeqStack stack;InitStack(&stack);for (int i = 0; i < strlen(str); i++) {if (str[i] == '(' || str[i] == '[' || str[i] == '{') {Push(&stack, str[i]); // 将左括号压入栈中} else if (str[i] == ')' || str[i] == ']' || str[i] == '}') {if (StackEmpty(stack)) {return 0; // 右括号多于左括号，不匹配}char top = Pop(&stack); // 弹出栈顶元素if ((str[i] == ')' && top != '(') || (str[i] == ']' &&top != '[') || (str[i] == '}' && top != '{')) {return 0; // 左右括号不匹配}}}return StackEmpty(stack); // 栈为空，表示括号匹配}```五、实验结果与分析1. 实验结果通过实验，成功实现了顺序栈的定义、性质、顺序存储结构、基本操作和应用。

数据结构顺序串基本操作实验报告

数据结构顺序串基本操作实验报告实验目的：1.掌握顺序串的定义和基本操作；2.掌握顺序串的插入、删除、查找等基本操作。

实验内容：实现顺序串的基本操作，包括串的初始化、插入、删除、查找、输出等操作，并通过实例测试验证操作的正确性。

实验原理：顺序串是一种以连续的存储空间来存储字符序列的数据结构。

在顺序串中，字符串的字符元素依次存储在一组连续的存储单元中，可以通过下标来访问和修改元素。

顺序串的基本操作包括初始化、插入、删除、查找等。

1.串的初始化：初始化一个空串，即将串的长度设置为0。

2.串的插入：在指定位置插入一个字符或字符串。

首先需要判断插入位置的合法性，即位置不能超过当前串的长度，并将插入位置后的元素后移一位，然后将要插入的元素放入指定位置。

3.串的删除：删除指定位置的字符或字符串。

首先需要判断删除位置的合法性，即位置不能超过当前串的长度，然后将删除位置后的元素前移一位。

4.串的查找：在串中查找指定字符或子串第一次出现的位置。

遍历串中的每个元素，检查是否与要查找的字符或子串相等，若相等则返回其位置。

5.串的输出：将串中的元素打印出来。

实验步骤：1.定义顺序串的数据结构。

使用数组来存储字符序列，并定义一个变量用于记录串的长度。

2.初始化一个空串。

将串的长度设置为0。

3.实现插入操作。

根据插入位置的合法性，判断是否需要进行插入操作。

如果插入位置超过了当前串的长度，则将元素插入到串末尾；否则，将插入位置后的元素后移一位，并将要插入的元素放入指定位置。

4.实现删除操作。

根据删除位置的合法性，判断是否需要进行删除操作。

如果删除位置超过了当前串的长度，则无需删除；否则，将删除位置后的元素前移一位。

5.实现查找操作。

遍历串中的每个元素，检查是否与要查找的字符或子串相等，若相等则返回其位置。

6.实现输出操作。

遍历串中的每个元素，将其打印出来。

7.构造测试实例，并进行验证。

实验结果：以插入、删除、查找等操作为例，构造测试实例进行验证：假设有一个空串，插入字符'A'到位置0：结果为"A"；在串的末尾插入字符'B'：结果为"AB"；在位置1插入字符'C'：结果为"ACB"；删除位置3的字符：结果为"AC"；查找字符'C'的位置：结果为1实验总结：本次实验主要是对顺序串的基本操作进行了实现和验证。

串操作实验报告

串操作实验报告
《串操作实验报告》
实验目的：通过对串操作的实验，掌握串的基本操作方法，提高对串操作的理解和掌握。

实验材料：计算机、编程软件、实验指导书。

实验步骤：
1. 字符串的输入输出：首先，我们学习了如何通过编程软件向计算机输入字符串，并且通过编程实现将字符串输出到屏幕上。

这一步骤帮助我们了解了如何使用编程语言来操作字符串。

2. 字符串的拼接：接着，我们学习了如何将两个字符串进行拼接。

通过实验，我们发现可以通过简单的加号操作符来实现字符串的拼接，这为我们在日后的编程中提供了很大的便利。

3. 字符串的截取：在实验中，我们还学习了如何通过编程语言来截取字符串的部分内容。

这一步骤让我们对于字符串的操作更加灵活，可以根据需要来截取所需的内容。

4. 字符串的比较：最后，我们学习了如何通过编程语言来比较两个字符串的内容。

这一步骤让我们对于字符串的比较有了更深入的理解，可以通过比较来判断字符串是否相等，或者哪个字符串的内容更大。

实验结果：通过这次实验，我们对于串操作有了更加深入的理解和掌握。

我们可以通过编程语言来实现对字符串的输入输出、拼接、截取和比较等操作，为日后的编程工作打下了坚实的基础。

结论：串操作是编程中非常重要的一部分，通过这次实验，我们对于串操作有
了更加深入的理解和掌握。

希望在日后的编程工作中能够更加灵活地运用串操作，提高编程效率和质量。

数据结构实验报告串

一、实验目的1. 理解串的概念和性质；2. 掌握串的基本操作，如连接、赋值、求长度、定位等；3. 熟悉串的两种存储结构：顺序存储和链式存储；4. 能够实现串的简单应用，如字符串匹配、子串查找等。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 串的定义和性质2. 串的顺序存储结构3. 串的链式存储结构4. 串的基本操作5. 字符串匹配算法6. 子串查找算法四、实验步骤1. 定义串的数据结构```cpp#define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int length;} StrString;```2. 实现串的基本操作```cpp// 初始化串void InitString(StrString &S) {S.length = 0;}// 赋值操作void AssignString(StrString &S, StrString T) { for (int i = 0; i < T.length; i++) {S.data[i] = T.data[i];}S.length = T.length;}// 求长度操作int Length(StrString S) {return S.length;}// 定位操作int Index(StrString S, StrString T, int pos) { int i, j;i = pos;for (j = 0; j < T.length && i < S.length; j++, i++) { if (S.data[i] != T.data[j]) {i = i - j;j = 0;}}if (j == T.length) {return i - T.length + 1;}return 0;}```3. 实现字符串匹配算法```cpp// 字符串匹配算法（KMP算法）int KMPMatch(StrString S, StrString T) {int i, j;int next[T.length];// 构建next数组for (i = 1, j = 0; i < T.length; i++) {while (j > 0 && T.data[i] != T.data[j]) {j = next[j - 1];}if (T.data[i] == T.data[j]) {j++;}next[i] = j;}// 匹配过程i = 0;j = 0;while (i < S.length && j < T.length) { if (S.data[i] == T.data[j]) {i++;j++;} else if (j > 0) {j = next[j - 1];} else {i++;}}if (j == T.length) {return i - j;}return 0;}```4. 实现子串查找算法```cpp// 子串查找算法（朴素算法）int SubStringMatch(StrString S, StrString T) {int i, j;for (i = 0; i <= S.length - T.length; i++) {j = 0;while (j < T.length && S.data[i + j] == T.data[j]) {j++;}if (j == T.length) {return i;}}return 0;}```五、实验结果与分析1. 初始化串、赋值操作、求长度操作、定位操作均能正常执行，符合预期。

顺序串的基本操作实现

newstring.strtraverse();
}
if(returnvalue==overflow)
{
cout<<"字符串的最大长度为"<<maxsize<<endl;
cout<<"发生溢出，操作失败!"<<endl;
}
if(returnvalue==range_error)
cout<<"位置错误，操作失败!"<<endl;
str[i-1]=str[j];
length=length-(endposition-beginposition+1);
return success;
}
returninfo string::strmodify(int beginposition,int endposition,char newstr[])
{
cout<<"数据没有发生更改!"<<endl;
break;
}
if(choose=='Y'||choose=='y')
{
returnvalue=newstring.strcreate();
if(returnvalue==success)
cout<<"创建成功!"<<endl;
flag=1;
}
else
returninfo strmodify(int beginposition,int endposition,char newstr[]); //修改
int strsearch(char newstr[]); //查找

顺序串的基本操作

《数据结构》实验#include<stdio.h>#include<string.h>#define maxnum 100typedef struct{char str[maxnum];int length;}SString;void creat(SString &s){printf("请输入主串s:\n");gets(s.str);s.length=strlen(s.str);}void Strcopy(SString &t,SString &f){int i;printf("请输入串f:\n");gets(f.str);f.length=strlen(f.str);for(i=0;i<f.length;i++){t.str[i]=f.str[i];}printf("字符串复制成功!\n");}int Strcompare(SString s,SString &t){ int i,j,k;i=0;j=0;printf("请输入要比较的串:\n");gets(t.str);t.length=strlen(t.str);while(i<s.length&&j<t.length){if(s.str[i]==t.str[i]){i++;j++;}else{return k=s.str[i]-t.str[i];}}if(j==t.length)return k=s.length-t.length;else i++;j++;return k;}void concat(SString &sub,SString s,SString &t){ int i,j;printf("请输入要联接的串:\n");gets(t.str);t.length=strlen(t.str);if(s.length+t.length<maxnum) {for(i=0;i<s.length;i++)sub.str[i]=s.str[i];for(j=0;j<t.length;j++)sub.str[j+s.length]=t.str[j]; sub.length=s.length+t.length; }else if(s.length<maxnum){for(i=0;i<s.length;i++)sub.str[i]=s.str[i];for(j=0;j<maxnum-s.length;j++) sub.str[j+s.length]=t.str[j]; sub.length=maxnum;}else{for(i=0;i<maxnum;i++)sub.str[i]=s.str[i];sub.length=maxnum;}}void Insert(SString &s,SString &t){ int i,j,k;t.length=strlen(t.str);printf("请输入要插入的位置:\n"); scanf("%d",&j);for(i=j-1;i<s.length;i++){s.str[i+t.length]=s.str[i];}for(k=0,i=j-1;i<j+t.length-1;i++) {s.str[i]=t.str[k];k++;}s.length+=t.length;printf("字符串插入成功:\n");}void Delete(SString &s){int i,j,len;printf("请输入要删除的位置:\n"); scanf("%d",&j);printf("请输入要删除串的长度:\n"); scanf("%d",&len);for(i=j-1+len;i<s.length;i++){s.str[i-len]=s.str[i];}s.length-=len;}void print(SString &s){int i;for(i=0;i<s.length;i++){printf("%c ",s.str[i]);}}void main(){SString s,a,b,c,d,e,f;int x;char y;creat(s);do{printf("请输入要操作的项:\n");printf("*****************************************\n");printf("* 2字符串的复制。

串的实验小结

串的实验小结本次实验是关于串的实验，通过实验我对串有了更深入的了解。

串是由多个字符构成的数据结构，其中字符之间按一定顺序排列。

串的实现可以使用数组或链表的方式。

在本次实验中，我首先学习了串的基本概念和相关术语，例如串的长度、比较、连接等。

接着，我根据实验要求，完成了串的基本操作的实现，包括串的初始化、销毁、清空、插入字符、删除字符、查找子串等操作。

我采用了数组的方式来实现串。

在实现串的基本操作过程中，我遇到了一些问题，例如如何插入字符和删除字符。

通过仔细研究问题，我发现可以通过移动字符来实现插入和删除操作。

具体来说，对于插入操作，我可以先将插入位置之后的字符向后移动，然后将新字符插入到插入位置。

对于删除操作，我可以将删除位置之后的字符向前移动，从而达到删除的效果。

通过这次实验，我不仅加深了对串的理论知识的理解，还学会了如何实现串的基本操作。

实验过程中，我还发现了一些问题需要改进。

首先，我发现在插入和删除字符时，需要移动字符的操作比较繁琐，效率也不高。

我可以考虑使用链表来实现串，这样在插入和删除字符时，只需要修改指针的指向，而不需要移动字符，从而提高效率。

其次，我还发现在查找子串时，需要对整个串进行遍历，效率比较低。

我可以考虑使用KMP算法来实现子串的查找，从而提高效率。

总的来说，本次实验对我来说是一次很有意义的实践活动。

通过实验，我不仅加深了对串的理解，还学会了如何实现串的基本操作。

通过实验过程中的总结，我也发现了一些问题需要改进，这将对我的后续学习和研究有所帮助。

我相信通过不断地学习和实践，我会成为一名优秀的计算机学习者。

数据结构-顺序串基本操作实验报告

数据结构\顺序串基本操作实验报告实验报告数据结构\顺序串基本操作一、实验目的本实验旨在通过实践，掌握顺序串的基本操作，包括顺序串的初始化、销毁、插入、删除和查找等。

二、实验内容1\初始化顺序串2\销毁顺序串3\插入元素到顺序串4\删除顺序串中的指定元素5\查找顺序串中的指定元素三、实验步骤1\初始化顺序串顺序串的初始化就是创建一个空顺序串，可以通过创建一个定长数组来实现。

具体步骤如下：（1）定义一个定长数组，例如a[MAX_SIZE]，用于存储顺序串的元素。

（2）定义一个变量len，用于记录顺序串的当前长度，初值为0。

2\销毁顺序串销毁顺序串就是释放顺序串占用的内存空间，具体步骤如下：（1）释放数组a所占用的内存空间。

（2）将len重置为0。

3\插入元素到顺序串插入元素到顺序串就是在指定位置插入一个元素。

具体步骤如下：（1）判断插入位置的合法性，如果位置小于0或大于当前顺序串的长度，即为非法操作。

（2）将len加1，表示顺序串的长度增加了一个。

（3）将插入位置及其之后的元素依次后移一位。

（4）将需要插入的元素存放到插入位置处。

4\删除顺序串中的指定元素删除顺序串中的指定元素就是将顺序串中某个位置的元素删除。

具体步骤如下：（1）判断被删除位置的合法性，如果位置小于0或大于等于当前顺序串的长度，即为非法操作。

（2）将被删除位置之后的元素依次前移一位。

（3）将len减1，表示顺序串的长度减少了一个。

5\查找顺序串中的指定元素查找顺序串中的指定元素就是找出顺序串中第一个与给定元素相等的元素的位置。

具体步骤如下：（1）从顺序串的第一个元素开始逐个与给定元素比较，直到找到相等的元素或搜索到顺序串的末尾。

（2）返回相等元素的位置。

四、实验结果与分析根据实验步骤，我们可以完成顺序串的初始化、销毁、插入、删除和查找等基本操作。

通过这些操作，我们可以对顺序串进行各种元素的插入、删除和查找操作，方便实现顺序串的各种功能。

串的存储实验报告(3篇)

第1篇一、实验目的1. 理解串的概念及其在计算机中的应用。

2. 掌握串的存储方式及其在C语言中的实现。

3. 熟悉串的基本操作，如串的创建、串的复制、串的连接等。

4. 通过实验验证串操作的准确性和效率。

二、实验原理1. 串（String）是由零个或多个字符组成的有限序列，是计算机中常用的非数值数据类型。

2. 串的存储方式主要有两种：顺序存储和链式存储。

3. 顺序存储是将串的字符序列存储在一段连续的内存空间中，通过数组来实现。

4. 链式存储则是通过链表来实现，每个节点存储一个字符，节点之间通过指针连接。

三、实验环境1. 操作系统：Windows 102. 编程语言：C3. 编译器：Visual Studio 2019四、实验内容1. 创建一个串，并对其进行初始化。

2. 复制一个串，并验证复制的串与原串内容相同。

3. 连接两个串，并验证连接后的串内容。

4. 实现串的插入、删除、查找等操作。

5. 对串进行排序，如按字典序排序。

五、实验步骤1. 创建一个串```cinclude <stdio.h>include <stdlib.h>include <string.h>define MAX_SIZE 100typedef struct {char data[MAX_SIZE];int length;} String;// 创建串String createString(const char str) { String s;strcpy(s.data, str);s.length = strlen(str);return s;}```2. 复制一个串```c// 复制串String copyString(const String s) { String t;strcpy(t.data, s.data);t.length = s.length;return t;}```3. 连接两个串```c// 连接两个串String concatString(const String s1, const String s2) { String s;strcpy(s.data, s1.data);strcat(s.data, s2.data);s.length = s1.length + s2.length;return s;}```4. 实现串的插入、删除、查找等操作```c// 插入字符void insertChar(String s, int pos, char ch) {if (pos < 0 || pos > s->length) {printf("Insert position is invalid.\n");return;}for (int i = s->length; i >= pos; i--) {s->data[i + 1] = s->data[i];}s->data[pos] = ch;s->length++;}// 删除字符void deleteChar(String s, int pos) {if (pos < 0 || pos >= s->length) {printf("Delete position is invalid.\n"); return;}for (int i = pos; i < s->length - 1; i++) { s->data[i] = s->data[i + 1];}s->length--;}// 查找字符int findChar(const String s, char ch) {for (int i = 0; i < s.length; i++) {if (s.data[i] == ch) {return i;}}return -1;}```5. 对串进行排序```c// 字典序排序void sortString(String s) {for (int i = 0; i < s->length - 1; i++) {for (int j = i + 1; j < s->length; j++) {if (s->data[i] > s->data[j]) {char temp = s->data[i];s->data[i] = s->data[j];s->data[j] = temp;}}}}```六、实验结果与分析1. 创建串、复制串、连接串等操作均能正常进行，验证了串的存储和操作的正确性。

串的数据结构实验报告

串的数据结构实验报告串的数据结构实验报告一、引言在计算机科学中，串（String）是一种基本的数据结构，用于存储和操作字符序列。

串的数据结构在实际应用中具有广泛的用途，例如文本处理、搜索引擎、数据库等。

本实验旨在通过实践掌握串的基本操作和应用。

二、实验目的1. 理解串的概念和基本操作；2. 掌握串的存储结构和实现方式；3. 熟悉串的常见应用场景。

三、实验内容1. 串的定义和基本操作在本实验中，我们采用顺序存储结构来表示串。

顺序存储结构通过一个字符数组来存储串的字符序列，并使用一个整型变量来记录串的长度。

基本操作包括：- 初始化串- 求串的长度- 求子串- 串的连接- 串的比较2. 串的模式匹配串的模式匹配是串的一个重要应用场景。

在实验中，我们将实现朴素的模式匹配算法和KMP算法，并比较它们的性能差异。

四、实验步骤1. 串的定义和基本操作首先，我们定义一个结构体来表示串，并实现初始化串、求串的长度、求子串、串的连接和串的比较等基本操作。

2. 串的模式匹配a. 实现朴素的模式匹配算法朴素的模式匹配算法是一种简单但效率较低的算法。

它通过逐个比较主串和模式串的字符来确定是否匹配。

b. 实现KMP算法KMP算法是一种高效的模式匹配算法。

它通过利用已匹配字符的信息，避免不必要的比较，从而提高匹配效率。

3. 性能比较与分析对比朴素的模式匹配算法和KMP算法的性能差异，分析其时间复杂度和空间复杂度，并讨论适用场景。

五、实验结果与讨论1. 串的基本操作经过测试，我们成功实现了初始化串、求串的长度、求子串、串的连接和串的比较等基本操作，并验证了它们的正确性和效率。

2. 串的模式匹配我们对两种模式匹配算法进行了性能测试，并记录了它们的运行时间和内存占用情况。

结果表明，KMP算法相较于朴素算法，在大规模文本匹配任务中具有明显的优势。

六、实验总结通过本实验，我们深入学习了串的数据结构和基本操作，并掌握了串的模式匹配算法。

串操作实验报告

竭诚为您提供优质文档/双击可除串操作实验报告篇一：顺序串的基本操作实验报告宁波工程学院电信学院计算机教研室实验报告课程名称：数据结构实验项目：顺序串的基本操作实验人员：徐浩学号：10401010209班级：计科102指导教师：宋宏图实验位置：计算机中心二楼实验日期：20XX-10-13一、实验目的1）熟悉串的定义和串的基本操作。

2）掌握顺序串的基本运算。

3）加深对串数据结构的理解，逐步培养解决实际问题的编程能力。

二、实验环境装有Visualc＋＋6.0的计算机。

本次实验共计2学时。

三、实验内容编写一个程序，实现顺序串的各种基本运算，并在此基础上设计一个主程序。

具体如下：编写栈的基本操作函数顺序串类型定义如下所示：typedefstruct{charch[mAxsIZe];intlen;}seqstring;（1）串赋值Assign(s,t)?将一个字符串常量赋给串s,即生成一个其值等于t的串s（2）串复制strcopy(s,t)?将串t赋给串s（3）计算串长度strLength(s)?返回串s中字符个数（4）判断串相等strequal(s,t)?若两个串s与t相等则返回1；否则返回0。

（5）串连接concat(s,t)?返回由两个串s和t连接在一起形成的新串。

（6）求子串substr(s,i,j)?返回串s中从第i(1≤i≤strLength((:串操作实验报告)s))个字符开始的、由连续j个字符组成的子串。

（7）插入Insstr(s,i,t)?将串t插入到串s的第i(1≤i≤strLength(s)+1)个字符中,即将t的第一个字符作为s的第i个字符,并返回产生的新串（8）串删除Delstr(s,i,j)?从串s中删去从第i(1≤i≤strLength(s))个字符开始的长度为j的子串,并返回产生的新串。

（9）串替换Repstr(s,s1,s2)?在串s中,将所有出现的子串s1均替换成s2。

（10）输出串Dispstr(s)?输出串s的所有元素值（11）判断串是否为空Isempty(s)编写主函数调用上述函数实现下列操作：（1）建立串s=“abcdefghijklmn”，串s1=“xyz”，串t＝“hijk”（2）复制串t到t1，并输出t1的长度（3）在串s的第9个字符位置插入串s1而产生串s2，并输出s2（4）删除s第2个字符开始的5个字符而产生串s3，并输出s3（5）将串s第2个字符开始的3个字符替换成串s1而产生串s4，s4（6）提取串s的第8个字符开始的4个字符而产生串s5，并输出s5（7）将串s1和串t连接起来而产生串s6，并输出s6 （8）比较串s1和s5是否相等，输出结果程序：#include#definemAxsIZe100typedefstruct{charch[mAxsIZe];intlen;}sqstring;voidstrAssign(sqstringfor(i=0;t[i]!=\0;i++)s.ch[i]=t[i];s.len=i;}voidstrcopy(sqstring并输出for(i=0;i s.ch[i]=t.ch[i];s.len=t.len;}voidstrequal(sqstrings,sqstringt){//判断串相等intsame=1,i;if(s.len!=t.len){same=0;}else{for(i=0;i if(s.ch[i]!=t.ch[i]){same=0;break;}}if(same==0)printf("s1,s5不相等");elseprintf("s1,s5相等");printf("\n");}voidstrLength(sqstrings){//计算串长度printf("t1的长度：");printf("%d",s.len);printf("\n");}sqstringconcat(sqstrings,sqstringt){//串连接sqstringstr;inti;str.len=s.len+t.len;for(i=0;i str.ch[i]=s.ch[i];for(i=0;i str.ch[s.len+i]=t.ch[i];returnstr;}sqstringsubstr(sqstrings,inti,intj){//求子串sqstringstr;intk;str.len=0;if(is.len||js.len)returnstr;for(k=i-1;k str.ch[k-i+1]=s.ch[k];str.len=j;returnstr;}sqstringInsstr(sqstrings1,inti,sqstrings2){//插入intj;sqstringstr;str.len=0;if(is1.len+1)returnstr;for(j=0;j str.ch[j]=s1.ch[j];for(j=0;j str.ch[i+j-1]=s2.ch[j];for(j=i-1;j str.ch[s2.len+j]=s1.ch[j];str.len=s1.len+s2.len;returnstr;}sqstringDelstr(sqstrings,inti,intj){//删除intk;sqstringstr;str.len=0;if(is.len||i+j>s.len+1)returnstr;for(k=0;k str.ch[k]=s.ch[k];for(k=i+j-1;k str.ch[k-j]=s.ch[k];str.len=s.len-j;returnstr;sqstringRepstr(sqstrings,inti,intj,sqstringt){//替换intk;sqstringstr;str.len=0;if(is.len||i+j-1>s.len)returnstr;for(k=0;k str.ch[k]=s.ch[k];for(k=0;k str.ch[i+k-1]=t.ch[k];for(k=i+j-1;k str.ch[t.len+k-j]=s.ch[k];str.len=s.len-j+t.len;returnstr;}voidDispstr(sqstrings){//输出串所有元素inti;if(s.len>0){for(i=0;i printf("%c",s.ch[i]);printf("\n");}}voidIsempty(sqstrings){//判断串是否为空if(s.len>0)printf("串不为空");elseprintf("串为空");printf("\n");}篇二：串实验报告篇三：字符串实验报告数据结构字符串实验班级：计算机应用技术10-1学号：10602101048姓名：姚福刚一、实验目的及要求：掌握有关字符串的基本操作和存储结构，并编写相应的基本操作算法。

串的实验报告总结

串的实验报告总结本次实验旨在研究串（String）数据类型在计算机编程中的应用。

通过对串的基本操作和常见算法进行实验，探索串在字符串处理、文本编辑等方面的实际应用。

本报告将总结实验过程、结果及结论，并提出对进一步研究的展望。

实验内容与方法1.实验内容本次实验主要包括以下内容：-字符串的输入和输出；-串的基本操作，如串的连接、截取、插入等；-串的模式匹配算法，如KMP算法；-串的排序算法，如快速排序。

2.实验方法为了完成上述实验内容，我们采用了以下方法：-使用编程语言（如C++、Java）来实现串数据类型及其相关操作；-设计测试样例，验证实现的正确性和效率；-运行程序，记录实验结果并进行分析。

实验结果与分析经过实验，我们得到了以下结果和分析：1.字符串的输入和输出操作实现了预期的功能，可以正确地读取和显示字符串数据。

2.串的基本操作（连接、截取、插入等）能够正确地处理字符串，并且具有良好的效率。

3.KMP算法作为一种高效的模式匹配算法，能够快速地在文本中搜索指定的模式串，并返回匹配结果。

4.快速排序算法作为一种常用的排序算法，在处理大量字符串数据时表现出了较高的效率。

结论与展望通过本次实验，我们对串数据类型及其基本操作和常见算法有了更深入的理解。

串在计算机编程中具有重要的应用价值，特别是在字符串处理和文本编辑方面。

实验结果显示，实现的串操作功能正常，并且在性能上达到了预期的要求。

然而，本次实验还有改进和拓展的空间。

首先，可以进一步研究优化串的操作效率，提升算法的执行速度。

其次，可以探索更多的串算法，如字符串匹配的其他算法（如BM算法、Trie树等）以及字符串压缩算法等。

此外，可以考虑将串的应用扩展到更多领域，如自然语言处理、数据挖掘等。

综上所述，本次实验对于串数据类型的研究和应用具有重要意义，为进一步深入探索串的应用提供了基础和启示。

我们期待未来在串的研究中取得更多的成果，并将其应用于实际的计算机编程和软件开发中。

_串的基本操作

实验三串的基本操作【实验内容与要求】问题描述：采用顺序存储结构，完成串的联接和子串定位操作。

基本要求：（1）定义串的顺序存取结构。

（2）分别定义串的联接和子串定位的基本操作。

（3）设计一个测试主函数进行测试。

【测试数据】有两个串，分别为s1=‘ababbaabaa’，s2=‘aab’。

输出串s1与串s2联接的结果，以及在串s1中对串s2定位的结果。

二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）1）符号名说明s1，s2 分别定义为母串和字串的字符数组x，y 分别定义为全局变量，用来表示2个串的长度s3 表示连接完成的字符串k 表示定位的结果2）程序流程图三、源程序及注释：#include"stdio.h"#include"string.h"int x,y;int dingwei(char s1[],char s2[])；定位函数{ int i,j,k;i=0;j=0;while(i<x&&j<y)；i，j分别来控制s1，s2数组中字符的位置{if(s1[i]==s2[j])如果二者相等，则比较2个数组的下一位{i++;j++;}else {i=i-j+1;j=0; }；不相等j置数为0，i从i-j+1开始}if(s2[y-1]==s1[i-1]&&j==y) return i-j+1; 比较完后，输出比较结果else return 0;}int lianjie(char s1[],char s2[]){ int i,j,k;char s3[50];；定义一个数组来存放s1，s2连接后的字符串i=0;j=0;while(s1[i]!=0){ s3[i]=s1[i];i++; ；依次将s1中的字符串输入到s3中}while(s2[j]!=0){s3[i]=s2[j];将s2中的字符串紧接着传送到s3中i++;j++;}s3[i]=0;puts(s3);输出连接完成后的结果}int main(){char s1[50],s2[50];int i,j,k;printf("\t\t串的基本操作");printf("\n\t输入主字符串：");gets(s1);输入语句x=strlen(s1);计算s1的长度printf("\n\t输入子字符串：");gets(s2);y=strlen(s2);k=dingwei(s1,s2);调用定位函数printf("\n\t定位结果：");；输出定位结果if(k) printf("\t%d",k);else printf("不存在从属关系");printf("\n\t字符串相连：");lianjie(s1,s2);调用连接函数，将字符串连接getchar();}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：这个程序要实现的要求相对而言是比较容易实现的；只要知道关于字符数组的一些基本操作指令，再结合for语句循环，应该能实现题目所要求的条件。

串的基本操作和简程序实验心得

串的基本操作包括：1. 创建串：使用字符串常量或字符数组来创建一个串。

2. 初始化串：将串中的所有元素设置为一个特定的值。

3. 拷贝串：将一个串的内容复制到另一个串中。

4. 连接串：将两个或多个串连接在一起，形成一个新的串。

5. 求串长度：返回串中元素的个数。

6. 判断子串：检查一个串是否包含在另一个串中。

7. 查找子串：在一个串中查找指定子串的位置。

8. 替换子串：将一个串中的某个子串替换为另一个子串。

9. 插入子串：在指定位置插入一个子串。

10. 删除子串：从指定位置开始，删除指定长度的子串。

11. 截取子串：从指定位置开始，截取指定长度的子串。

12. 逆置串：将串中的元素顺序颠倒。

13. 遍历串：访问串中的每个元素。

以下是一个简单的C语言程序，用于实现上述操作：```c#include <stdio.h>#include <string.h>#include <stdlib.h>void create_string(char *str, const char *s);void init_string(char *str, char c);void copy_string(char *dest, const char *src);void concatenate_strings(char *dest, const char *s1, const char *s2); int length_string(const char *str);int substring_exists(const char *str, const char *sub);int find_substring(const char *str, const char *sub);void replace_substring(char *str, const char *old, const char *new); void insert_substring(char *str, int pos, const char *sub);void delete_substring(char *str, int pos, int len);void substring(char *dest, const char *str, int pos, int len);void reverse_string(char *str);void traverse_string(const char *str);int main() {char str1[100], str2[100], result[200];int pos = 2;int len = 3;int found = -1;int index = -1;const char *old = "world";const char *new = "everyone";const char *sub = "hello";const char *s1 = "Hello, ";const char *s2 = "world!";create_string(str1, "Hello");create_string(str2, "world");init_string(result, '-');concatenate_strings(result, s1, s2);printf("Concatenated string: %s", result);printf("Length of string: %d", length_string(result));found = substring_exists(result, sub);printf("Substring exists: %d", found);index = find_substring(result, sub);printf("Substring index: %d", index);replace_substring(result, old, new);printf("Replaced string: %s", result);insert_substring(result, pos, sub);printf("Inserted string: %s", result);delete_substring(result, pos, len);printf("Deleted string: %s", result);substring(result, result + index + strlen(sub), pos, len);printf("Substring after deletion: %s", result);reverse_string(result);printf("Reversed string: %s", result);traverse_string(result);return 0;}```实验心得：通过这个简单的程序，我了解了串的基本操作和实现方法。

串及其应用的实验报告

一、实验目的1. 理解串的概念及其基本操作。

2. 掌握串的创建、插入、删除、查找等操作。

3. 学习串在具体应用场景中的应用。

二、实验原理串（String）是一种特殊的线性表，它是由若干字符构成的有限序列。

串的基本操作包括创建、插入、删除、查找等。

在计算机科学中，串广泛应用于文本处理、字符串匹配、自然语言处理等领域。

三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验内容1. 串的创建2. 串的插入3. 串的删除4. 串的查找5. 串在文本处理中的应用五、实验步骤1. 串的创建（1）定义串的结构体```cppstruct String {char data; // 指向串中字符的指针int length; // 串的长度};```（2）创建串```cppString createString(const char str) {String s;s.data = new char[strlen(str) + 1]; // 为串分配内存strcpy(s.data, str); // 复制字符串到串中s.length = strlen(str); // 设置串的长度return s;}```2. 串的插入（1）在串的指定位置插入字符```cppvoid insertChar(String& s, int position, char ch) {if (position < 0 || position > s.length) {return; // 插入位置不合法}char newData = new char[s.length + 2]; // 为新串分配内存 strcpy(newData, s.data); // 复制原串到新串newData[position] = ch; // 在指定位置插入字符strcpy(s.data, newData); // 复制新串到原串s.length++; // 更新串的长度}```（2）在串的指定位置插入子串```cppvoid insertSubstring(String& s, int position, const char subStr) {if (position < 0 || position > s.length) {return; // 插入位置不合法}char newData = new char[s.length + strlen(subStr) + 1]; // 为新串分配内存strcpy(newData, s.data); // 复制原串到新串strcpy(newData + position, subStr); // 在指定位置插入子串strcpy(s.data, newData); // 复制新串到原串s.length += strlen(subStr); // 更新串的长度}```3. 串的删除（1）删除串中的单个字符```cppvoid deleteChar(String& s, int position) {if (position < 0 || position >= s.length) {return; // 删除位置不合法}char newData = new char[s.length]; // 为新串分配内存strcpy(newData, s.data); // 复制原串到新串strcpy(newData + position, newData + position + 1); // 删除指定位置的字符strcpy(s.data, newData); // 复制新串到原串s.length--; // 更新串的长度}```（2）删除串中的子串```cppvoid deleteSubstring(String& s, const char subStr) {int position = s.indexOf(subStr); // 查找子串的位置if (position == -1) {return; // 子串不存在}deleteChar(s, position); // 删除子串}```4. 串的查找（1）查找串中的单个字符```cppint indexOfChar(const String& s, char ch) {for (int i = 0; i < s.length; i++) {if (s.data[i] == ch) {return i; // 找到字符，返回位置}}return -1; // 未找到字符，返回-1}```（2）查找串中的子串```cppint indexOfSubstring(const String& s, const char subStr) {for (int i = 0; i <= s.length - strlen(subStr); i++) {if (strncmp(s.data + i, subStr, strlen(subStr)) == 0) {return i; // 找到子串，返回位置}}return -1; // 未找到子串，返回-1}```5. 串在文本处理中的应用（1）字符串替换```cppvoid replaceSubstring(String& s, const char oldStr, const char newStr) { int position = indexOfSubstring(s, oldStr);while (position != -1) {deleteSubstring(s, oldStr); // 删除旧子串insertSubstring(s, position, newStr); // 插入新子串position = indexOfSubstring(s, oldStr); // 继续查找旧子串}}```（2）字符串排序```cppvoid sortString(String& s) {char temp = new char[s.length + 1];strcpy(temp, s.data);qsort(temp, s.length, sizeof(char), [](const void a, const void b) { return (const char)a - (const char)b;});strcpy(s.data, temp);delete[] temp;}```六、实验结果与分析1. 创建串：通过创建一个包含“Hello, World!”的串，验证了串的创建功能。

串联_并联电路实验报告

一、实验目的1. 理解串联和并联电路的基本概念和特点。

2. 掌握串联和并联电路的连接方法。

3. 探究串联和并联电路的电流、电压分布规律。

4. 培养动手能力和实验操作技能。

二、实验原理1. 串联电路：将电路元件依次连接，电流只有一条路径可走，电流处处相等，电压按电阻成正比分配。

2. 并联电路：将电路元件首尾相连，电流有多条路径可走，干路电流等于各支路电流之和，各支路电压相等。

三、实验器材1. 电源：直流电源，电压可调。

2. 电阻：不同阻值电阻若干。

3. 电流表：量程合适的电流表。

4. 电压表：量程合适的电压表。

5. 开关：单刀双掷开关。

6. 导线：若干。

四、实验步骤1. 串联电路连接：（1）将电源、电阻、电流表、开关依次连接，形成串联电路。

（2）闭合开关，观察电流表示数，记录电流值。

（3）用电压表测量各电阻两端电压，记录电压值。

2. 并联电路连接：（1）将电源、电阻、电流表、开关依次连接，形成并联电路。

（2）闭合开关，观察电流表示数，记录电流值。

（3）用电压表测量各电阻两端电压，记录电压值。

3. 数据处理与分析：（1）根据实验数据，分析串联电路和并联电路的电流、电压分布规律。

（2）验证串联电路电流处处相等，电压按电阻成正比分配；并联电路干路电流等于各支路电流之和，各支路电压相等。

五、实验结果与分析1. 串联电路：实验结果显示，串联电路中电流处处相等，电压按电阻成正比分配。

这与实验原理相符。

2. 并联电路：实验结果显示，并联电路中干路电流等于各支路电流之和，各支路电压相等。

这也与实验原理相符。

六、实验结论1. 串联电路中，电流处处相等，电压按电阻成正比分配。

2. 并联电路中，干路电流等于各支路电流之和，各支路电压相等。

七、实验总结本次实验成功探究了串联和并联电路的电流、电压分布规律，验证了实验原理。

在实验过程中，我们掌握了串联和并联电路的连接方法，提高了动手能力和实验操作技能。

同时，我们也认识到实验过程中应注意的问题，如电路连接的准确性、测量仪器的选择等。

实验五顺序串实验报告

课内实验报告学生姓名:巩柠1009290212 及学号：江博1009290216王浩0809290228 学院: 理学院班级: 信计102课程名称：数据结构实验题目:顺序串基本操作指导教师郭新辰教授姓名及职称：胡建平副教授刘力实验师2011年10月18日目录一、实验目的 (1)二、实验内容 (1)三、实验要点及说明 (1)四、实现方法 (1)五、实验结果 (2)六、源程序清单 (2)七、思考及总结 (6)一、实验目的1. 了解顺序串的结构特点及有关概念；2. 理解顺序串的存储结构；3. 掌握顺序串的基本操作算法二、实验内容建立顺序串，完成顺序串的基本操作：初始化、求串长、串赋值、串连接、求子串、串比较、字串定位、串插入、子串删除、串替换、串清空、串输出等。

三、实验要点及说明通过一些函数对顺序串进行初始化，复制，插入等操作四、实现方法运行环境C++ 6.0五、实验结果六、源程序清单#include<stdio.h>#define MaxSize 50typedef struct{char data[MaxSize]; //存放字符串int length; //字符串长度}SqString;//将一个字符串常量赋给串svoid StrAssign(SqString &s,char cstr[]){int i;for(i=0;cstr[i]!='\0';i++) //这个'\0'代表字符串结束标志,编译系统自动加上的s.data[i]=cstr[i];s.length=i;}//字符串的复制void StrCopy(SqString &s,SqString t)int i;for(i=0;i<t.length;i++)s.data[i]=t.data[i];s.length=t.length;printf("字符串复制成功了\n");}//判断字符串是否相等void StrEqual(SqString s,SqString t){int i,same=1;if(s.length!=t.length)same=0;else{for(i=0;i<s.length;i++)if(s.data[i]!=t.data[i]){same=0;break;}}if(same==0)printf("这两个字符串不相等\n");elseprintf("这两个字符串相等\n");}//字符串的长度void StrLength(SqString s){printf("此字符串长度为：%d\n",s.length); }//合并字符串SqString Concat(SqString s,SqString t){SqString str;int i;str.length=s.length+t.length;for(i=0;i<s.length;i++)str.data[i]=s.data[i];for(i=0;i<t.length;i++)str.data[s.length+i]=t.data[i];return str;//求子字符串void SubStr(SqString s,int i,int j){SqString str;int k;str.length=0;if(i<=0||i>s.length||j<0||i+j-1>s.length)printf("子字符串复制失败\n");for(k=i-1;k<i+j-1;k++)str.data[k-i+1]=s.data[k];str.length=j;printf("子字符串复制成功长度为：%d\n",j); printf("下面输出此子字符串：\n");for(i=0;i<j;i++)printf("%c",str.data[i]);printf("\n");}//插入字符串SqString InserStr(SqString s1,int i,SqString s2){int j;SqString str;str.length=0;if(i<=0||i>s1.length+1){printf("字符串插入失败\n");return str;}for(j=0;j<i-1;j++)str.data[j]=s1.data[j];for(j=0;j<s2.length;j++)str.data[i-1+j]=s2.data[j];for(j=i-1;j<s1.length;j++)str.data[s2.length+j]=s1.data[j];str.length=s1.length+s2.length;printf("插入字符串成功长度为：%d\n",str.length); return str;}//删除字符串SqString DeleStr(SqString s,int i,int j){int k;SqString str;str.length=0;if(i<=0||i>s.length||i+j>s.length+1){printf("字符串删除失败\n"); return str;}for(k=0;k<i-1;k++)str.data[k]=s.data[k];for(k=i+j-1;k<s.length;k++)str.data[k-j]=s.data[k];str.length=s.length-j;printf("删除子字符串成功剩余长度为：%d\n",str.length); return str;}//替换字符串void RepStr(SqString s,int i,int j,SqString t){int k;SqString str;str.length=0;if(i<=0||i>s.length||i+j-1>s.length)printf("字符串替换失败了\n");for(k=0;k<i-1;k++)str.data[k]=s.data[k];for(k=0;k<t.length;k++)str.data[i+k-1]=t.data[k];for(k=i+j-1;k<s.length;k++)str.data[t.length+k-j]=s.data[k];str.length=s.length-j+t.length;printf("替换字符串成功新字符串长度为：%d\n",str.length); }//字符串的输出void DispStr(SqString s){int i;if(s.length>0){printf("下面输出这个字符串\n");for(i=0;i<s.length;i++)printf("%c",s.data[i]);printf("\n");}elseprintf("目前空字符串无法输出\n");}void main(){SqString s;char a[]={"boshi"}; //字符串常量aStrAssign(s,a);DispStr(s);StrLength(s);SqString s1,s2,t; //s1是待复制的字符串变量printf("请输入一个字符串t:\n");scanf("%s",t.data);StrAssign(t,t.data);StrCopy(s1,t); //复制字符串StrLength(s1);DispStr(s1);printf("下面判断字符串s1和字符串s是否相等\n");StrEqual(s,s1);printf("下面将字符串s1和字符串s合并一起\n");SqString str;str=Concat(s,s1); //合并字符串DispStr(str);StrLength(str);SubStr(str,22,7); //求子字符串str=DeleStr(str,15,4); //删除字符串DispStr(str);StrLength(str);printf("请插入一个字符串s2\n");scanf("%s",s2.data);StrAssign(s2,s2.data);str=InserStr(str,15,s2); //插入字符串DispStr(str);StrLength(str);printf("顺序字符串的基本运算到此结束了\n");}七、思考及总结对顺序串的基本操作有了一定的了解，在程序方面还有不懂的地方。

串的基本操作的编程实现

串的基本操作的编程实现Document serial number【NL89WT-NY98YT-NC8CB-NNUUT-NUT108】数据结构双语班DATA STRUCTURE BILINGUAL-TEACHING CLASS 实验报告003 批改单Experiment Report Commendatory Bill串基本操作的编程实现2006-2007（2）学期 T523-1班学号：33 姓名:王娟指导老师：马春江时间：【实验目的】内容：串基本操作的编程实现要求：串基本操作的编程实现（2学时，验证型），掌握串的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、合并、剪裁等操作，存储结构可以在顺序结构或链接结构、索引结构中任选，也可以全部实现，用菜单进行管理。

也鼓励学生利用基本操作进行一些应用的程序设计。

【实验性质】验证性实验（学时数：2H）【实验内容】可以只完成基本的功能演示程序。

也可以通过一个较为实用的系统下体现各种操作的作用，如可以开发一个文本统计程序，要求如下：编写程序，进行字符串统计系统的设计将存在txt文件中的文本进行统计：字母数、标点符号数、单词数、句子数、段落数。

进一步的工作（统计：汉字数、每个单词的次数和所在行数等）【详细设计】#include <>#include <>#include <>#define Maxlen 50#include <string>using namespace std;typedef struct{char ch[Maxlen];int len;}strtype;void disp(strtype *s) 出程序。

(按其他键继续) ┃","┃┃","┃┃","┃┃","┃ＯＯ════∩════ＯＯ指导老师：马春江┃","┃湖北汽车工业学院作者：王娟┃","┃▁╭▅▆▇□□█▇▆▅▄▃▂▁(╳)█╮┃","┃╰═▃_电气工程系∠════▔▔▔┃","┃*:-.,,.-:*``*:-.,,.-:*``*:-.,,.-:*``*:-.,,.-:*,, ┃","┃╭╧╮╭╧╮╭╧╮╭╧╮╭╧╮ *:-.,,.-:*,、☆*:-., ┃","┃║双║║语║║班║║天║║地║★*:-., ┃","┃└﹏┘└﹏┘└﹏┘└﹏┘└﹏┘┃","┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛"};int i,j;for(i=20;i>=0;i--){system("cls");for(j=i;j<=25;j++){cout<<"\t"<<p[j]<<endl;}Sleep(150);}}void menu2(){char *p[]={"┏━━┳┯┳┳┯┳┳┯┳┳┯┳┳┯┳┳┯┳┳┯┳┳┯┳━━┓","┃ ^_^┠数┨┠据┨┠结┨┠构┨┠程┨┠序┨┠设┨┠计┨^_^ ┃","┃┗┷┛┗┷┛┗┷┛┗┷┛┗┷┛┗┷┛┗┷┛┗┷┛┃","┣━━━━━━━━字符串的基本操作实现━━━━━━━━━┫","┃程序功能: ┃","┃┃","┃本程序实现字符串的基本操作┃","┃┃","┃ 0.退出程序。

顺序串的基本操作实验报告

数据顺序栈实验报告

数据结构顺序串基本操作实验报告

串操作实验报告

数据结构实验报告串

顺序串的基本操作实现

顺序串的基本操作

串的实验小结

数据结构-顺序串基本操作实验报告

串的存储实验报告(3篇)

串的数据结构实验报告

串操作实验报告

串的实验报告总结

_串的基本操作

串的基本操作和简程序实验心得

串及其应用的实验报告

串联_并联电路实验报告

实验五 顺序串实验报告

串的基本操作的编程实现

实验五顺序串实验报告