数据结构之串

最新推荐文章于 2024-09-27 14:59:03 发布
最新推荐文章于 2024-09-27 14:59:03 发布
阅读量213 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44161383/article/details/103627711
版权

八，实现顺序串的基本运算的算法

#include <stdio.h>
#include <stdlib.h>
#define max 100
typedef struct
{
	char data[max];
	int length;
}sqstring;
sqstring s, s1;
void strassign(sqstring &s, char str[])
{
	int i;
	for (i = 0; str[i] != '\0'; i++)
	{
		s.data[i] = str[i];
	}
	s.length = i;
}

bool equal(sqstring s, sqstring t)
{
	int i;
	if (s.length != t.length)
		return false;
	else
	{
		for (i = 0; i<s.length; i++)
		{
			s.data[i] != t.data[i];
			return false;
			break;
		}
	}
}

int length(sqstring &s)
{
	return s.length;
}

sqstring connect(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;
}

sqstring zichuan(sqstring s, int i, int j)   	//求子串 
{
	int k;
	sqstring str;
	str.length = 0;
	if (i <= 0 || i>s.length || j<0 || i + j - 1>s.length)
		return str;
	for (k = i - 1; k<i + j - 1; k++)
	{
		str.data[k - i + 1] = s.data[k];
	}
	str.length = j;
	return str;
}

sqstring insert(sqstring s1, int i, sqstring s2)
{
	int j;
	sqstring str;
	str.length = 0;
	if (i <= 0 || i>s1.length + 1)
		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 + j - 1] = 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;
	return str;
	printf("%s", str.data);
}
sqstring deletestr(sqstring s, int i, int j)
{
	int k;
	sqstring str;
	str.length = 0;
	if (i <= 0 || i>s.length || i + j>s.length + 1)
		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;
	return str;
}

sqstring repstr(sqstring s, int i, int j, sqstring t)
{
	int k;
	sqstring str;
	str.length = 0;
	if (i <= 0 || i>s.length || i + j>s.length + 1)
		return str;
	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;
	return str;
}

void dispstr(sqstring s)
{
	int i;
	if (s.length>0)
	{
		for (i = 0; i<s.length; i++)
		{
			printf("%c", s.data[i]);
		}
		printf("\n");
	}
}
int main(int argc, char *argv[])
{
	int num,n;
	sqstring s2;
	/*strassign(s, "abcdefghijklmn");
	strassign(s1, "xyz");*/
	char *ch1 = "abcdefghijklmn";
	char *ch2 = "xyz";
	strassign(s, ch1);
	strassign(s1, ch2);
	printf("请输入你要进行的操作：\n1.输出串s\n2.输出串s的长度\n3.在串s的第九个字符位置插入串s1\n4.删除串s的第二个字符开始的五个字符\n5.将串s的第二个字符开始的五个字符替换成串s1\n6.提出串s第二个字符开始的十个字符\n7.将两个串连起来\n\n");
	while (scanf("%d", &num))
	{
		switch (num)
		{
		case 1:
			dispstr(s);
			break;
		case 2:
			printf("%d\n",length(s));
			break;
		case 3:
			s2=insert(s, 9, s1);
			dispstr(s2);
			break;
		case 4:
			s2 = deletestr(s, 2, 5);
			dispstr(s2);
			break;
		case 5:
			s2 = repstr(s, 2, 5, s1);
			dispstr(s2);
			break;
		case 6:
			s2 = zichuan(s, 2, 10);
			dispstr(s2);
			break;
		case 7:
			s2 = connect(s, s1);
			dispstr(s2);
			break;
		default:printf("重新输入\n");
			break;
		}
	}
	system("pause");
	return 0;
}

在这里插入图片描述

九，实现链串的基本运算的算法

#include<stdio.h>
#include<stdlib.h>
typedef struct node
{
	char data;
	struct node *next;
}Linkstrnode;
Linkstrnode *s,*s1,*s2;
void assign(Linkstrnode *&s, char str[])		//生成串
{
	int i;
	Linkstrnode *r, *p;
	s = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	r = s;
	for (i = 0; str[i] != '\0'; i++)
	{
		p = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		p->data = str[i];
		r->next = p;			//类似尾插法
		r = p;
	}
	r->next=NULL; 
}

void destroy(Linkstrnode *&s)		
{
	Linkstrnode *p;
	while (s != NULL)
	{
		p = s;
		s = s->next;
		free(p);
	}
}

void copy(Linkstrnode *&s, Linkstrnode *t)
{
	Linkstrnode *p = t->next, *q, *r;
	s = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	r = s;
	while (p != NULL)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;				//尾插法
		r = q;
		p = p->next;
	}
	r->next = NULL;
}

bool equal(Linkstrnode *s, Linkstrnode *t)		//判断串相等
{
	Linkstrnode *p = s->next, *q = t->next;
	while (p != NULL&&q != NULL&&p->data == q->data)
	{
		p = p->next;
		q = q->next;
	}
	if (q == NULL&&p==NULL)
		return true;
	else
		return false;
}

int length(Linkstrnode *s)
{
	int i = 0;
	Linkstrnode *p = s->next;
	while (p != NULL)
	{
		i++;
		p = p->next;
	}
	return i;
}
Linkstrnode *concat(Linkstrnode *s, Linkstrnode *t)	//串的连接
{
	Linkstrnode *str, *p = s->next, *q, *r;
	str = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	r = str;
	while (p != NULL)
	{
		q= (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;
	}
	p = t->next;
	while (p != NULL)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;
	}
	r->next = NULL;
	return str;
}


Linkstrnode *zichuan(Linkstrnode *s, int i, int j)		//求子串
{
	int k;
	Linkstrnode *str, *p = s->next, *q, *r;
	str = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	str->next = NULL;
	r = str;
	if (i <= 0 || i > length(s) || j<0 || i + j - 1>length(s))
		return str;
	for (k = 1; k < i; k++)
	{
		p = p->next;
	}
	for (k = 1; k <= j; k++)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;
	}
	r->next = NULL;
	return str;
}

Linkstrnode *insert(Linkstrnode *s, int i, Linkstrnode *t)
{
	int k;
	Linkstrnode *str, *p = s->next,*p1=t->next, *q, *r;
	str = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	str->next = NULL;
	r = str;
	if (i <= 0 || i > length(s) + 1)
		return str;
	for (k = 1; k <= i; k++)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;
	}
	while (p != NULL)
	{
			q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
			q->data = p->data;
			r->next = q;
			r = q;
			p = p->next;
	}
	while (p != NULL)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;
		
	}
	r->next = NULL;
	return str;

}
Linkstrnode *deletestr(Linkstrnode *s, int i, int j)
{
	int k;
	Linkstrnode *str, *p = s->next, *q, *r;
	str = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	str->next = NULL;
	r = str;
	if (i <= 0 || i > length(s) || j<0 || i + j - 1>length(s))
		return str;
	for (k = 1; k <= i; k++)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;
	}
	for (k = 0; k < j; k++)
	{
		p = p->next;
	}
	while (p != NULL)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;
		r->next = q;
		r = q;
		p = p->next;

	}
	r->next = NULL;
	return str;
}

Linkstrnode *repstr(Linkstrnode *s, int i, int j, Linkstrnode *t)
{
	int k;
	Linkstrnode *str, *p = s->next, *p1 = t->next, *q, *r;
	str = (Linkstrnode *)malloc(sizeof(Linkstrnode));
	str->next = NULL;
	r = str;
	if (i <= 0 || i > length(s) || j<0 || i + j - 1>length(s))	
		return str;
	for (k = 0; k < i-1; k++)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;	q->next = NULL;
		r->next = q;
		r = q;
		p = p->next;
	}
	for (k = 0; k < j; k++)
	{
		p = p->next;
	}
	while (p1!= NULL)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p1->data;
		q->next = NULL;
		r->next = q;
		r = q;
		p1 = p1->next;
	}
	while (p != NULL)
	{
		q = (Linkstrnode *)malloc(sizeof(Linkstrnode));
		q->data = p->data;	q->next = NULL;
		r->next = q;
		r = q;
		p = p->next;
	}
	r->next = NULL;
	return str;
}

void dispstr(Linkstrnode *s)
{
	Linkstrnode *p = s->next;
	while (p != NULL)
	{
		printf("%c", p->data);
		p=p->next;
	}
	printf("\n");
}
int main()
{
		int num,n;
		assign(s, "abcdefghijklmn");
		assign(s1, "xyz");
		printf("请输入你要进行的操作：\n1.输出串s\n2.输出串s的长度\n3.在串s的第九个字符位置插入串s1\n4.删除串s的第二个字符开始的五个字符\n5.将串s的第二个字符开始的五个字符替换成串s1\n6.提出串s第二个字符开始的十个字符\n7.将两个串连起来\n\n");
		while (scanf("%d", &num))
		{
			switch (num)
			{
			case 1:
				dispstr(s);
				break;
			case 2:
				printf("%d\n",length(s));
				break;
			case 3:
				s2=insert(s, 9, s1);
				dispstr(s2);
				break;
			case 4:
				s2 = deletestr(s, 2, 5);
				dispstr(s2);
				break;
			case 5:
				s2 = repstr(s, 2, 5, s1);
				dispstr(s2);
				break;
			case 6:
				s2 = zichuan(s, 2, 10);
				dispstr(s2);
				break;
			case 7:
				s2 = concat(s, s1);
				dispstr(s2);
				break;
			default:printf("重新输入\n");
				break;
			}
		}

	system("pause");
	return 0;
}

在这里插入图片描述

十，实现顺序串的各种模式匹配算法

#include<stdio.h>
#include<stdlib.h>
#define max 100
typedef struct
{
	char data[max];
	int length;
}sqstring;
void strassign(sqstring &s,char cstr[])
{
	int i;
	for(i=0;cstr[i]!='\0';i++)
	{
		s.data[i]=cstr[i];
	}
	s.length=i;

}

void dispstr(sqstring s)
{
	int i;
	if(s.length>0)
	{
		for(i=0;i<s.length;i++)
			printf("%c",s.data[i]);
		printf("\n");
	}
}
int BF(sqstring s,sqstring t)
{
	int i=0,j=0;
	while(i<s.length&&j<t.length)
	{
		if(s.data[i]==t.data[j])
		{
			i++;
			j++;
		}
		else
		{
			i=i-j+1;
			j=0;
		}
	}
	if(j>=t.length)
		return(i-t.length);
	else
		return -1;
}
void getnext(sqstring t,int next[])
{
	
	int j,k;
	j=0;k=-1;
	next[0]=-1;
	while(j<t.length-1)
	{
		if(k==-1||t.data[j]==t.data[k])
		{
			j++;k++;
			next[j]=k;
		}
		else
			k=next[k];
	}
	
}
void getnextval(sqstring t)
{
	int nextval[100]={0};

	int j=0,k=-1;
	nextval[0]=-1;
	while(j<t.length)
	{
		if(k==-1||t.data[j]==t.data[k])
		{
			j++;k++;
			if(t.data[j]!=t.data[k])
				nextval[j]=k;
			else
				nextval[j]=nextval[k];
		}
		else
			k=nextval[k];

	}


	for(j=0;j<t.length;j++)
	{
		printf("%5d",nextval[j]);
	}
}

int KMP(sqstring s,sqstring t)
{
	int next[100];
	int i=0,j=0;
	getnext(t,next);
	
	while(i<s.length && j<t.length)
	{
		if(j==-1||s.data[i]==t.data[j])
		{
			i++;
			j++;
		}
		else
			j=next[j];
	}
		if(j>=t.length)
			return (i-t.length);
		else
			return -1;
}
int main()
{
	int a,b,j;
	
	sqstring S1,S2;
	char *s,*t;
	int next[100]={0};
	s="abcabcdabcdeabcdefabcdefg";
	t="abcdeabcdefab";
	strassign(S1,s);
	strassign(S2,t);
	dispstr(S1);
	dispstr(S2);
	a=BF(S1,S2);
	printf("t在s的中的位置为%   d\n",a);
	printf("t的next值为：\n");
	getnext(S2,next);
	for(j=0;j<S2.length;j++)
	{
		printf("%5d",next[j]);
	}
	printf("\n");
	printf("t的nextval值为：\n");
	getnextval(S2);
	printf("\n");
	b=KMP(S1,S2);
	printf("t在s的中的位置为%   d\n",b);
	system("pause");
	return 0;
}

在这里插入图片描述

陌生人你好.
关注
专栏目录
给定二叉树的先序遍历和中序遍历，输出它的后序遍历序列
buxizhizhou530的专栏
08-26 6442
这里没再用到先申请大Node数组的方法了，想练练写动态内存分配和释放的，一次OK了，也没怎么出错啊，开心~ 方法二 - Code： //给出一个二叉树的先序遍历和中序遍历，输出它的后序遍历 //直接构造的方法白书已给出。这里是先递归构造二叉树，然后进行后序遍历。 #include #include #include #define MAXN 1000 typedef struct nod
数据结构---串（结构体实现）
malechi的博客
10-14 3759
目录 顺序串及其基本运算的实现 链串及其基本运算的实现 串的模式识别 BF算法（简单粗暴）  KMP算法 改进的KMP算法 串(string)是由零个或多个字符组成的有限序列。kong'chuan是任何串的子串 串中所含字符的个数称为该串的长度。一般情况下，英文字母、数字和常用的变电符号以及空格符都是合法的字符。 两个串相等当且仅当它们的长度相等并且各对应位置上的字符都相同。 ...
C语言基础编程——链表（一）
weixin_43958845的博客
05-25 1561
一、静态链表 #include<stdio.h> #include<stdlib.h> typedef struct node { int data;///数据域 struct node* next;///指针域 }; int main() { system("color 7D");//背景颜色 struct node node1={1,NULL}; struct node node2={2,NULL}; struct node n
数据结构与算法
蜡笔小旧的博客
06-30 608
冒泡排序 #include<stdio.h> int main() { int i,j; int a[5] = {1,4,32,6,4}; for (i = 1; i <= 5; i++) {//要比较的次数，比较的次数就是 长度-1 for (j = 0; j <=5 - i - 1; j++) { //要比较的个数 就是从前面第一个 到倒数第几个，每一趟都会生成一个最大的在后面，所以后面的不用比较 if (a[j] >= a[j + 1]) {//如果相邻的
Qt学习之路(50): QString
weixin_34406796的博客
02-08 1607
这段时间回家，一直没有来得及写，今天才发现博客的编辑器有了新版。还是先来试试新版编辑器的功能吧！ 今天要说的是QString。之所以把QString单独拿出来，是因为string是很常用的一个数据结构，甚至在很多语言中，比如JavaScript，都是把string作为一种同int等一样的基本数据结构来实现的。 每一个GUI程序都需要string，这些string可以用在界...
C语言数据结构之串插入操作
01-20
C语言数据结构之串插入操作 实例代码： /* 串的堆分配存储表示 */ #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 typedef int Status; typedef ...
c语言 数据结构实现之字符串
08-30
C语言数据结构实现之字符串 C语言数据结构实现之字符串是指使用C语言来实现字符串数据结构的相关操作。字符串是一种基本的数据结构，广泛应用于计算机科学和信息技术领域。下面将详细介绍C语言数据结构实现之字符串...
数据结构——串
FREEDOM’s blog
07-08 4938
串的定义、基本操作、存储结构、模式匹配（朴素模式匹配算法、KMP算法）
C语言数据结构之模式匹配字符串定位问题
08-28
C语言数据结构之模式匹配字符串定位问题 模式匹配字符串定位问题是C语言数据结构中的一个重要知识点，它主要涉及到字符串的模式匹配和定位问题。在实际应用中，模式匹配字符串定位问题广泛应用于文本搜索、数据挖掘...
31. 括号序列
该博客暂停使用
06-18 765
一个括号序列是指一个由'(', ')', '[', ']'四种字符组成的字符串。 一个只包含数字，加号'+'，和上述四种括号的合法算数表达式，去掉数字和加号之后得到的括号序列成为合法的括号序列。我们定义空串也是合法的括号序列。 例如(1) + [2], ([3]), 4 + [5]相应的括号序列 "()[]", "([])", "[]"都是合法的括号序列。而(6 + 7], [8 + ((9对
蓝桥杯习题笔记-入门训练
huhuhuhuhuhu_hu的博客
10-05 529
蓝桥杯练习-入门训练Fibonacci数列圆的面积序列求和A+B问题 Fibonacci数列 问题描述 Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。 当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。 输入格式 输入包含一个整数n。 输出格式 输出一行，包含一个整数，表示Fn除以10007的余数。 说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数
串的基本操作
qq_41006871的博客
05-27 371
#include&lt;stdio.h&gt;#include&lt;string.h&gt;#include&lt;stdlib.h&gt;#include&lt;conio.h&gt;#define MAXN 50#define OK 1#define ERROR 0typedef struct strnode{    char str[MAXN+1];    int len;}Snode;v...
4-5把串s中最先出现的子串"ab"改为"xyz"
wuwuhuai的博客
02-09 1518
//把串s中最先出现的子串"ab"改为"xyz" #include "listring.cpp" void Repl(LinkStrNode *&amp;s) { LinkStrNode *p=s-&gt;next,*q; int find=0; while (p-&gt;next!=NULL &amp;&amp; find==0) //查找'ab'子串 { if (p-&gt;dat..
数据结构-字符串替换（顺序串）
程序员本员
12-11 5092
字符串替换 编写一个字符串替换的函数，函数头如下： void replace(sqstring *S, int i, int j, char T[]) 其中，S表示主串，为顺序串结构体，i表示被替换子串的开始位置（从1开始），j表示被替换子串的字符个数，T表示要替换的字符串。 提示：替换操作可以拆分成先删除，后插入两个步骤。可以先分别实现删除deleteString和插入insertString。其函数头为： void deleteString(sqstring *S, int i, int j) void
数据结构——用头插法和尾插法建立链表
＃两个西柚
07-21 4928
一、要求以头插法建立单链表 #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; LinkList Create(); void print( LinkList L); int main() { LinkList L = Create(); pr
C~排序算法
最新发布
weixin_60461563的博客
09-27 815
在C/C++中，有多种排序算法可供选择，每种算法都有其特定的应用场景和特点。下面介绍几种常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序，并给出相应的示例代码和解释。
数据结构：树、森林
pranaa的博客
09-24 820
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
考研数据结构——C语言实现插入排序
weixin_58879477的博客
09-24 380
C语言实现插入排序
C语言数据结构之串的概念与存储
"这篇资料详细介绍了C语言中数据结构中的串（String）概念，包括串的定义、存储结构和操作。" 在计算机科学中，数据结构是组织和管理数据的重要方式，而串作为数据结构的一种，是C语言中处理字符序列的基础。本资料...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值