精华内容
下载资源
问答
  • 数据结构基本操作,使用C语言,完整代码,可以使用
  • 问题描述:采用顺序存储结构,完成的联接和子串定位操作。 基本要求: (1) 定义的顺序存取结构。 (2) 分别定义的联接和子串定位的基本操作。 (3) 设计一个测试主函数进行测试。
  • 数据结构实验三_串基本操作的编程实现(C语言)

    千次阅读 多人点赞 2019-04-24 00:05:19
    串基本操作的编程实现,掌握串的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、合并、剪裁等操作,存储结构可以在顺序结构或链接结构、索引结构中任选,也可以全部实现。也鼓励学生利用...

    一、实验题目

    串基本操作的编程实现

    二、题目要求

    串基本操作的编程实现,掌握串的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、合并、剪裁等操作,存储结构可以在顺序结构或链接结构、索引结构中任选,也可以全部实现。也鼓励学生利用基本操作进行一些应用的程序设计。

    三、程序运行结果

    在这里插入图片描述

    四、程序基本功能

    1、建立顺序串

    函数名:setstr()
    描述:建立一个顺序串
    入口参数:无
    出口参数:无
    说明:对于顺序串的建立,我定义了个全局变量数组str[100],字符串长度strlength,之前我尝试了使用快捷键的方式结束字符串的输入,但是觉得这种方法有弊端,如果我的字符串中想出现快捷键字符的话并不能实现。所以我直接使用了gets()函数,直接得到一个字符串,存入数组之中,有一点好处就是gets()函数遇到回车就会结束字符串的输入。然后我通过循环读取了字符串的长度存在了strlength中。重要代码如下:

    void setstr()
    {
    	str[100]=NULL;
    	strlength=0;
        fflush(stdin);
    	printf("请输入要创建的字符串(100以内,回车结束):");
    	gets(str);
    	puts("创建成功!");
    	for(int i=0;str[i]!='\0';i++)  //统计字符串个数 
    	{
    		strlength++;
    	}
    }
    

    2、显示顺序串

    函数名:showstr()
    描述:显示一个顺序串
    入口参数:无
    出口参数:无
    说明:显示字符串其实就是输出每一个字符,我看了老师的程序之后,对于他的显示界面还是很喜欢的,所以我也采用了这种显示方式(如图)
    在这里插入图片描述

    有一点不同的是,我的显示序号是从1-0,老师的是0-9,每超过十个就会显示数量,所以我个人认为我这样显示的话很好去知道哪一个字符在哪一个地方,例如‘m’在13位,很容易找到。对于显示方法,我直接使用循环输入了每一个字符。重要代码如下:

    	for(j=0;str[j]!='\0';j++)
    	printf("%c",str[j]);
    

    3、修改顺序串

    函数名:modstr()
    描述:修改一个顺序串中任何一个字符,其中包括字符的长短。
    入口参数:无
    出口参数:无
    说明:对于顺序串的修改,首先我们必须先确定用户需要修改的位置,然后修改他所需要修改的地方,其中修改有以下三种情况:

    (1)新字符串比需要修改的字符串短

    因为新字符串比需要修改的字符串短,所以我们既可以先移动后面的字符串再覆盖也可以先覆盖再移动,这里我采用的是先覆盖再前移,先计算出新字符串的长度,然后计算出需要前移的数量为(last-first+1)-length,通过覆盖原先的字符串,再讲后面的字符串前移就达到了效果。重要代码如下:

    	for(int i=0;modstr[i]!='\0';i++)  //统计字符串个数 
    		length++;
    	if(length<last-first+1) //新字符串长度小于修改字符串 
    	{
    		for(i=first-1,j=0;modstr[j]!='\0';i++,j++)  //数据覆盖 
    		{
    			str[i]=modstr[j];
    		}
    		for(j=last;j!=strlength+1;j++)  //数据前移 
    		{
    			str[j-(last-first+1)+length]=str[j];
    		}
    		strlength-=(last-first+1)-length;	//整个字符串的新长度
    	}
    

    在这里插入图片描述
    在这里插入图片描述

    (2)新字符串等于需要修改的字符串

    这种情况相对于简单,就是普通的一个覆盖,不需要任何的移动。重要代码如下:

    else if(length==last-first+1) //新字符串长度等于修改字符串 
    {
    	for(int i=0;first!=last+1;first++,i++)
    	{
    		str[first-1]=modstr[i];
    	}
    }
    

    在这里插入图片描述
    在这里插入图片描述

    (3)新字符串大于需要修改的字符串

    对于这种情况我们先将需要修改字符串后面的字符串移动,然后再讲新的字符串插入覆盖。计算出需要移动的数量length-(last-first+1),将新的字符串覆盖。重要代码如下:

    	else if(length>last-first+1) //新字符串长度大于修改字符串
    	{
    		for(i=strlength;i>last-1;i--) //原数组后移 
    	{
    		str[i+length-(last-first+1)]=str[i];
    	}
    	for(i=first-1,j=0;modstr[j]!='\0';i++,j++) //插入覆盖 
    	{
    		str[i]=modstr[j];
    	}
    	strlength+=length-(last-first+1);
    	}
     
    

    在这里插入图片描述
    在这里插入图片描述

    4、插入顺序串

    函数名:insertstr()
    描述:在任何地方插入一个任意长度的字符串。
    入口参数:无
    出口参数:无
    说明:对于字符串的插入,无非就是先移动数据再将新的字符串插入覆盖。先计算出新字符串的长度,再将插入位置后面的字符串向后移动这个长度,再将新的字符串覆盖。重要代码如下:

    	printf("请输入要插入的位置:");
    	scanf("%d",&last);
    	printf("请输入要插入的字符串:");
    	fflush(stdin);
    	gets(insertstr);
    	for(i=0;insertstr[i]!='\0';i++) //统计插入字符个数 
    		length++;
    	for(i=strlength-1;i!=last-2;i--) //原数组后移 
    	{
    		str[i+length]=str[i];
    	}
    	for(i=last-1,j=0;insertstr[j]!='\0';i++,j++) //插入覆盖 
    	{
    		str[i]=insertstr[j];
    	}
    	printf("插入成功!\n");
    	strlength+=length;
    	}
    

    在这里插入图片描述
    在这里插入图片描述

    5、删除顺序串

    函数名:delstr()
    描述:在任何地方删除一个任意长度的字符串。
    入口参数:无
    出口参数:无
    说明:删除字符串就是将需要删除字符串后面的字符串前移。首先
    计算出新字符串的长度,然后前移。重要代码如下:

    	printf("请输入要删除的初始位置:");
    	scanf("%d",&first);
    	printf("请输入要删除的终止位置:");
    	scanf("%d",&last);
    	for(i=first-1,j=last;i!=last;i++,j++) //前移覆盖 
    	{
    		str[i]=str[j];
    	}
    	strlength-=last-first+1;
    	}
    

    在这里插入图片描述
    在这里插入图片描述

    6、查找顺序串

    函数名:searchstr()
    描述:在字符串中查找一段连续的字符串。
    入口参数:无
    出口参数:无
    说明:首先输入需要查找的字符串,通过一个三重循环就可以查找。第一层循环判断总字符串查找是否结束,第二重循环判断查找字符串,第三重循环判断需要查找的字符串是否结束。重要代码如下:

    	printf("请输入需要查找的字符串:");
    	gets(searchstr);
    	for(i=0;searchstr[i]!='\0';i++) //统计插入字符个数 
    		length++;
    	while(str[position]!='\0') //判断主串是否结束 
    	{
    		for(i=position,j=0;searchstr[j]==str[i];i++,j++) //比较 
    		{
    			if(searchstr[j+1]=='\0')  //判断查找串是否结束 
    			{
    				flag=1;
    				break;
    			}
    		}
    		position++;   //下一个字符 
    		if(flag==1)
    		break; 
    	}
    	if(flag==1)
    	{ 
    	printf("查找成功!\n");
    	}
    

    在这里插入图片描述

    五、源码

    1、串基本操作的编程实现

    #include<stdio.h>
    #include<windows.h>
    #include<stdlib.h>
    void showmenu();//菜单显示
    void processmenu();//菜单控制
    void setstr();//建立顺序串 
    void showstr();//显示顺序串
    void modstr();//修改顺序串
    void insertstr();//插入顺序串 
    void delstr();//删除顺序串
    void searchstr();//查找顺序串 
    void strlong();//求串长 
    char str[100];
    char strlength=0; 
    int main()
    {
    	system("color f0");//背景白色
    	while(1)
    	{
    		showmenu();
    		processmenu();
    		system("pause");
    		system("cls");
    	}
    }
    void showmenu()
    {
    	puts("~~~~~~~~~~~~~~~~~~~~~~~~");
    	puts("\t\t串基本操作的编程实现");
    	puts("\t\t操作软件:dev c++");
    	puts(" ~~~~~~~~~~~~~~~~~~~~~~~~");
    	puts("~~~\t\t1、建立顺序串\t\t~~~~");
    	puts(" ~~~\t\t2、显示\t\t\t ~~~~");
    	puts("~~~\t\t3、修改\t\t\t~~~~");
    	puts(" ~~~\t\t4、插入\t\t\t ~~~~");
    	puts("~~~\t\t5、删除\t\t\t~~~~");
    	puts(" ~~~\t\t6、查找\t\t\t ~~~~");
    	puts(" ~~~\t\t7、求串长度\t\t ~~~~");
    	puts("~~~\t\t0、退出程序\t\t~~~~");                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
        puts("~~~~~~~~~~~~~~~~~~~~~~~~");
    	puts("");
    	printf("请输入您的选择:");
    }
    void processmenu()
    {
    	int menuchoice;//菜单选择  
    	scanf("%d",&menuchoice);
    	switch(menuchoice)
    	{
    		case 1:
    		 	 setstr(); 
    			 fflush(stdin);
    			break;
    		case 2:
    			 showstr();
    			 fflush(stdin); 
    			break;
    		case 3:
    			 modstr();
    			 fflush(stdin);
    			break;
    		case 4:
    			insertstr();
    			break;
    		case 5:
    			delstr();
    			fflush(stdin); 
    			break;
    		case 6:
    			searchstr();
    			fflush(stdin); 
    			break;
    		case 7:
    			strlong();
    			fflush(stdin); 
    			break;
    		case 0:
    			puts("\n~~~~~~~~~~~~~~~~~~~~~~~~");
    			puts("\t\t欢迎下次再用!");
    			puts("~~~~~~~~~~~~~~~~~~~~~~~~\n");
    			exit(0);
    			
    		default :
    		printf("输入错误!请重新输入...\n");
    	}
    }
    void setstr()
    {
    	str[100]=NULL;
    	strlength=0;
        fflush(stdin);
    	printf("请输入要创建的字符串(100以内,回车结束):");
    	gets(str);
    	puts("创建成功!");
    	for(int i=0;str[i]!='\0';i++)  //统计字符串个数 
    	{
    		strlength++;
    	}
    }
    void showstr()
    {	
    	if(strlength==0)
    	printf("顺序串为空!\n"); 
    	else
    	{
    	int j=0;
    	printf("位置:");
    	for(int i=strlength/10;i!=-1;i--)
    	{
    		printf("|---%d----|",j);
    		j++;
    	}
    	printf("\n位置:");
    	for(int i=strlength/10;i!=-1;i--)
    	{
    		printf("1234567890");
    	}
    	printf("\n当前:");
    	for(j=0;str[j]!='\0';j++)
    	printf("%c",str[j]);
    	printf("\n");  
    	}
    }
    void modstr()
    {
    	if(strlength==0)
    	printf("顺序串为空!\n");
    	else
    	{ 
    	int first,last;
    	int length=0;
    	int i,j;
    	char modstr[100]; 
    	showstr();
    	printf("请输入要修改的初始位置:");
    	scanf("%d",&first);
    	printf("请输入要修改的终止位置:");
    	scanf("%d",&last);
    	printf("请输入新的字符串:");
    	fflush(stdin);
    	gets(modstr);
    	for(int i=0;modstr[i]!='\0';i++)  //统计字符串个数 
    		length++;
    	if(length<last-first+1) //新字符串长度小于修改字符串 
    	{
    		for(i=first-1,j=0;modstr[j]!='\0';i++,j++)  //数据覆盖 
    		{
    			str[i]=modstr[j];
    		}
    		for(j=last;j!=strlength+1;j++)  //数据前移 
    		{
    			str[j-(last-first+1)+length]=str[j];
    		}
    	strlength-=(last-first+1)-length;
    	}	
    	else if(length==last-first+1) //新字符串长度等于修改字符串 
    	{
    	for(int i=0;first!=last+1;first++,i++)
    	{
    		str[first-1]=modstr[i];
    	}
    	printf("修改成功!\n");
    	}
    	else if(length>last-first+1) //新字符串长度大于修改字符串
    	{
    		for(i=strlength;i>last-1;i--) //原数组后移 
    	{
    		str[i+length-(last-first+1)]=str[i];
    	}
    	for(i=first-1,j=0;modstr[j]!='\0';i++,j++) //插入覆盖 
    	{
    		str[i]=modstr[j];
    	}
    	printf("修改成功!\n");
    	strlength+=length-(last-first+1);
    	}
    	showstr();
    	}
    }
    void insertstr()
    {
    	if(strlength==0)
    	printf("顺序串为空!\n");
    	else
    	{
    	int last;
    	int i,j,length;
    	char insertstr[100]; 
    	showstr();
    	printf("请输入要插入的位置:");
    	scanf("%d",&last);
    	printf("请输入要插入的字符串:");
    	fflush(stdin);
    	gets(insertstr);
    	for(i=0;insertstr[i]!='\0';i++) //统计插入字符个数 
    		length++;
    	for(i=strlength-1;i!=last-2;i--) //原数组后移 
    	{
    		str[i+length]=str[i];
    	}
    	for(i=last-1,j=0;insertstr[j]!='\0';i++,j++) //插入覆盖 
    	{
    		str[i]=insertstr[j];
    	}
    	printf("插入成功!\n");
    	strlength+=length;
    	showstr();
    	}
    }
    void delstr()
    {
    	if(strlength==0)
    	printf("顺序串为空!\n");
    	else
    	{
    	showstr();
    	int i,j; 
    	int first,last;
    	printf("请输入要删除的初始位置:");
    	scanf("%d",&first);
    	printf("请输入要删除的终止位置:");
    	scanf("%d",&last);
    	for(i=first-1,j=last;i!=last;i++,j++) //前移覆盖 
    	{
    		str[i]=str[j];
    	}
    	strlength-=last-first+1;
    	showstr();
    	}
    }
    void searchstr()
    {
    	if(strlength==0)
    	printf("顺序串为空!\n");
    	else
    	{
    	int i,j;
    	int position=0;
    	int flag=0;
    	int length=0; 
    	char searchstr[100];
    	fflush(stdin);
    	printf("请输入需要查找的字符串:");
    	gets(searchstr);
    	for(i=0;searchstr[i]!='\0';i++) //统计插入字符个数 
    		length++;
    	while(str[position]!='\0') //判断主串是否结束 
    	{
    		for(i=position,j=0;searchstr[j]==str[i];i++,j++) //比较 
    		{
    			if(searchstr[j+1]=='\0')  //判断查找串是否结束 
    			{
    				flag=1;
    				break;
    			}
    		}
    		position++;   //下一个字符 
    		if(flag==1)
    		break; 
    	}
    	if(flag==1)
    	{ 
    	printf("查找成功!\n");
    	showstr();
    	printf("查找:");
    	position--;
    	while(position--)
        	printf(" ");
    	for(i=0;searchstr[i]!='\0';i++ )
    		printf("%c",searchstr[i]);
    	printf("\n");
    //	printf("该字符串的初始位置为:%d\n",position);
    //	printf("该字符串的末尾位置为:%d\n",length+position-1); 
    	} 
    	else 
    	printf("查找失败!\n");
    	}
    }
    void strlong()
    {
    	printf("目前字符串的长度为:%d\n",strlength);
    } 
    
    展开全文
  • 本文就介绍了数据结构基本操作的编程实现,掌握的建立、遍历,求子,定位等基本操作 提示:以下是本篇文章正文内容,下面案例可供参考 一、是什么? 在计算机程序设计中,字符 string 通常是字符序列...



    前言

    本文就介绍了数据结构中串的基本操作的编程实现,掌握串的建立、遍历,求子串,定位等基本操作


    提示:以下是本篇文章正文内容,下面案例可供参考
    有更简洁的代码实现,请移步链接: 数据结构——串的基本操作(C语言,究极简单,完整实现).

    一、串是什么?

    在计算机程序设计中,字符串 string 通常是字符序列,要么是文字常量,要么是某种变量。后者可能允许其元素发生突变,长度改变,或者是固定的(在创建之后)。字符串通常被认为是一种数据类型,通常作为字节(或字)的数组数据结构来实现,它存储了一系列元素,通常是使用一些字符编码的字符。字符串还可以用来表示更一般的数组或其他序列(或列表)数据类型和结构。

    根据所使用的编程语言和精确的数据类型,声明为字符串的变量可能会导致内存中的存储被静态地分配给预先确定的最大长度,或者可以使用动态分配来容纳可变数量的元素。

    当一个字符串在源代码中出现时,它被称为字符串文字或匿名字符串。

    在数学逻辑和理论计算机科学中使用的正式语言中,string 是由一个叫做字母表的集合所选择的有限的符号序列。
    串的实现形式有两种,堆分配和块链存储,本文讲述块链存储

    二、该如何理解串?

    串 sting,一般又可以被称作字符串,是由0个或则多个字符组成的有限序列。一般我们用S = “a1 a2 a3…an” 来表示,其中S 是串的名字,双引号或则单引号作为串的定界符用来表示串的内容即串值,ai (0<= i <= n) 则代表串中的单个元素,n表示穿的个数即串中有几个字符,当n 为0时,该串被称为空串(null string),用双引号“”来表示,符号记为Ф。

    注,空白串(blank string)和空串的区别,空白串是由一个或多个空格组成的串。
    在JAVA中,String有着更深层次的理解,本文不做过多叙述

    三、各类串的形式

    子串(subString):串中任意几个连续的字符组成的子序列即为该串的子串

    主串:相应地,包含该子串的串称为主串

    子串的位置(index):子串在主串中首次出现时,该子串的首字符对应在主串中的序号,即为子串在主串中的位置。

    这里有一个很经典的例子用来辅助说明。例如,设A和B分别为 A=‘This is a string’ B=‘is’ 则B是A的子串,A为主串。B在A中出现了两次,其中首次出现所对应的主串位置是3。因此,称B在A中的位置为3。 特别地,空串是任意串的子串,任意串是其自身的子串。

    连接 (concatenation):连接是一个重要的二进制操作。对于任意两个主串中的子串s和t,它们的连接根据放置s和t 的前后顺序来定符号序列。例如,子串s = love,t = hug,那么st 就是lovehug,ts 就是huglove。

    前缀和后缀 prefixes and suffixes:字符串s 可以说是t 的前缀,如果存在一个字符串u 满足条件t =su。如果u 是非空的,那么可以说s 是t 的一个合适的前缀;相应地,串s 可以说t 的后缀如果存在一个串u 满足条件t=us。如果u 是非空的,s 可以说是t 的一个合适的后缀。前缀和后缀可以说是t 的子串。

    旋转:串s = uv 可以被说成t 的旋转如果t = vu. 举个例子,当u = 00110, v = 01的时候,串0011001 是0100110 的旋转。

    逆转:串的逆转就是具有相同符号单顺序相反的字符串。例如,如果s=abc(a、b和c是字母表中符号),那么s 的逆转就是cba。一个与自身相反的字符串(例如,s=madam,逆转还是madam)被称为回文 palindrome,它还包括空字符串和所有长度为1的字符串。

    四、串的实现

    1.串的实现

    1.1 引入库以及设置结构体

    #include<stdio.h>
    #include<malloc.h>
    #include<string.h>
    #define CHUNKSIZE 80
    
    typedef struct 
    {
    	char *ch;
    	int length;
    }HString;
    

    1.2初始化串

    int StrAssign(HString &T,char *chars)//生成一个其值等于串常量chars的T 
    {
    //	if(T.ch) free(T.ch);
    	int i,n;char *c;
    	for(i=0,c=chars;*c;++i,++c);
    	if(!i)
    	{
    		T.ch=NULL;
    		T.length=0;
    	}
    	else
    	{
    		if(!(T.ch=(char *)malloc(i*sizeof(char))))
    			return -1;
    		for(n=0;n<=i-1;n++)
    		{
    			T.ch[n]=chars[n];
    			T.length=i;
    		}
    	}
    	return 1;
    }
    

    1.3求子串的功能实现

     int SubString(HString &Sub,HString S,int pos,int len)//求子串 
     {
     	int n; 
     	if(pos<0||pos>S.length||len<0||len>S.length-pos+1)
     	{
     		 		return 0;
    	 }
    //	if(Sub.ch) free(Sub.ch);
    	if(!len)
    		{
    			Sub.ch=NULL;
    			Sub.length=0;
    		 } 
    	else
    		{
    			Sub.ch=(char *)	malloc(len * sizeof(char));
    			for(int n=0;n<=len-1;n++)
    			{
    				Sub.ch[n]=S.ch[pos+n-1];
    			}
    			Sub.length=len;
    		}
    	return 1;
     }
    

    1.4两串比较的功能实现

     int StrCompare(HString S,HString T)//若S>T,则返回值>0; 若S=T,则返回值0;若S<T,则返回值<0 
     {
     	for(int i=0;i<S.length&&i<T.length;i++)
     	{
     		if(S.ch[i]!=T.ch[i])
     			return S.ch[i]-T.ch[i];
    		else
    			  return S.length-T.length;
    	 }	
     }
    

    1.5定位功能

    int Index(HString S,HString T,int pos)
    {
    	int i=pos,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) return i-T.length;
    	else return 0;
    }
    

    1.6求串的长度功能

    int StrLength(HString T)//求串长 
    {
    	return T.length;
     } 
    

    1.7串的输出功能

    void StrPrint(HString T)
    {
    	int i;
    	for(i=0;i<T.length;i++)
    	{
    		printf("%c",T.ch[i]);
    	}
    } 
    

    1.8主函数实现上述全部功能

    void Show()
    {
    	printf("请输入想选择的指令:\n");
    	printf("1.显示串\n");
    	printf("2.显示串长\n");
    	printf("3.两串做比较\n");
    	printf("4.求子串\n");
    	printf("5.定位\n");
    	printf("0.退出\n");
    	printf("-------------------\n");
    }
    
    int main()
    {
    	int n;
    	Show();	
    	scanf("%d",&n);	
    	char s[15]="qwertasdfzxc";		
    	HString S;
    	StrAssign(S,s);	
    	char t[5]="asdf";
    	HString T;
    	StrAssign(T,t);	
    	HString Sub;
    	while(n!=0)
    	{
    		switch(n)
    		{
    			case 1:	
    					printf("第一个串为:%s\n",S.ch);
    					printf("第二个串为:%s\n",T.ch);break;
    			case 2: printf("第一条串长:%d\n",StrLength(S));
    					printf("第二条串长:%d\n",StrLength(T));break;
    			case 3: 	int n ;
    						n=StrCompare(S,T);
    						if(n!=0)
    							if(n>0)
    								printf("前面长\n");
    							else
    								printf("后面长\n");
    						else
    							printf("一样长\n");break; 
    			case 4:printf("请输入你想取的位置及长度:\t");
    					int j,l;
    					scanf("%d %d",&j,&l);
    					SubString(Sub,S,j,l);
    					StrPrint(Sub);break;
    			case 5: int k;
    					printf("输入查询的位置:\n");
    					scanf("%d",&k);
    					int x=Index(S,T,k);
    				    printf("定位到的位置为:%d",x);break;
    		 } 
    			printf("\n");
    			Show();
    			scanf("%d", &n);
    		}
    	return 0;
     } 
    

    总结

    以上就是今天要讲的内容,本文仅仅简单介绍了串基础结构以及基础功能的相应实现。
    希望对你有所帮助
    展开全文
  • 数据结构串串基本操作C语言实现

    千次阅读 多人点赞 2019-03-12 19:40:42
    数据结构基本操作 以一组地址连续的存储单元存放值字符序列,存储空间在程序执行过程中动态分配得到,操作灵活。 代码: 1.结构体定义 typedef struct { char * ch; //若是非空串,则按长分配存储...

    【数据结构】串 堆串的基本操作

    以一组地址连续的存储单元存放串值字符序列,存储空间在程序执行过程中动态分配得到,操作灵活。

    代码:

    1.结构体定义
    typedef struct {
    	char * ch;	//若是非空串,则按串长分配存储区,否则ch为NULL
    	int length; //串长度
    }HString;
    
    2.基本操作函数声明
    // 基本操作的函数原型说明
    
    //初始化生成一个空串T
    Status StrInit(HString &T);
    
    //生成一个其值等于串常量chars的串T
    Status StrAssigh(HString &T, char * chars);
    
    //返回S的元素个数,称为串的长度
    int StrLength(HString S);
    
    //若S>T,则返回值大于0....
    Status StrCompare(HString S, HString T);
    
    //将S清为空串,并释放S所占空间 
    Status ClearString(HString &S);
    
    //用T返回由S1和S2联接而成的新串
    Status Concat(HString &T, HString S1, HString S2);
    
    //返回串S的第pos个字符起长度为len的子串
    Status SubString(HString &Sub,HString S, int pos, int len);
    
    3.函数定义
    #include "String.h"
    
    Status StrInit(HString & T)
    {
    	T.ch = NULL;
    	T.length = 0;
    	return OK;
    }
    
    Status StrAssigh(HString & T, char * chars)
    {
    	if (T.ch)free(T.ch);		//释放其原有空间
    	char* c = chars; int i = 0;
    	for (i = 0; *c; i++, ++c); //求chars的长度i
    	if (!i) {
    		T.ch = NULL;
    		T.length = 0;
    	}
    	else {
    		if (!(T.ch = (char*)malloc(i * sizeof(char)))) exit(OVERFLOW);
    		for (int  j = 0; j < i; j++)T.ch[j] = chars[j];
    		T.length = i;
    	}
    	return OK;
    }
    
    
    int StrLength(HString S)
    {
    	return S.length;
    }
    
    Status StrCompare(HString S, HString T)
    {
    	for (int i = 0; i < S.length&&i<T.length; i++)
    		if (S.ch[i] != T.ch[i])return S.ch[i] - T.ch[i];
    	return S.length - T.length;
    }
    
    Status ClearString(HString & S)
    {
    	if (S.ch) {
    		free(S.ch); S.ch = NULL;
    	}
    	S.length = 0;
    	return OK;
    }
    
    Status Concat(HString & T, HString S1, HString S2)
    {
    	if (T.ch) free(T.ch);	//释放旧空间
    	if (!(T.ch = (char*)malloc((S1.length + S2.length) * sizeof(char))))
    		exit(OVERFLOW);
    	for (int i = 0; i < S1.length; i++) T.ch[i] = S1.ch[i];
    	T.length = S1.length + S2.length;
    	for (int i = S1.length; i < T.length; i++) T.ch[i] = S2.ch[i-S1.length];
    	return OK;
    }
    
    Status SubString(HString &Sub,HString S, int pos, int len)
    {
    	if (pos<1 || pos>S.length || len<0 || len>S.length - pos + 1)return ERROR;
    	if (Sub.ch) free(Sub.ch);			//释放旧空间
    	if (!len) {
    		Sub.ch = NULL; Sub.length = 0;
    	}
    	else {
    		Sub.ch = (char*)malloc(len * sizeof(char));
    		for (int i = 0; i < len; i++)
    		{
    			Sub.ch[i] = S.ch[pos - 1 + i];
    		}
    		Sub.length = len;
    	}
    	return OK;
    }
    
    
    4.测试
    #include"String.h"
    using namespace std;
    
    void StrDisplay(HString S) {
    	//显示串
    	for (int i = 0; i < S.length; i++)
    	{
    		cout << S.ch[i];
    	}
    }
    int main() {
    	HString A;
    	StrInit(A);
    	HString B;
    	StrInit(B);
    	HString C;
    	StrInit(C);
    	char b[10] = "hello";
    	char c[10] = " world";
    
    	cout << "初始化B,显示B:" << endl;
    	StrAssigh(B, b);
    	StrDisplay(B);
    
    	cout << endl<<"初始化C,显示C:" << endl;
    	StrAssigh(C, c);
    	StrDisplay(C);
    	
    	cout << endl << "比较串B,C,返回一个数值" << endl;
    	cout << StrCompare(A, B);
    	
    	cout << endl<<"将B,C串联接成串A,输出A:" << endl;
    	Concat(A, B,C);
    	StrDisplay(A);
    
    	cout << endl << "输出串A第二个字符起后五个字符" << endl;
    	SubString(B, A, 2, 5);
    	StrDisplay(B);
    	cout << endl << "串长度为";
    	cout << StrLength(B);
    	
    	cout << endl;
    	system("pause");
    
    }
    

    测试结果:
    在这里插入图片描述

    展开全文
  • 数据结构基本操作

    万次阅读 多人点赞 2018-05-30 12:57:57
    1.串的实现相比较而言简单一些,但个人觉得有一些需要注意的地方,以下一 一列举:(1)串基本术语...(2)串基本操作:赋值操作、连接操作、求串长、窜的比较和求子串。(3)串的存储结构:顺序存储和链式存储。其...

    1.串的实现相比较而言简单一些,但个人觉得有一些需要注意的地方,以下一 一列举:

    (1)串基本术语:

    空串:空串指长度为0的串,其不包含任何字符;

    空格串:不同于空串,它是由一个或多个空格构成的串。虽然是空格,但在计算长度时要把空格的个数算在内;

    串比较:串的大小比较时以字符的ASCII码值作为依据。

    (2)串基本操作:赋值操作、连接操作、求串长、窜的比较和求子串。

    (3)串的存储结构:顺序存储和链式存储。其中链式存储可以指定节点大小,存储若干个字符。

    2.串的模式匹配算法:求解子串在主串中首次出现的位置:Index(S,T,pos)

    算法的实现使具有暴力的性质,模式串和主串同时从第一个位置开始进行判断,若对应位置字符相等则继续向后判断,若不相

    等,则模式串回到串首,主串字符位置指针回退,重新匹配。

    int Index(String s,String t,int pos){
        //返回子串t在主串s中第pos个字符之后的位置,若不存在,则返回0
        if(isEmpty(t) || pos<0 || pos>t.length-1) exit(0);
        int i=pos;
        int 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) {
            return i-t.length;
        }
        else
            return 0;

    }

    串的模式匹配算法优化:KMP算法

    此算法可以在O(m+n)的数量级上完成串的匹配操作。其改进在于,每一趟匹配过程中出现字符比较不相等的时候,不需要回

    退指针i,而是利用已经匹配到的部分结果将模式串向右滑动尽可能远的距离,继续匹配。

    #include<iostream>
    #include<cstdlib>
    using namespace std;
    #define MAXSTRLEN 100

    typedef char SString[MAXSTRLEN+1];


    //返回模式串T在主串中第pos位置之后的位置,若存在,返回1,否则返回0

    int KMPindex(SString S,SString T,int pos){
        if(pos < 1 || pos>S[0]) exit(0);
        int i=pos;
        int j=1;
        int next[MAXSTRLEN];
        GetNext(T,next);
        while(i <= S[0] && j<= T[0]){
            if(S[i] == T[j]){
                i++;j++;
            }else{
                j=next[j];
            }
        }
        if(j >T[0]) return i-T[0];
        return 0;
    }

    //求子串next[i]的值
    void GetNext(SString T,int next[]){
        int j=1,k=0;
        next[1]=0;
        while(j<T[0]){
            if(k==0 || T[j]==T[k]){ //子串自己与机子进行比较
                ++j;
                ++k;
                next[j]=k;
            }else{
                k = next[k];
            }
        }

    }
    int main()
    {
        SString S = {13,'a','b','a','b','c','a','b','c','a','c','b','a','b'};  
        SString T = {5,'a','b','c','a','c'};  
        int pos;  
        pos = KMPindex( S,  T, 1);  
        cout<<"匹配位置为:"<<pos;
        return 0;
    }

     

    3.顺序串与链式串的实现(C语言)

    (1)顺序串:

    #include<iostream>
    #include<cstdio>
    #include<cstdlib>
    using namespace std;
    #define MAXSIZE 100
    //串的顺序存储
    typedef struct st{
        char *ch;//串存放的起始地址
        int length;//串的长度
        int strsize;//分配的存储空间的大小
    }String;

    //1.串的初始化操作
    String CreateNullString(){
        String str;
        str.length = 0;
        str.ch = (char *)malloc(MAXSIZE*sizeof(char));
        str.strsize = MAXSIZE;
        return str;
    }

    //2.判断空串
    int isEmpty(String str){
        if(str.length == 0){
            return 1;
        }else{
            return 0;
        }
    }

    //3.串的赋值操作
    void StrAssign(String *str1,char str2[]){
        int i=0;
        while(str2[i] != '\0') i++;//计算str2的长度
        if(str1->length < i){   //结构指针成员的访问
            //增加存储空间,将较长的空间赋值为新的值
            str1->ch = (char *)malloc(sizeof(char));
            str1->strsize = i;
        }
        
        str1->length = i;
        for(i=0;i<str1->length;i++){
            str1->ch[i] = str2[i];//从第一个字符开始,着个赋值
            
        }
    }
    //4.串的拷贝
    void StrCopy(String *str1,String str2){
        if(str1->strsize < str2.strsize){
            str1->ch = (char *)realloc(str1->ch,str2.length*sizeof(char));
            str1->strsize = str2.length;;
        }
        
        str1->length = str2.length;
        int i;
        for(i=0;i<str1->length;i++){
            str1->ch[i] = str2.ch[i];
        }
    }

    //5.串的长度
    int StrLength(String str){
        return str.length;
    }

    //6.串的连接操作
    void StrConcat(String *str,String str1,String str2){
        if(str->strsize < str1.strsize + str2.strsize){
            str->ch = (char *)realloc(str->ch,(str1.length+str2.length)*sizeof(char));
            str->strsize = str1.length+str2.length;
        }
        
        str->length = str1.length+str2.length;
        
        int i;
        for(i=0;i<str1.length;i++){
            str->ch[i] = str1.ch[i];
        }//将str1赋值到str
        for(;i<str->length;i++){
            str->ch[i] = str2.ch[i-str1.length];
        }//将str2赋值到str
    }

    //7.取子串
    int SubStr(String s,int i,int len,String *t){
        /*
            i表示从字符串s的第i个位置开始截取(索引从1开始)
            len表示截取字符串的长度
        */
        
        //将s中从i位置起,len长度的串通过t返回
        if(i<=0 || i>s.length || len<0 || len>s.length-i+1){
            t->ch = (char *)realloc(t->ch,len*sizeof(char));
            t->strsize = len;
        }
        t->length = len;
        int k;
        for(k=0;k<t->length;k++){
            t->ch[k] = s.ch[i-1+k];
        }
        return 1;
    }

    //8.插入操作
    int InsertString(String *str,int i,String str1){
        //将str1,插入str的第i个位置
        if(i <= 0 || i>str->length+1) return 0;
        
        if(str->strsize < str->length + str1.length){
            //空间不足
            str->ch = (char *)realloc(str->ch,(str->length+str1.length)*sizeof(char));
            str->strsize = str->length + str1.length;
        }
        int k;
        for(k=str->length-1;k>=i-1;k--){
            //将str中的后i个字符后移
            str->ch[k+str1.length] = str->ch[k];
        }
        str->length = str->length + str1.length;
        for(k=0;k<str1.length;k++){
            str->ch[k+i-1] = str1.ch[k];
        }
        
        return 1;
        
    }
    //9.删除子串
    int deleteStr(String *str,int i,int len){
        //从第i个位置开始,删除len长度的子串
        if(i<=0 || i>str->length || len <0 || len > str->length-i+1){
            return 0;
        }
        int k;
        for(k=i+len-1;k<str->length;k++){
            //从str的i+len-1个位置开始将其后的所有字前移
            str->ch[k-len] = str->ch[k];
        }
        str->length -= len;
        return 1;
    }

    //10.输出操作
    void print(String *str){
        int i;
        for(i=0;i<str->length;i++){
            cout<<str->ch[i]<<" ";
        }
        cout<<endl;
    }

    //11.串的模式匹配
    int Index(String s,String t,int pos){
        //返回子串t在主串s中第pos个字符之后的位置,若不存在,则返回0
        if(isEmpty(t) || pos<0 || pos>t.length-1) exit(0);
        int i=pos;
        int 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) {
            return i-t.length;
        }
        else
            return 0;
    }
    int main()
    {
        String str1 = CreateNullString();
        String str2 = CreateNullString();
        String str3 = CreateNullString();
        char ch[MAXSIZE];
        cout<<"请输入主串"<<endl;
        gets(ch);
        StrAssign(&str1,ch);
        cout<<"主串为:";
        print(&str1);
        cout<<endl;
        StrCopy(&str2,str1);
        cout<<"拷贝得到的串为:";
        print(&str2);
        cout<<endl;
        
        SubStr(str1,4,4,&str3);
        cout<<"截取的子串为:";
        print(&str3);
        cout<<endl;
        
        int pos = Index(str1,str2,0);
        cout<<"匹配位置为:"<<pos<<endl;
        return 0;

    }


    (2)链式串:

    #include<iostream>
    #include<cstdlib>
    using namespace std;
    //串的链式存储
    typedef struct node{
        char ch;   //字符域
        struct node *next; //指针域,存放下一个节点的指针
    }node,*Linkstr;
    //1.初始化一个空串
    Linkstr CreateNullString()
    {
        Linkstr str;
        str=(Linkstr)malloc(sizeof(node));
        if(str != NULL){
            str->next = NULL;
        }
        return str;
    }

    //2.判断空串
    int IsEmpty(Linkstr str)
    {
        if(str->next ==NULL){
            return 1;
        }
        else{
            return 0;
        }
    }

    //3.赋值操作
    void StringAssign(Linkstr str,char t[])
    {
        Linkstr p,q,r;
        r=str;//r始终表示的尾节点(最后一个非空节点,而不是最后一个NULL节点)。
        q=str->next;
        int i;
        for(i=0;t[i] != '\0';i++){
            if(q!=NULL)
            {
                q->ch = t[i]; //一个一个的存入节点
                r=q;
                q=q->next;    
            }
            else{
                //(初始化时只给头结点分配了存储空间或者其他情况),如果需要继续添加数据(其他节点没分配空间)需要继续分配
                p=(Linkstr)malloc(sizeof(node));
                //添加节点
                p->ch = t[i];
                r->next = p;
                r = p;
            }
            r->next = NULL;
            //将s中多余的空间释放掉
            while(q!=NULL){
                p=p->next;
                free(q);
                q=p;
            }
        }
     }
     
    //2.串的拷贝
    void Assign(Linkstr s,Linkstr t)
    {
        将t串的值赋值给s串
        Linkstr p,q,r,u;
        p=t->next;
        q=s->next;
        r=s;
        while(p!=NULL){
            //串s已经分配了空间
            if(q!=NULL){
                q->ch = p->ch;
                r=q;
                q=q->next;
            }
            else{
                //串s中原先的空间不够
                u=(Linkstr)malloc(sizeof(node));
                u->ch = p->ch;
                r->next =u;
                r=u;
            }
            //p节点后移
            p=p->next;
            //同理,若q的长度过长,可以释放多余的空间
            while(q!= NULL){
                p=p->next;
                free(q);
                q=p;
            }
            r->next = NULL;
        }
    }

    //3.求串长
    int length(Linkstr s)
    {
        Linkstr p;
        int len=0;
        p=s->next;
        while(p!=NULL){
            len++;
            p=p->next;
        }
        return len;
    }
    //4.串的链接操作
    void contact(Linkstr s,Linkstr s1,Linkstr s2)
    {
        Linkstr p,q,r,t;
        r=s;
        p=s1->next;
        q=s->next;
        while(p!=NULL){
            if(q!=NULL)  //s不是空串
            {
                q->ch = p->ch;
                q=q->next;
                r=q;
            }
            else{
                //串s原来没有分配存储空间,需要申请空间
                t=(Linkstr)malloc(sizeof(node));
                t->ch=p->ch;
                r->next=t;
                r=t;
            }
            p=p->next;
        }
        p=s2->next;
        while(p!=NULL){
            if(q!=NULL){
                q->ch=p->ch;
                q=q->next;
                r=q;
            }else{
                //串s原来没有分配存储空间,需要申请空间
                t=(Linkstr)malloc(sizeof(node));
                t->ch=p->ch;
                r->next=t;
                r=t;
            }
            p=p->next;
        }
        
        //将串s的多余的空间清除掉(这个情况只可能发生在while的if循环中)
        while(q!=NULL){
            p=q->next;
            free(q);
            q=p;
        }
        r->next = NULL;
    }  
    //5.截取子串
    int subString(Linkstr s,int i,int len,Linkstr t)
    {
        Linkstr p,q,r,u;
        if(i<=0||i>length(s) || i+len-1>length(s))
            return 0;
        //指针指向s的第i-1个位置
        int j,k;
        for(j=0,p=s;j<i;j++){
            p=p->next;
        }
        for(k=0,r=t,q=t->next;k<len;k++)
        {
            if(q!=NULL){
                q->ch=p->ch;
                r=q;
                q=q->next;
            }
            else{
                u=(Linkstr)malloc(sizeof(node));
                u->ch=p->ch;
                r->next=u;
                r=u;
            }
            p=p->next;
        }
        
        while(q!=NULL){
            p=q->next;
            free(q);
            q=p;
        }
        r->next=NULL;
        return 1;
    }
    //6.插入子串操作
    int insert(Linkstr s,int i,Linkstr t)
    {
        Linkstr p,q,r;
        if(i<=0 || i>length(s)+1)
        return 0;
        //指向i-1个位置
        int j;
        for(j=0,p=s;j<i-1;j++){
            p=p->next;
        }
        q=t->next;
        while(q!=NULL)
        {
            r=(Linkstr)malloc(sizeof(node));
            r->ch = q->ch;
            r->next=p->next;
            p->next=r;
            q=q->next;
            p=r;
        }
        return 1;
    }
    //7.删除操作
    int deleteStr(Linkstr s,int i,int len){
        Linkstr p,q,r;
        if(i<=0 || i>length(s) || i+len-1>length(s))
        return 0;
        int j;
        for(j=0,p=s;j<i-1;j++){
            p=p->next;
        }
        for(j=0;j<len;j++){
            q=p->next;
            p->next=q->next;
            free(q);
        }
        return 1;
    }
    //8.打印输出
    void print(Linkstr s)
    {
        Linkstr p=s->next;
        while(p!=NULL)
        {
            cout<<p->ch<<" ";
            p=p->next;
        }
        cout<<endl;
     }
    int main()
    {
        Linkstr s1;
        Linkstr s2;
        Linkstr s3;
        s1=CreateNullString();
        s2=CreateNullString();
        s3=CreateNullString();
        char str[100];
        cout<<"请输入字符:"<<endl;
        gets(str);
        StringAssign(s1,str);
        cout<<"串1:";
        print(s1);
        cout<<endl;
        cout<<"串1的长度为:"<<length(s1)<<endl;
        
        Assign(s2,s1);
        cout<<"串2:";
        print(s2);
        cout<<endl;
        cout<<"串2的长度为:"<<length(s2)<<endl;
        
        cout<<"串s2的删除操作:"<<endl;
        deleteStr(s2,3,3);
        cout<<"串2:";
        print(s2);
        cout<<endl;
        cout<<"串2的长度为:"<<length(s2)<<endl;
        contact(s3,s1,s2);
        cout<<"串3为(串1和串2的连接):";
        
        print(s3);
        return 0;
    }


    展开全文
  • 数据结构顺序基本操作(C/C++实现)

    千次阅读 多人点赞 2019-10-29 00:19:07
    数据结构顺序基本操作(C/C++实现) 注意:本代码为了测试运行默认含有操作所需数据,如有需要可自己增删改相关数据 涉及基本运算流程 建立 s = ‘’abcdefghijklnm’'和s1 = ‘’xyz‘’ 输出s 输出s...
  • 数据结构基本操作和实现

    万次阅读 多人点赞 2019-05-27 23:07:49
    基本操作和实现 文章目录基本操作和实现的基本概念基本操作项目实现源码项目实现结果 的基本概念 (String)是由零个或多个字符组成的有限序列,又称字符。 长度:中字符的个数,称为的长度...
  • 数据结构——字符基本操作

    千次阅读 2017-12-16 11:32:56
    cout 两比较,若结果大于0,则1 ASCLL大于2 ASCLL。结果为:"; cout(s1, s2); concat(strcat, s1, s2); cout 两连接后为:"; printstring(strcat); cout 取得子串为:"; substring(substr, strcat...
  • 数据结构基本操作的实现(c语言)

    万次阅读 多人点赞 2018-01-21 17:01:26
    字符(简称),可以将其看作是种特殊的线性表,其特殊性在于线性表的数据元素的类型总是字符性,字符数据对象约束为字符集。 是由0个或多个字符组成的有限序列。一般记作:s = “s1 s2 s3 …. sn”,,...
  • 数据结构——基本操作与应用

    千次阅读 2018-11-18 21:24:51
    数据结构中栈和队列是比较重要的,今天贴下的一些应用。 数据结构很重要,数据结构很重要,数据结构很重要!!! 重要的事情说三遍… 一、实验目的 1、 掌握的存储表示; 2、 掌握基本操作; 3、 掌握的2...
  • printf("将S的第2个字符开始的5个字符替换成S1而生成S2\n"); s2 = RepStr(s,2,5,s1); printf("输出S2\n"); DispStr(s2); printf("提取S的第2个字符开始的10个字符而生成S3\n"); s3 = SubStr(s,2...
  • //#include&lt;iostream&gt; #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string&gt; #include&lt;string.h&gt; using namespace std;...typed...
  • 的定义 是由零个或多个字符组成的有限序列。中字符的个数称为的长度,含有零个元素的叫...的存储结构 定长顺序存储: // 定长顺序存储 typedef struct { char str[maxSize+1]; //的最大长度为maxSi...
  • 源代码:#include <stdio.h> #define MaxSize 100 typedef struct //结构体 { char ch[MaxSize]; int length; } SqString; void StrAssign(SqString &s,char t[]) //赋值 { int i; for(...
  • 数据结构】4.1基本操作(附代码实现)

    千次阅读 多人点赞 2018-08-18 18:37:58
    基本操作有: 赋值 连接 比较 清空 求子 具体代码如下 #include &lt;stdio.h&gt; #include&lt;malloc.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; ...
  • 数据结构——的定义与基本操作

    千次阅读 2017-09-17 15:08:49
    的定义与基本原子操作
  • 数据结构实验四:串基本操作的实现

    千次阅读 2019-11-12 15:55:27
    实验项目名称:串基本操作的实现 实验目的: 1.掌握串的模式匹配操作。 实验要求: 1、分别使用BF和KMP算法完成串的模式匹配。 实验过程: BF算法代码;; 1、设计完成next值的计算函数; 2、设计完成修正...
  • 数据结构:字符基本操作

    千次阅读 多人点赞 2013-04-25 13:36:39
    字符(string)是由0个或多个字符组成的有限序列。...示例程序:(改编自《大话数据结构》)  C++ Code  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
  • 数据结构的总结

    千次阅读 2020-09-01 12:21:09
    基本概念 的定义 是由0个或多个字符组成的有限序列,又叫字符。 空串 长度为0的,不包含任何字符。 空白 由一个或多个空白字符组成的。 子串 的任意个连续字符组成的串子序列。子串的位置...
  • 数据结构-顺序基本操作

    千次阅读 2017-11-09 16:01:44
    //顺序基本操作 #include #include using namespace std; #define max 50 typedef struct { char data[max]; int length; }sqstring; void display(sqstring s)//输出 { int i; if(s.length>0) for(i=0;...
  • 通过将控制台输入的字符赋值给S1(从1开始存储),如果字符长度超过限制,则截取越界前的数据存入。S1[0]位置存放字符长度 字符拷贝 对字符遍历逐个拷贝(判断长度,仅拷贝长度范围内的) 字符判空 ...
  • 数据结构与算法】常见数据结构基本操作

    万次阅读 多人点赞 2019-06-16 21:42:44
    数据结构基本操作+排序算法+查找算法目录1.数据结构与算法常见概念2.数据逻辑结构2.1线性结构2.2树形结构2.3图形结构2.4集合结构3.排序算法冒泡排序简单选择排序直接插入排序希尔排序堆排序归并排序快速排序4.查找...
  • 实验项目四 串基本操作的实现 课程名称:数据结构 实验项目名称:串基本操作的实现 实验目的: 1.掌握串的模式匹配操作。 实验要求: 1、分别使用BF和KMP算法完成串的模式匹配。 实验过程: 1、设计...
  • 数据结构与算法设计》实验报告书之字符和数组的基本操作 实验项目 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;字符和数组的基本操作 实验目的 &nbsp;&nbsp;&nbsp;&...
  • 数据结构 - 基本运算实现

    千次阅读 2016-06-01 18:04:16
    实验题目:一个文本可用事先给定的字母映射表进行加密。例如,设字母映射表为: abcdefghijklmnopqrstuvwxyz ngzqtcobmuhelkpdawxfyivrsj 则字符“abc”被加密为“ngz”。设计一个程序exp4-4.cpp将输入的文本...
  • 文章目录前言一、实验目的二、实验内容三、实验环境1)使用的操作系统及版本2)使用的编译系统及版本四、实验步骤及说明1、用c语言,设计出的存储结构总结 前言 计算机上非数值处理的对象大部分是字符串数据,...
  • 数据结构基本操作

    万次阅读 多人点赞 2014-04-25 22:54:27
    /* ===========================================================... 基本操作 By~fanxingzju 2014.04.23 1.StrAssign(&T, chars) 初始条件:chars是字符常量 操作结果:生成一个其值等于chars的T 2.S
  • 的堆分配存储表示的特点是,仍以一组地址连续的存储单元存放值字符序列,但它们的...//文件名:串操作----堆分配存储实现 //描述:这个存储的特点是,仍以一组地址连续的存储单元存放值字符序列,但是存储空...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 589,939
精华内容 235,975
关键字:

数据结构串的基本操作

数据结构 订阅