数据结构串基本操作代码
实验三串基本操作的编程实现
实验三串基本操作的编程实现引言：串是由零个或多个字符组成的有限序列，是一种非常基础也非常重要的数据结构。
在本实验中，我们将学习串的基本操作，并使用C语言来实现这些操作。
1.实验目的：-掌握串的基本操作，包括串的初始化、判空、求长度、复制和拼接等操作；-学会使用C语言编程实现串的基本操作。
2.实验内容：本实验主要包括以下几个串的基本操作的编程实现。
2.1串的初始化操作在C语言中，我们可以使用字符数组来表示一个串。
以下是一个串的初始化操作的实现代码：```c#include <stdio.h>void InitString(char s[], char str[])int i;for (i = 0; str[i] != '\0'; i++)s[i] = str[i];}s[i]='\0';int maichar s[20];char str[] = "Hello, World!";InitString(s, str);printf("Initialized string: %s\n", s);return 0;```2.2串的判空操作判空操作即判断一个串是否为空串。
如果一个串的长度为0，则表示该串为空串。
以下是一个判空操作的实现代码示例：```c#include <stdio.h>#include <stdbool.h>bool IsEmptyString(char s[])return s[0] == '\0';int maichar s[20] = ""; // 空串if (IsEmptyString(s))printf("The string is empty.\n");} elseprintf("The string is not empty.\n");}return 0;```2.3串的长度操作求串的长度，即求一个串中字符的个数。
数据结构-单链表基本操作实现（含全部代码）
数据结构-单链表基本操作实现（含全部代码）今天是单链表的实现，主要实现函数如下：InitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点LocateElem(LinkList L,ElemType e) 参数：单链表L，元素e 功能：查找第⼀个等于e的元素，返回指针时间复杂度O(n)代码：/*Project: single linkeed list (数据结构单链表)Date: 2018/09/14Author: Frank YuInitList(LinkList &L) 参数：单链表L 功能：初始化时间复杂度 O(1)ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度时间复杂度O(n)ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插时间复杂度O(n)[加⼊了查找]若已知指针p指向的后插 O(1)ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素时间复杂度O(n)[加⼊了查找]若已知p指针指向的删除最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
数据结构实验报告串
一、实验目的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. 初始化串、赋值操作、求长度操作、定位操作均能正常执行，符合预期。
数据结构串的基本操作
串的生成（StrAssign）、串的比较（StrCompare）、串的联接（StrCombine）、求串的长度（StrLength）和求串的子串（StrSub）这5个操作构成的集合为OperationSet中的最小操作子集。
#include <stdio.h>#include <stdlib.h>#define MaxSize 100typedef struct{char data[MaxSize];int len;}SqString;void StrAssign(SqString &str,char cstr[]){int i;for (i=0;cstr[i]!='\0';i++)str.data[i]=cstr[i];str.len=i;}SqString StrCombine(SqString s,SqString t){SqString str;int i;str.len=s.len+t.len;for (i=0;i<s.len;i++)str.data[i]=s.data[i];for (i=0;i<t.len;i++)str.data[s.len+i]=t.data[i];return str;}SqString SubStr(SqString s,int i,int j){SqString str;int k;str.len=0;if(i<=0 || i>s.len || j<0 || i+j-1>s.len){printf("参数不正确\n");return str;}for(k=i-1;k<i+j-1;k++)str.data[k-i+1]=s.data[k];str.len=j;return str;}int StrCompare(SqString s,SqString t){int same=1,i;if (s.len!=t.len)same=0;elsefor (i=0;i<s.len;i++)if (s.data[i]!=t.data[i]){same=0;break;}return same;}SqString RepStr(SqString s,int i,int j,SqString t) {int k;SqString str;str.len=0;if (i<=0 || i>s.len || i+j-1>s.len){printf("参数不正确\n");return str;}for (k=0;k<i-1;k++)str.data[k]=s.data[k];for (k=0;k<t.len;k++)str.data[i+k-1]=t.data[k];for (k=i+j-1;k<s.len;k++)str.data[t.len+k-j]=s.data[k];str.len=s.len-j+t.len;return str;}int StrLength(SqString s){return s.len;}void ShowS(SqString s){int i;if (s.len>0){for (i=0;i<s.len;i++)printf("%c",s.data[i]);printf("\n");}}int main(){SqString s,s1,s2,s3,s4,s5;printf("--------------开始字符串的操作-------------\n");printf("建立串S和S1\n");StrAssign(s,"makesuccess");StrAssign(s1,"you");printf("输出串S\n");ShowS(s);printf("输出串S1\n");ShowS(s1);printf("输出串S的长度\n");printf("%d\n",StrLength(s));printf("输出串S1的长度\n");printf("%d\n",StrLength(s1));printf("提取串S的第2个字符开始的3个字符而生成串S2\n");s2 = SubStr(s,2,3);printf("输出串S2\n");ShowS(s2);printf("将串S1和S2连接起来而生成串S3\n");s3 = StrCombine(s1,s2);printf("输出串S3\n");ShowS(s3);printf("将串S的第4个字符开始的3个字符替换成串S1而生成串S4\n");s4 = RepStr(s,4,3,s1);printf("输出串S4\n");ShowS(s4);printf("串S4的长度\n");printf("%d\n",StrLength(s4));printf("提取串S4的第5个字符开始的4个字符而生成串S5\n");s5 = SubStr(s4,5,4);printf("输出串S5\n");ShowS(s5);printf("---------------字符串的操作完成-------------\n");return 0;}。
数据结构经典代码(严蔚敏)
/* 线性表的顺序表示：类型和界面定义*//* 线性表的顺序表示：函数实现*//* 线性表的单链表表示：类型和界面函数定义*//* 线性表的单链表表示：函数实现*//* 线性表的顺序表示：类型和界面定义*//* 线性表的顺序表示：函数实现*//* 用顺序表解决josephus问题的算法*//* 用循环单链表解决josephus问题的算法*//*字符串的顺序表示*//* 字符串的链接表示 *//* 顺序栈表示：类型和界面函数声明 *//* 顺序栈表示：函数定义 *//* 栈链接表示：类型和界面函数声明 *//*栈链接表示：函数定义*//* 简化背包问题的递归算法*//* 简化背包问题的非递归算法*//* 迷宫问题的递归算法*//* 迷宫问题的非递归算法(栈实现)*//* 队列的顺序表示：类型和函数声明 *//* 队列的顺序表示：函数定义 *//*队列链接表示：类型和界面函数声明*//*队列链接表示：函数定义*//* 用队列解决农夫过河问题的算法*//* 树的长子-兄弟表示法*//* 树的父指针表示法*//* 树的子表表示法*//* 树的后根周游的递归算法*//* 树的先根周游的非递归算法*//* 树的中根周游的递归算法*//* 树的后根周游的递归算法*//* 树的广度优先周游算法*//* 二叉树的链接表示*//* 二叉树的顺序表示*//* 线索二叉树的定义,构造算法和中根周游算法*//* 二叉树前根周游的递归算法*//* 二叉树对称根周游的递归算法*//* 二叉树后根周游的递归算法*//* 二叉树后根周游的非递归算法*//* 本程序提供了用顺序表实现字典的存储表示定义*//* 本程序是用开地址法解决碰撞的散列表示方法,提供了字典的一些基本操作*//* 字典的二叉排序树实现,本程序实现了二叉排序树的基本操作的算法*/ /* 字典的AVL树实现*//* 本程序提供了用顺序表实现字典的情况下的顺序检索算法*//* 本程序提供了用顺序表实现字典的情况下的二分法检索算法*//* 本程序是用开地址法实现散列的检索算法*//* 二叉排序树的检索算法*//* AVL树的检索算法*//* 最佳二叉排序树是具有最佳检索效率的二叉排序树, 本程序提供了最佳二叉排序树的构造方法*//* 直接插入排序的算法源程序*//* 二分法插入排序的算法源程序*//* 表插入排序的算法源程序*//* shell排序的算法源程序 *//* 直接选择排序的算法源程序*//* 堆排序的算法源程序*//* 起泡排序的算法源程序*//* 快速排序的算法源程序*//* 基数排序的算法源程序*//* 二路归并排序算法的源程序*//* 用图邻接矩阵表示实现的一些基本运算*//* 用图邻接表表示实现的一些基本运算*//* 用邻接矩阵表示的图的广度优先周游算法*//* 用邻接表表示的图的广度优先周游算法*//* 用邻接矩阵表示的图的深度优先周游的递归算法*/ /* 用邻接矩阵表示的图的深度优先周游的非递归算法*/ /* 用邻接表表示的图的深度优先周游的非递归算法*/ /* 用邻接矩阵表示的图的Kruskal算法的源程序*//* 用邻接矩阵表示的图的prim算法的源程序*//* 用邻接矩阵表示的图的Dijkstra算法的源程序*//* 用邻接矩阵表示的图的Floyd算法的源程序*//* 用邻接表表示图的拓扑排序算法*//* 用邻接矩阵表示图的拓扑排序算法*//* 图的关键路径问题的算法*//* 背包问题的贪心法算法*//* 用动态规划法求组和数的算法*//* 用回溯法解决骑士周游问题的算法*//* 0/1背包问题的回溯法算法*//* 0/1背包问题的动态规划法算法*//* 0/1背包问题的分支定界法算法*//* 线性表的顺序表示：类型和界面定义*/#define TRUE 1#define FALSE 0#define SPECIAL -1/* 定义顺序表的大小。
数据结构二叉树的基本操作代码
数据结构二叉树的基本操作代码x#include<iostream>using namespace std;//二叉树的结构struct TreeNode{int data;//节点的值TreeNode *left;//指向左子树TreeNode *right;//指向右子树};//插入节点void insert(TreeNode *&tree, int val){if(tree == NULL){tree = new TreeNode;tree->data = val;tree->left = tree->right = NULL;}else if(val<=tree->data)//小于根节点的值则插入到左子树 insert(tree->left, val);else if(val>tree->data)//大于根节点的值则插入到右子树 insert(tree->right,val);}//查找节点TreeNode* find(TreeNode *tree,int val){if (tree == NULL)//树为空，无法查找return NULL;else if (val == tree->data)//值和节点的值相等，返回该节点return tree;else if (val < tree->data)//值小于节点的值，查找左子树 return find(tree->left,val);else if (val > tree->data)//值大于节点的值，查找右子树 return find(tree->right,val);elsereturn NULL;//无法查找}//遍历二叉树//先序遍历void preOrder(TreeNode *tree){if(tree != NULL){cout<< tree->data <<'t'; //先访问根节点preOrder(tree->left); //再遍历左子树 preOrder(tree->right); //最后遍历右子树 }}//中序遍历void inOrder(TreeNode *tree){if(tree != NULL){inOrder(tree->left); //先遍历左子树 cout<< tree->data <<'t'; //再访问根节点inOrder(tree->right); //最后遍历右子树 }}//后序遍历void postOrder(TreeNode *tree){if(tree != NULL){postOrder(tree->left); //先遍历左子树 postOrder(tree->right); //再遍历右子树 cout<< tree->data <<'t'; //最后访问根节点 }}//查找最大值TreeNode* findMax(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->right == NULL)return tree;elsereturn findMax(tree->right);}//查找最小值TreeNode* findMin(TreeNode *tree){if(tree == NULL)return NULL;else if(tree->left == NULL)return tree;elsereturn findMin(tree->left);}//删除节点void remove(TreeNode *&tree, int val){if(tree == NULL)return;else if(val < tree->data)remove(tree->left, val);else if(val > tree->data)remove(tree->right, val);else//找到要删除的节点{if(tree->left != NULL && tree->right != NULL)//左右子树均不为空{TreeNode *temp = tree;TreeNode *max = findMax(tree->left);//查找左子树的最大结点tree->data = max->data;//将最大结点的值替换到要删除的节点remove(temp->left, max->data);//将最大结点删掉}else//只有一边的子节点不为空或者左右节点都为空{TreeNode *temp = tree;if(tree->left == NULL)//如果左节点为空，就将右节点提升 tree = tree->right;else if(tree->right == NULL)//如果右节点为空，就将左节点提升tree = tree->left;delete temp;//删掉要删除的节点}}}int main(){TreeNode *tree = NULL; //声明一个空树int arr[10] = {12, 3, 4, 6, 7, 9, 10, 5, 2, 8};for(int i=0; i<10; i++){insert(tree, arr[i]);//把数组元素插入到树当中}cout<<'先序遍历：';preOrder(tree);cout<<endl;cout<<'中序遍历：';inOrder(tree);cout<<endl;cout<<'后序遍历：';postOrder(tree);cout<<endl;cout<<'查找节点数据：4';TreeNode *findNode = find(tree, 4);if(findNode != NULL)//如果节点存在cout<<'找到了，节点的值是：'<<findNode->data;else//如果节点不存在cout<<'没有找到';cout<<endl;cout<<'查找树的最大值：'<<findMax(tree)->data<<endl; cout<<'查找树的最小值：'<<findMin(tree)->data<<endl; cout<<'删除节点：。
栈的基本操作代码
栈的基本操作代码引言栈（Stack）是一种常见的数据结构，具有后进先出（Last In First Out，LIFO）的特性。
栈的基本操作包括入栈（Push）、出栈（Pop）、获取栈顶元素（Top）和判断栈是否为空（IsEmpty）。
本文将详细介绍栈的基本操作代码及其实现。
一、栈的定义栈是一种线性数据结构，仅允许在一端进行插入和删除操作。
这一端被称为栈顶，另一端称为栈底。
栈的插入操作叫做入栈，删除操作叫做出栈。
栈的特性决定了最后插入的元素最先删除。
二、栈的基本操作2.1 入栈（Push）入栈操作将一个元素添加到栈的栈顶。
具体实现如下：class Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)2.2 出栈（Pop）出栈操作将栈顶元素删除并返回。
具体实现如下：class Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)def pop(self):if not self.is_empty():return self.stack.pop()else:return None2.3 获取栈顶元素（Top）获取栈顶元素操作不改变栈的结构，仅返回栈顶元素的值。
具体实现如下：class Stack:def __init__(self):self.stack = []def push(self, item):self.stack.append(item)def pop(self):if not self.is_empty():return self.stack.pop()else:return Nonedef top(self):if not self.is_empty():return self.stack[-1]else:return None2.4 判断栈是否为空（IsEmpty）判断栈是否为空操作用于检测栈内是否还有元素。
数据结构的串操作
数据结构的串操作数据结构的串操作
⒈概述
⑴串的定义
⑵串的基本操作
⒉串的存储结构
⑴顺序存储结构
⑵链式存储结构
⒊串的基本操作
⑴串的长度
⑵串的比较
⑶串的连接
⑷串的截取
⑸串的插入
⑹串的删除
⑺串的替换
⒋字符串匹配算法
⑴朴素模式匹配算法
⑵ KMP 算法
⑶ Boyer-Moore 算法
⑷ Rabin-Karp 算法
附件：
⒈示例代码
⒉数据集
法律名词及注释：
⒈串：在计算机科学中，串（String）是由零个或多个字符组成的有限序列。
⒉顺序存储结构：串的顺序存储结构是将串的字符按线性次序逐个存储在一组地址连续的存储单元里。
⒊链式存储结构：串的链式存储结构是通过定义一个节点类型来存储串的字符，每个节点包含一个字符和一个指向下一个节点的指针。
⒋朴素模式匹配算法：朴素模式匹配算法是最简单的字符串匹
配算法之一，通过对目标串的每个字符依次与模式串进行比较，直
到找到匹配的位置或遍历完所有字符。
⒌ KMP 算法：KMP 算法是一种高效的字符串匹配算法，通过利
用模式串的前缀和后缀信息，在匹配失败时将模式串移动比朴素算
法更远的位置，减少比较次数。
⒍ Boyer-Moore 算法：Boyer-Moore 算法是一种基于多种规则
的字符串匹配算法，通过从右到左比较模式串和目标串的字符，根
据不匹配字符在模式串中的位置和字符表进行移动，提高匹配效率。
⒎ Rabin-Karp 算法：Rabin-Karp 算法是一种利用哈希函数的
字符串匹配算法，通过计算目标串和模式串的哈希值，并逐个比较，减少比较次数。
python栈的基本操作代码
python栈的基本操作代码Python栈的基本操作代码栈是计算机科学中一种重要的数据结构，它具有后进先出（LIFO）的特性。
Python语言也提供了栈的实现，可以通过列表或deque等数据类型来实现栈。
本文将介绍Python栈的基本操作代码。
一、创建一个空栈在Python中，可以使用列表或deque来创建一个空栈。
下面是两种方法：1. 使用列表创建空栈stack = []2. 使用collections模块中的deque创建空栈from collections import dequestack = deque()二、判断栈是否为空在使用栈时，需要经常判断它是否为空。
可以使用len()函数或者直接判断列表或deque是否为空来进行判断。
1. 使用len()函数来判断if len(stack) == 0:print("Stack is empty")2. 直接判断列表或deque是否为空if not stack:print("Stack is empty")三、向栈中添加元素向栈中添加元素有两种方法：push()和append()。
其中，push()是自定义函数，append()是列表或deque内置方法。
1. 使用push()方法添加元素def push(stack, item):stack.append(item)2. 使用append()方法添加元素stack.append(item)四、从栈中删除元素从栈中删除元素同样有两种方法：pop()和remove()。
其中，pop()是自定义函数，remove()是列表或deque内置方法。
1. 使用pop()方法删除元素def pop(stack):if not stack:return "Stack is empty"else:return stack.pop()2. 使用remove()方法删除元素stack.remove(item)五、获取栈顶元素获取栈顶元素同样有两种方法：top()和[-1]。
数据结构(串)
数据结构(串)数据结构(串)数据结构中的串（String）是由字符构成的有限序列。
在计算机科学中，串是一种基本的数据结构，被广泛应用于字符串处理、文本搜索、模式匹配等领域。
1. 串的定义和基本操作串可以使用多种方式来定义和表示，常见的方式有：- 定长顺序存储表示：使用数组来存储串，数组的长度和最大串长相等，不足的部分用特定字符填充（通常用空格）。
- 堆分配存储表示：使用堆（动态内存分配区）来存储串，可以根据实际需要动态分配和释放串的存储空间。
- 串的块链存储表示：将串分成多个块，将每个块使用链表进行表示，将各块在一起组成完整的串。
串的基本操作包括：- 串的赋值：将一个串赋值给另一个串。
- 串的连接：将两个串按顺序连接成一个新的串。
- 串的比较：比较两个串的大小关系。
- 串的截取：从一个串中截取出一段子串。
- 串的插入：将一个串插入到另一个串的指定位置。
- 串的删除：删除一个串中指定位置的字符或一段子串。
- 串的替换：将一个串中指定位置的字符或一段子串替换成另一个串。
2. 串的匹配算法串的匹配是指在一个主串中查找一个模式串的过程。
常见的串匹配算法包括：- 朴素匹配算法：也称为暴力匹配算法，是最简单的匹配算法。
它从主串的第一个字符开始，与模式串逐个字符进行比较，若不匹配，则主串向后移动一位，直到找到匹配的子串或主串遍历完。
- KMP算法：即Knuth-Morris-Pratt算法，通过利用模式串自身的信息，减少字符的比较次数。
该算法具有线性时间复杂度，是一种高效的匹配算法。
- Boyer-Moore算法：基于模式串中的字符发生不匹配时的启发式策略，通过跳跃式地移动模式串，减少字符的比较次数，从而提高匹配效率。
3. 串的应用串作为一种基本的数据结构，在实际应用中具有广泛的用途，主要包括以下几个方面：- 字符串处理：串在文本编辑、编译器设计、语法分析、文件操作等方面都有广泛应用。
- 模式匹配：串的匹配算法常被用于字符串搜索、DNA序列分析、信息检索等领域。
数据结构—顺序表的基本操作
数据结构—顺序表的基本操作#include<iostream>using namespace std;#define MaxSize 10typedef struct SqList {int data[MaxSize];int length;}SqList;// 初始化⼀个顺序表void InitList(SqList &L){for (int i=0; i<MaxSize; i++)L.data[i] = 0;L.length = 0;}// 在顺序表的第i个位置插⼊元素ebool ListInsert(SqList &L, int i, int e){if (i<1 || i>L.length+1) // 判断i的范围是否有效return false;if (L.length >= MaxSize) // 当前存储空间已满，不能插⼊return false;for (int j=L.length; j>=i; j--) // 将第i个元素及以后的元素后移L.data[j] = L.data[j-1];L.data[i-1] = e; // 在位置i放⼊元素eL.length ++; // 长度加·1return true;}// 在顺序表的第i个位置插⼊元素ebool ListDelete(SqList &L, int i, int &e){if (i<1 || i>L.length) // 判断i的范围是否有效return false;e = L.data[i-1]; // 将被删除的元素赋值给efor (int j=i; j<L.length; j++) // 将第i个位置后的元素前移L.data[j-1] = L.data[j];L.length --; // 长度加·1return true;}// 按位置查找元素, 返回元素值int GetElem(SqList L, int i){if (i<1 || i>L.length) // 判断i的范围是否有效return 0;return L.data[i-1];}// 按值查找元素，返回元素的位置int LocElem(SqList L, int e){for (int i=0; i<L.length; i++)if (L.data[i] == e)return i+1;return 0;}int main(){SqList L;InitList(L); // 初始化ListInsert(L,1,1); // 插⼊元素ListInsert(L,2,2); // 插⼊元素ListInsert(L,3,3); // 插⼊元素int e = -1;ListDelete(L,2,e); // 删除元素cout << "delete element: " << e << endl;int a = GetElem(L, i); // 按位置查找元素int b = LocElem(L, e); // 按值查找元素for (int i=0; i<L.length; i++)cout << "data[" << i << "]=" << L.data[i] << endl;return 0;}。
串-数据结构实验报告[修改版]
![串-数据结构实验报告[修改版]](https://img.taocdn.com/s3/m/c2761ee859eef8c75ebfb30c.png)
第一篇：串-数据结构实验报告【源程序】：#include #include #include void choose(char *s, int i,int m,char *t);//i位置截取m个字符函数void main() //主函数{ char *s,*t; int i,sl,m;s=(char *)malloc(100*sizeof(char));t=(char *)malloc(100*sizeof(char));printf("\n 输入主字符串s=?"); gets(s); printf("\n s=%s\n",s);printf("\n 输入位置i=?"); scanf("%d",&i); printf("\n i=%d\n",i);printf("\n 输入字符个数m=?"); scanf("%d",&m); printf("\n m=%d\n",m);sl=strlen(s);if(i>sl) printf("i位置出错\n");else if(i+m>sl+1) printf("m位置出错\n");else{choose(s,i,m,t);printf("\n 子串为t=%s\n",t);} } //end_main void choose(char *s, int i,int m,char *t) { int n;int j=0; for(n=i;n三.实验结论及分析串的存储结构包含有顺序存储结构和链式存储结构。
在串的顺序存储结构中，表示串的长度通常有两种方法：一种方法是设置一个串的长度参数，其优点在于便于在算法中用长度参数控制循环过程；另一种方法是在串值得末尾添加结束标记，此种方法的优点在于便于系统自动实现。
数据结构串的性质和基本操作本
S s s p r i n p r i n
？
g
^
g # # # # ^
直接采用第一种链表 存储串值，进行操 作时效率太低。
串的块链存储表示
块的结构定义
#define CHUNKSIZE 80 ∥可由用户定义的块大小
typedef struct Chunk{ ∥结点结构
char ch[CHUNKSIZE];
本章内容
4.1 串的定义 4.2 串的表示和实现
1.串的顺序存储结构 2.串的链式存储结构
4.3 串的模式匹配算法
1.朴素的模式匹配算法
2.KMP算法
串的定义和相关概念
1.串的定义
串（ String ） : 由零个或多个字符组成的有限序列。 记为：s=’a1a2…an’（n≥0）
2.相关概念
s为串名， ’a1a2…an’为串值，n为串的长度。 ai，约束为字符集中的字符。 空串（Null String）：n=0，记为：Ф 。 子串在主串中的位置：以子串的第一个字符在 空格串 (blank string) ：串中仅包含空格字符。 主串中的位置来表示。 串相等：当且仅当两个串的串值相等（两个串的长 子串：串中任意个连续的字符组成的子序列称为 该串的子串。包含子串的串被称为主串。 度相等，并且各个对应的字符也都相等）。
例如：串的联接算法中需分三种情况处理：
Status Concat(SString S1, SString S2, SString &T) {
// 用T返回由S1和S2联接而成的新串。若未截断, 则返回TRUE，否则FALSE。
return uncut; } // Concat
if (S1[0]+S2[0] <= MAXSTRLEN) {// 未截断 T[1..S1[0]] = S1[1..S1[0]]; else if (S1[0] <MAXSTRSIZE) { // 截断 T[S1[0]+1..S1[0]+S2[0]] = S2[1..S2[0]]; T[1..S1[0]] = S1[1..S1[0]]; T[0] = S1[0]+S2[0]; uncut else { // 截断(仅取 S1) = TRUE; } T[S1[0]+1..MAXSTRLEN] = T[0..MAXSTRLEN] = S1[0..MAXSTRLEN]; S2[1..MAXSTRLEN－S1[0]]; // T[0] == S1[0] == MAXSTRLEN T[0] = MAXSTRLEN; uncut = FALSE; } uncut = FALSE; }
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构 串基本操作代码
数据结构串基本操作代码简介本文档介绍了数据结构中串的基本操作代码,包括串的定义、串的赋值、串的比较、串的连接、串的替换等。
1.串的定义串是由零个或多个字符组成的有限序列,是字符串的抽象数据类型。
常用的串类型包括顺序串和链式串。
1.1 顺序串顺序串是使用数组来存储字符序列的数据结构。
其定义如下：```cdefine MaXSiZe 100 // 串的最大长度typedef struct {char data[MaXSiZe]； // 存储串的字符数组int length； // 串的长度} SqString；```1.2 链式串链式串是使用链表来存储字符序列的数据结构。
其定义如下：```ctypedef struct LNode {char data； // 存储串的字符struct LNode next； // 指向下一个节点的指针} LNode, LinkString；```2.串的基本操作2.1 串的赋值将一个字符串赋值给一个串,可以使用字符串赋值函数`strcpy`或者循环遍历字符串赋值。
2.1.1 使用strcpy函数赋值```cinclude <string.h>void Strassign(SqString s, char str) {strcpy(s->data, str)；s->length = strlen(str)；}```2.1.2 使用循环遍历赋值```cvoid Strassign(SqString s, char str) {int i；for (i = 0； str[i] ！= '\\0'； i++) {s->data[i] = str[i]；}s->length = i；s->data[i] = '\\0'；}```2.2 串的比较比较两个串是否相等,可以使用字符串比较函数`strcmp`或者循环遍历比较。
数据结构串基本操作代码
数据结构串基本操作代码串是由零个或多个字符组成的有限序列，是数据结构中的一种基本数据类型。
常见的串操作有串的存储、串的插入、串的删除、串的替换、串的连接、串的比较等。
以下是对串基本操作的代码实现：1.串的存储串的存储可以使用数组或链表来实现。
下面是基于数组的实现方式。
```C++#define MAX_LEN 100 // 定义串的最大长度typedef structchar data[MAX_LEN]; // 存储串的字符数组int length; // 当前串的长度} String;//初始化串void InitString(String &s)s.length = 0;//串赋值void AssignString(String &s, char str[])int len = strlen(str);for (int i = 0; i < len; i++)s.data[i] = str[i];}s.length = len;//输出串void PrintString(String s)for (int i = 0; i < s.length; i++)cout << s.data[i];}cout << endl;```2.串的插入在指定位置上插入指定内容。
```C++//串的插入void InsertString(String &s, int pos, char str[]) int len = strlen(str);if (s.length + len > MAX_LEN)return; // 串已满，无法插入for (int i = s.length - 1; i >= pos; i--)s.data[i + len] = s.data[i];}for (int i = pos, j = 0; j < len; i++, j++)s.data[i] = str[j];}s.length += len;```3.串的删除删除指定位置上的字符。
数据结构实验报告-串
实验四串【实验目的】1、掌握串的存储表示及基本操作；2、掌握串的两种模式匹配算法：BF和KMP。
3、了解串的应用。
【实验学时】2学时【实验预习】回答以下问题：1、串和子串的定义串的定义：串是由零个或多个任意字符组成的有限序列。
子串的定义：串中任意连续字符组成的子序列称为该串的子串。
2、串的模式匹配串的模式匹配即子串定位是一种重要的串运算。
设s和t是给定的两个串，从主串s的第start个字符开始查找等于子串t的过程称为模式匹配，如果在S中找到等于t的子串，则称匹配成功，函数返回t在s中首次出现的存储位置（或序号）；否则，匹配失败，返回0。
【实验内容和要求】1、按照要求完成程序exp4_1.c，实现串的相关操作。
调试并运行如下测试数据给出运行结果：•求“This is a boy”的串长；•比较”abc3”和“abcde“；表示空格•比较”english”和“student“；•比较”abc”和“abc“；•截取串”white”，起始2，长度2；•截取串”white”，起始1，长度7；•截取串”white”，起始6，长度2；•连接串”asddffgh”和”12344”；#include<stdio.h>#include<string.h>#define MAXSIZE 100#define ERROR 0#define OK 1/*串的定长顺序存储表示*/typedef struct{char data[MAXSIZE];int length;} SqString;int strInit(SqString *s);/*初始化串*/int strCreate(SqString *s); /*生成一个串*/int strLength(SqString *s); /*求串的长度*/int strCompare(SqString *s1,SqString *s2); /*两个串的比较*/int subString(SqString *sub,SqString *s,int pos,int len);/*求子串*/int strConcat(SqString *t,SqString *s1,SqString *s2);/*两个串的连接*//*初始化串*/int strInit(SqString *s){s->length=0;s->data[0]='\0';return OK;}/*strInit*//*生成一个串*/int strCreate(SqString *s){printf("input string :");gets(s->data);s->length=strlen(s->data);return OK;}/*strCreate*//*（1）---求串的长度*/int strLength(SqString *s){return s->length;}/*strLength*//*（2）---两个串的比较，S1>S2返回>0，s1<s2返回<0，s1==s2返回0*/int strCompare(SqString *s1,SqString *s2){int i;for(i=0;i<s1->length&&i<s2->length;i++){if(s1->data[i]>s2->data[i]){return 1;}if(s1->data[i]<s2->data[i]){return -1;}}return 0;}/*strCompare*//*（3）---求子串，sub为返回的子串，pos为子串的起始位置，len为子串的长度*/int subString(SqString *sub,SqString *s,int pos,int len) {int i;if(pos<1||pos>s->length||len<0||len>s->length-pos+1) {return ERROR;}sub->length=0;for(i=0;i<len;i++){sub->data[i]=s->data[i+pos-1];sub->length++;}sub->data[i]='\0';return OK;}/*subString*//*（4）---两个串连接，s2连接在s1后，连接后的结果串放在t中*/int strConcat(SqString *t,SqString *s1,SqString *s2){int i=0,j=0;while(i<s1->length){t->data[i]=s1->data[i];i++;}while(j<s2->length){t->data[i++]=s2->data[j++];}t->data[i]='\0';t->length=s1->length+s2->length;return OK;}/*strConcat*/int main(){int n,k,pos,len;SqString s,t,x;do{printf("\n ---String--- \n");printf(" 1. strLentgh\n");printf(" 2. strCompare\n");printf(" 3. subString\n");printf(" 4. strConcat\n");printf(" 0. EXIT\n");printf("\n ---String---\n");printf("\ninput choice:");scanf("%d",&n);getchar();switch(n){case 1:printf("\n***show strLength***\n");strCreate(&s);printf("strLength is %d\n",strLength(&s));break;case 2:printf("\n***show strCompare***\n");strCreate(&s);strCreate(&t);k=strCompare(&s,&t); /*（5）---调用串比较函数比较s，t*/if(k==0)printf("two string equal!\n");else if(k<0)printf("first string<second string!\n");elseprintf("first string>second string!\n");break;case 3:printf("\n***show subString***\n");strCreate(&s);printf("input substring pos,len:");scanf("%d,%d",&pos,&len);if(subString(&t,&s,pos,len))printf("subString is %s\n",t.data);elseprintf("pos or len ERROR!\n");break;case 4:printf("\n***show subConcat***\n");strCreate(&s);strCreate(&t);if(strConcat(&x,&s,&t)) /*（6）---调用串连接函数连接s&t*/printf("Concat string is %s",x.data);elseprintf("Concat ERROR!\n");break;case 0:exit(0);default:break;}}while(n);return 0;}2、按照要求完成程序exp4_2.c，实现BF&KMP串的模式匹配算法。
数据结构 第四章 串
第四章串串又称字符串，是一种特殊的线性表，它的每个元素仅由一个字符组成。
计算机上非数值处理的对象基本上是字符串数据。
在较早的程序设计语言中，字符串仅作为输入和输出的常量出现。
随着计算机应用的发展，在越来越多的程序设计语言中，字符串也可作为一种变量类型出现，并产生了一系列字符串的操作。
在信息检索系统、文字编辑程序、自然语言翻译系统等等应用中，都是以字符串数据作为处理对象的。
本章将讨论串的存储结构和基本操作。
4.1 串的基本概念4.1.1 串的自然语言定义串(string)(或字符串)是由零个或多个字符组成的有限序列，一般记为：S="a1 a2 …… a n" (n≥0)其中，S是串名，用双引号括起来的字符串序列是串的值；a i(1≤i≤n)可以是字母、数字或其他字符；串中字符的个数n称为串的长度。
长度为0的串称为空串。
需要注意的是，串值必须用一对双引号括起来，但双引号本身不属于串，它的作用只是为了避免与变量名或数的常量混淆。
如"tempt"是个串,tempt则是变量名；"23"是串,而23则是一个常量.串中任意个连续的字符组成的子序列称为该串的子串，如：串S＝"This is a string"，其中"This"是一个子串，"string"也是一个子串。
求子串在串中的起始位置称为子串定位或模式匹配。
例如，设A，B，C为如下三个串：A＝"data"，B="structure"，C＝"data structure"，则它们的长度分别是4,9，14，A和B都是C的子串，A在C中的位置是1，而B在C中的位置是6。
下面注意区别空格串与空串的概念。
在各种应用中，空格常常是串的字符集合中的一个元素，因而可以出现在其他字符中间。
由一个或多个空格组成的串称为空格串，也就是说空格串中只有空格字符，空格串的长度不为零。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三串//串的基本操作#include "stdio.h"#include "stdlib.h"#define MAXSTRLEN 255typedef unsigned char SString[MAXSTRLEN+1];void strlength(SString S)//求字串并放到 S[0] 中{int m;for(m=1;S[m]!='\0';m++);S[0]=m-1;}void insert(SString S,int n,char a)//是插入的位置 a 是插入的字符{strlength(S);int i;for(i=S[0];i>=n;i--)S[i+1]=S[i];S[n]=a;S[S[0]+2]='\0';}int compare(SString S,SString T){strlength(S);strlength(T);int i;for(i=1;i<=S[0]&&i<=T[0];i++){if(S[i]>T[i])return 1;if(S[i]<T[i])return -1;if(S[i]==T[i])continue;}if(S[0]>T[0])return 1;else if(S[0]<T[0])return -1;elsereturn 0;}void concat(SString T1,SString S1,SString S2){strlength(S1);strlength(S2);int i;if(S1[0]+S2[0]<=MAXSTRLEN)//未截断{for(i=1;i<=S1[0];i++)T1[i]=S1[i];for(i=1;i<=S2[0];i++)T1[S1[0]+i]=S2[i];}T1[S1[0]+S2[0]+1]='\0';}void clear(SString S){strlength(S);int i;for(i=1;i<S[0];i++)S[i]='\0';S[0]=0;}int SubString(SString &Sub,SString S,int pos,int len){int i;strlength(S);if(pos<1||pos>S[0]||len<0||len>S[0]-pos+1){printf("Error!position or length is out of range\n");return 0;}for(i=1;i<=len;i++)Sub[i]=S[pos+i-1];Sub[i]='\0';Sub[0]=len;return 1;}int Index(SString S,SString T,int pos) {int i=pos,j=1;strlength(S);strlength(T);while(i<=S[0]&&j<=T[0]){if(S[i]==T[j]){++i;++j;}else{i=i-j+2;j=1;}}if(j>T[0])return i-T[0];else return 0;}void main()// 测试主程序{/*SString S;printf(" 请输入字符串S： ");scanf("%s",S+1);printf("\n");printf(" 输入的字符串为： ");printf("%s",S+1);printf("\n");insert(S,2,'A');printf(" 插入字符后的字符串为："); printf("%s",S+1);printf("\n");*//*SString T;printf(" 请输入字符串T： ");scanf("%s",T+1);printf("\n");int flag;flag=compare(S,T);printf("%d",flag);*//*SString S1,S2,T1;printf(" 请输入字符串S1：");scanf("%s",S1+1);printf(" 请输入字符串S2：");scanf("%s",S2+1);concat(T1,S1,S2);printf(" 连接的新字符串为： ");printf("%s",T1+1);printf("\n");*//*SString S;printf(" 请输入字符串S： ");scanf("%s",S+1);printf(" 你输入的字符串为： %s\n",S+1); clear(S);printf("%s\n",S+1);*//*SString S,Sub;int pos,len;printf(" 请输入字符串S： ");scanf("%s",S+1);printf(" 请输入子串的位置： ");scanf("%d",&pos);printf(" 请输入子串的长度： ");scanf("%d",&len);if(SubString(Sub,S,pos,len)){printf("\n 子串为： %s\n",Sub+1);printf(" 子串的长度： %d\n",Sub[0]);}*/SString S,T;int pos,r;printf(" 输入主串： ");scanf("%s",S+1);printf(" 输入模式串： ");scanf("%s",T+1);printf(" 请输入起始位置pos：");scanf("%d",&pos);if(r=Index(S,T,pos))printf(" 模式串在主串中的位置为：%d\n",r);else printf("匹配失败！ \n");}//字符串中字符频度#include "Stdio.h"#include "stdlib.h"#define MAXSTRLEN 255typedef unsigned char SString[MAXSTRLEN+1]; typedef struct charcp{char zifu;int pingdu;struct charcp *next;}charcp,*Linkchar;void Strlength(SString S){int i;for(i=1;S[i]!='\0';i++);S[0]=i-1;}void Init(Linkchar &cp){cp=(Linkchar)malloc(sizeof(charcp));cp->next=NULL;cp->zifu='\0';cp->pingdu=0;}void Pingdu(SString S,Linkchar &cp){int i=1;charcp *p;charcp *q;while(S[i]!='\0'){p=cp;if(p->zifu=='\0'){p->zifu=S[i];p->pingdu++;i++;continue;}while(p->next!=NULL){if(p->zifu==S[i]){p->pingdu++;break;}p=p->next;}if(p->next==NULL){if(p->zifu==S[i]){p->pingdu++;}else{q=(Linkchar)malloc(sizeof(charcp));q->zifu=S[i];q->pingdu=1;q->next=NULL;p->next=q;}}i++;}}void main(){Linkchar cp;Init(cp);SString S;printf(" 请输入字符串S： ");scanf("%s",S+1);Pingdu(S,cp);charcp *p=cp;while(p!=NULL){printf(" 字符 %c 的频度为 %d \n",p->zifu,p->pingdu);p=p->next;}}。