精华内容
下载资源
问答
  • 数据结构顺序串和链串实验报告.pdf
  • 数据结构 顺序串

    2013-03-02 22:17:21
    数据结构 顺序串 包含无回溯类型匹配(BMP)算法
  • 主函数自行添加 头文件 + 宏定义 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 串的顺序存储 ...顺序串的创建 void creat(seqstring *S) {...

    主函数自行添加

    头文件 + 宏定义

    #include <stdio.h>
    #include <stdlib.h>
    #define MAXSIZE 100

    串的顺序存储

    typedef struct
    {
    	char str[MAXSIZE];
    	int length;
    }seqstring;

    顺序串的创建

    void creat(seqstring *S)
    {
    	char c;
    	int i=0;
    	while((c=getchar())!='\n')
    	{
    		S->str[i++]=c;
    	}
    	S->str[i]='\0';
    	S->length=i;
    	return ;
    }

    (1)插入运算

    将字符串T插入到字符串S的第i个字符开始的位置上

    void strinsert(seqstring *S,int i,seqstring T)
    {
    	int k;
    	if(i<1 || i>S->length+1 || S->length + T.length>=MAXSIZE)
    	{
    		printf("can not insert\n");
    		return ;
    	}
    	for(k=S->length-1;k>=i-1;k--)
    	{
    		S->str[k+T.length]=S->str[k];
    	}
    	for(k=0;k<T.length;k++)
    	{
    		S->str[k+i-1]=T.str[k];
    	}
    	S->length+=T.length;
    	S->str[S->length]='\0';
    }

    (2)删除运算

    将串S中从第i个字符起长度为len的字串删除

    void strdelete(seqstring *S,int i,int len)
    {
    	int k;
    	if(i<0 || i>S->length || i+len-1>MAXSIZE)
    	{
    		printf("can not delete\n");
    		return ;
    	}
    	for(k=i-1;k<=S->length-1;k++)
    	{
    		S->str[k]=S->str[k+len];
    	}
    	S->length-=len;
    	S->str[k]='\0';
    	return ;
    }

    (3)顺序串的连接

    将串S1和串S2连接

    seqstring *strconcat(seqstring S,seqstring T)
    {
    	int i;
    	seqstring *r;
    	if(S.length+T.length>=MAXSIZE)
    	{
    		printf("can not concate\n");
    		return NULL;
    	}
    	r=(seqstring*)malloc(sizeof(seqstring));
    	for(i=0;i<S.length;i++)
    	{
    		r->str[i]=S.str[i];
    	}
    	for(i=0;i<T.length;i++)
    	{
    		r->str[S.length+i]=T.str[i];
    	}
    	r->length=S.length+T.length;
    	r->str[r->length]='\0';
    	return r;
    }

    (4)求子串运算

    从串第i个字符开始取长度为len的子串返回

    seqstring *substring(seqstring S,int i,int len)
    {
    	int k;
    	seqstring *r;
    	if(i<1 || i>S.length || i+len-1>S.length)
    	{
    		printf("substring error\n");
    		exit(1);
    	}
    	else
    	{
    		r=(seqstring*)malloc(sizeof(seqstring));
    		for(k=0;k<len;k++)
    		{
    			r->str[k]=S.str[i-1+k];
    		}
    		r->length=len;
    		r->str[r->length]='\0';
    	}
    	return r;
    }

     

    展开全文
  • C语言数据结构顺序串

    2010-12-04 12:14:32
    顺序串去除字符串的前导空格,后导空格,保持每个单词之间有且只有一个空格,并且统计单词的频率和个数,还具有替换单词的功能
  • 顺序串操作C++描述

    2013-08-06 09:06:49
    C++描述的顺序串操作。VC6.0调试通过。
  • 定长顺序串【C语言】

    千次阅读 2019-11-27 21:38:49
    定长顺序串【C语言】 题目: 用定长顺序串编写下列算法 1.将顺序串r中所有值为ch1的字符转换成ch2的字符。 2.将顺序串r中所有字符按照相反次序仍存放在r中。 3.从顺序串r中删除其值等于ch的所有...

    定长顺序串【C语言】

    题目:

    定长顺序串编写下列算法
    1.将顺序串r中所有值为ch1的字符转换成ch2的字符。
    2.将顺序串r中所有字符按照相反次序仍存放在r中。
    3.从顺序串r删除其值等于ch所有字符
    4.从顺序串r1中第Index个字符起求首次串r2相同的子串起始位置
    5.从顺序串r删除所有与串r1相同的子串


    时间复杂度为任意空间复杂度为任意
    代码:
    /*3-2*/
    #include <stdio.h>
    #include <stdlib.h>
    #define size 40
    int num=0;
    int Index=0;
    typedef struct
    {
        char ch[size];
        int len;
    }Seqstring;
    void Create(Seqstring *S)
    {
        int j;
        for(j=0;j<num;j++)
        {
            scanf(" %c",&S->ch[j]);/*%c前面必须有空格*/
        }
        S->len=num;
    }
    void Replace(Seqstring *S,char e1,char e2)
    {
        int i;
        for(i=0;i<=S->len;i++)
        {
            if(S->ch[i]==e1)
            {
                S->ch[i]=e2;
            }
        }
    }
    void Reverse(Seqstring *S)
    {
        Seqstring *ReS=S;
        int i;
        for(i=0;i<ReS->len;i++)
        {
            ReS->ch[i]=S->ch[S->len-1-i];
        }
        S=ReS;
    }
    void Delete(Seqstring *S,char e)
    {
        int i;
        for(i=0;i<S->len;i++)
        {
            if(S->ch[i]==e)
            {
                int j;
                for(j=i;j<=S->len-1;j++)
                {
                    int temp=1;
                    while(S->ch[j]==S->ch[j+temp])
                    {
                        temp++;
                    }
                    S->ch[j]=S->ch[j+temp];
                }
            }
        }
        S->len=0;
        int k=0;
        while(S->ch[k]!='\0')
        {
            S->len++;
            k++;
        }
        if(S->len==0)
        {
            printf("该串被清空...\n");
        }
    }
    void Match(Seqstring *r1,Seqstring *r2,int m)
    {
        int i;
        if(r1->len-m<r2->len)
        {
            printf("匹配失败...\n");
            return;
        }
        for(i=m-1;i<r1->len;i++)
        {
            int j=i;
            int k=0;
            while(r1->ch[j]==r2->ch[k])
            {
                j++;
                k++;
            }
            if(k==r2->len)
            {
                printf("匹配成功...\n将您上次输入的数字当作位置“1”\n那么两串匹配的起始位置为:%d\n",i+1-m+1);
                return;
            }
        }
        printf("匹配失败...\n");
    }
    void sDelete(Seqstring *S,Seqstring *s)
    {
        if(s->len>S->len)
        {
            return;
        }
        int i;
        for(i=0;i<=S->len;i++)
        {
            int j=i;
            int k=0;
            while(S->ch[j]==s->ch[k])
            {
                j++;
                k++;
            }
            if(s->ch[k+1]=='\0' && s->ch[k]=='\0')
            {
                int x;
                for(x=1;x<=s->len;x++)
                {
                    int t;
                    for(t=i;t<=S->len;t++)
                    {
                        S->ch[t]=S->ch[t+1];
                    }
                    S->len--;
                }
            }
        }
    }
    void view(Seqstring S)
    {
        if(S.len==0)
        {
            printf("该串为:\n空\n");
            return;
        }
        printf("该串为:");
        int i;
        for(i=0;i<S.len;i++)
        {
            printf("%c",S.ch[i]);
        }
        printf("\n");
    }
    int main()
    {
        /*创建顺序串*/
        Seqstring r;
        printf("请您输入--串的长度:\n");
        scanf("%d",&num);
        r.len=num;
        printf("请你输入--串:\n");
        Create(&r);
        view(r);
        /*替换顺序串中的一个字符*/
        printf("#第一步操作#\n");
        printf("请您输入--您想替换的字符:\n");
        char ch1;
        scanf(" %c",&ch1);/*注意%c前面一定要有空格*/
        printf("您想将它替换成:\n");
        char ch2;scanf(" %c",&ch2);
        Replace(&r,ch1,ch2);view(r);
        /*顺序串的反转*/
        printf("#第二步操作#\n");
        printf("您的顺序串即将反转...\n");
        Reverse(&r);view(r);
        /*顺序串的删除*/
        printf("#第三步操作#\n");
        printf("请您输入--您想删除的字符:\n");
        char ch;
        scanf(" %c",&ch);
        Delete(&r,ch);
        view(r);
        /*输入一个串r1*/
        printf("#第四步操作#\n");
        Seqstring r1;
        printf("请您输入--串r1的长度:\n");
        scanf("%d",&num);
        r1.len=num;
        printf("请你输入--串r1:\n");
        Create(&r1);
        view(r1);
        /*输入一个串r2*/
        Seqstring r2;
        printf("请您输入--串r2的长度:\n");
        scanf("%d",&num);
        r2.len=num;
        printf("请你输入--串r2:\n");
        Create(&r2);
        view(r2);
        printf("根据题意:\n");
        printf("您想从r1的第几个字符开始查找:\n");
        scanf("%d",&Index);
        printf("r1和r2正在进行匹配...\n");
        Match(&r1,&r2,Index);
        printf("#第五步操作#\n");
        printf("显示r:\n");
        view(r);
        printf("r的长度:%d\n",r.len);
        printf("显示r1:\n");
        view(r1);
        printf("r1的长度:%d\n",r1.len);
        printf("正在去除r中与r1相同的子串...\n");
        sDelete(&r,&r1);
        printf("显示r:\n");
        view(r);
        printf("hello world\n");
        return 0;
    }
    

    运行情况:
    请您输入--串的长度:
    10
    请你输入--串:
    abcdeabcde
    该串为:abcdeabcde
    #第一步操作#
    请您输入--您想替换的字符:
    a
    您想将它替换成:
    e
    该串为:ebcdeebcde
    #第二步操作#
    您的顺序串即将反转...
    该串为:edcbeebcde
    #第三步操作#
    请您输入--您想删除的字符:
    e
    该串为:dcbbccd
    #第四步操作#
    请您输入--串r1的长度:
    4
    请你输入--串r1:
    cbbc
    该串为:cbbc
    请您输入--串r2的长度:
    2
    请你输入--串r2:
    bc
    该串为:bc
    根据题意:
    您想从r1的第几个字符开始查找:
    2
    r1和r2正在进行匹配...
    匹配成功...
    将您上次输入的数字当作位置“1”
    那么两串匹配的起始位置为:2
    #第五步操作#
    显示r:
    该串为:dcbbccd
    r的长度:7
    显示r1:
    该串为:cbbc
    r1的长度:4
    正在去除r中与r1相同的子串...
    显示r:
    该串为:dcd
    hello world
    Program ended with exit code: 0
    
    Copyright © 2019 wyq. All rights reserved.
    展开全文
  • 顺序串的各种基本运算的算法

    千次阅读 2020-06-15 18:18:28
    领会顺序串存储结构和顺序串中各种基本运算算法设计 结构体 声明顺序串类型 typedef struct { char data[100];//串中字符 int length;//串长 }Sqstring; 创建顺序串 strassign(Sqstring& s, char str[]):由...

    领会顺序串存储结构和顺序串中各种基本运算算法设计

    结构体 声明顺序串类型

    typedef struct {
    	char data[100];//串中字符
    	int length;//串长
    }Sqstring;
    

    创建顺序串

    strassign(Sqstring& s, char str[]):由串常量str创建顺序串s

    void strassign(Sqstring& s, char str[]) {//由常量串创建顺序串
    	for ( int i = 0; i < str[i]!='\0'; i++) {
    		s.data[i] = str[i];
    		s.length = i;
    	}
    }
    

    销毁串

    void destroystr(Sqstring& s){}//销毁串
    

    复制串

    将顺序串t复制到串s

    void strcopy(Sqstring& s, Sqstring t) {//串复制
    	for (int i = 0; i < t.length; i++) {
    		s.data[i] = t.data[i];
    	}
    	s.length = t.length;
    }
    

    判相等

    判断两个顺序串s和t是否相等

    void strequal(Sqstring s, Sqstring t) {//判断串相等
    	if ( s.length != t.length ) {
    		printf("两串不相同\n");
    	}
    	else {
    		for (int i = 0; i < t.length; i++) {
    			if (s.data[i] != t.data[i]) {
    				printf("两串不相同\n");
    				break;
    			}
    		}
    		printf("两串相同\n");
    	}
    }
    

    求串长度

    void strlength(Sqstring s) {//求串长度
    	printf("串的长度为%d\n", s.length);
    }
    

    串连接

    返回将顺序串t连接到顺序串s之后构成的新串

    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;
    }
    

    求子串

    返回顺序串s中第i个字符开始的j个字符构成的新串

    Sqstring 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 ) {
    		return str;//参数不正确时返回空串
    	}
    	for ( k = i-1; k < i+j-1; k++) {
    		str.data[k - i + 1] = s.data[k];
    	}
    	str.length = j;
    	return str;
    }
    

    插入子串

    返回将顺序串s2插入到顺序串s1中的第i个位置构成的新串

    Sqstring insterstr(Sqstring s1, int i, Sqstring s2) {//插入子串
    	int j;
    	Sqstring str;
    	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;
    }
    

    删除子串

    返回删除顺序串s中的第i个字符开始的j个字符构成的新串

    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;
    }
    

    替换子串

    返回将顺序串s的第i个字符开始的j个字符替换成顺序串t构成的新串

    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 - 1 > s.length) {
    		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+k-1; k < s.length; k++) {
    		str.data[t.length + k - j] = s.data[k];
    	}
    	str.length = s.length - j + t.length;
    	return str;
    }
    

    输出子串

    void showstr(Sqstring s) {//输出子串
    	if (s.length>0) {
    		for (int i = 0; i < s.length; i++) {
    			printf("%c ", s.data[i]);
    		}
    		printf("\n");
    	}
    }
    
    展开全文
  • 顺序串类的源代码

    2011-11-17 22:45:03
    这是一个顺序串类的源代码和测试的主程序,其中标注了我的一个小错误,希望对大家有用!
  • 实现顺序串各种基本运算的算法

    千次阅读 多人点赞 2019-01-17 17:49:12
    * 领会顺序串存储结构和掌握顺序串中各种基本运算的算法设计 * 实验内容: * 实现顺序串的各种基本运算 * 1、建立串s="abcdefghijklmn"和串s1="123" * 2、输出串s * 3、输出串s的长度 * ...

    /**
    *    实验题目:
    *        实现顺序串各种基本运算的算法
    *    实验目的:
    *        领会顺序串存储结构和掌握顺序串中各种基本运算的算法设计
    *    实验内容:
    *        实现顺序串的各种基本运算
    *        1、建立串s="abcdefghijklmn"和串s1="123"
    *        2、输出串s
    *        3、输出串s的长度
    *        4、在串s的第9个字符位置插入串s1而产生串s2
    *        5、输出串s2
    *        6、删除串s第2个字符开始的3个字符而产生串s2
    *        7、输出串s2
    *        8、将串s第2个字符开始的5个字符替换成串s1而产生串s2
    *        9、输出串s2
    *        10、提取串s的第2个字符开始的10个字符而产生串s3
    *        11、输出串s3
    *        12、将串s1和串s2连接起来而产生串s4
    *        13、输出串s4
    */

    #include <stdio.h>

    #define MAX_SIZE 100

    typedef struct
    {
        char data[MAX_SIZE]; // 串中字符
        int length; // 串长
    }SqString; // 声明顺序串类型

    /*-----------------将字符串常量赋给串s--------------------*/
    static void str_assign(SqString &s, char cstr[])
    {
        int i;

        for(i = 0; cstr[i] != '\0'; i++)
            s.data[i] = cstr[i];
        s.length = i;
    }

    /*-----------------销毁串--------------------*/
    static void destroy_str(SqString &s)
    {

    }

    /*-----------------串复制--------------------*/
    static void str_copy(SqString &s, SqString t)
    {
        int i;

        for(i = 0; i < t.length; i++)
            s.data[i] = t.data[i];
        s.length = t.length;
    }

    /*-----------------判断串相等--------------------*/
    static bool str_equal(SqString s, SqString t)
    {
        bool same = true;

        if(s.length != t.length) // 长度不相等时返回false
            same = false;
        else
        {
            for(int i = 0; i < s.length; i++)
            {
                if(s.data[i] != t.data[i]) // 有一个对应字符不相同时返回假
                {
                    same = false;
                    break;
                }
            }
        }

        return same;
    }

    /*-----------------求串长度--------------------*/
    static int str_length(SqString s)
    {
        return s.length;
    }

    /*-----------------串连接--------------------*/
    static SqString str_concat(SqString s, SqString t)
    {
        int index;
        SqString str;

        str.length = 0;
        for(index = 0; index < s.length; index++) // s.data[0...s.length-1]->str
            str.data[index] = s.data[index];
        for(index = 0; index < t.length; index++) // t.data[0...t.length-1]->str
            str.data[s.length + index] = t.data[index];
        str.length = s.length + t.length; // 计算串长

        return str;
    }

    /*-----------------求子串--------------------*/
    static SqString sub_str(SqString s, int start, int len)
    {
        int index;
        SqString str;

        str.length = 0;
        if((start <= 0) || (start > s.length) || (len < 0) || (start + len - 1 > s.length)) // 参数不正确时返回空串
            return str;
        for(index = start - 1; index < start + len - 1; index++)
            str.data[index - start + 1] = s.data[index];
        str.length = len;

        return str;
    }

    /*-----------------插入子串--------------------*/
    static SqString ins_str(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++) // s1.data[0...i-2]->str
            str.data[j] = s1.data[j];
        for(j = 0; j < s2.length; j++) // s2.data[0...s2.length-1]->str
            str.data[i + j - 1] = s2.data[j];
        for(j = i - 1; j < s1.length; j++) // s1.data[i-1...s1.length-1]->str
            str.data[s2.length + j] = s1.data[j];
        str.length = s1.length + s2.length;

        return str;
    }

    /*-----------------删除子串--------------------*/
    static SqString del_str(SqString s, int start, int len)
    {
        int index;
        SqString str;

        str.length = 0;

        if((start <= 0) || (start > s.length) || (start + len > s.length + 1)) // 参数不正确时返回空串
            return str;
        for(index = 0; index < start - 1; index++) // s.data[0...start-2]->str
            str.data[index] = s.data[index];
        for(index = start + len - 1; index < s.length; index++) // s.data[start + len - 1...s.length-1]->str
            str.data[index - len] = s.data[index];
        str.length = s.length - len;

        return str;
    }

    /*-----------------替换子串--------------------*/
    static SqString rep_str(SqString s, int start, int len, SqString t)
    {
        int index;
        SqString str;

        str.length = 0;

        if((start <= 0) || (start > s.length) || (start + len - 1 > s.length)) // 参数不正确时返回空串
            return str;
        for(index = 0; index < start - 1; index++) // s.data[0...start-2]->str
            str.data[index] = s.data[index];
        for(index = 0; index < t.length; index++) // t.data[0...t.length-1]->str
            str.data[start + index - 1] = t.data[index];
        for(index = start + len - 1; index < s.length; index++) // s.data[start + len - 1...s.length - 1]->str
            str.data[t.length + index - len] = s.data[index];
        str.length = s.length - len + t.length; // 计算串长

        return str;
    }


    /*-----------------输出串s--------------------*/
    static void disp_str(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[])
    {
        SqString s, s1, s2, s3, s4;

        printf("顺序串的基本运算如下:\n");
        printf("  (1)建立串s和串s1\n");
        str_assign(s, "abcdefghijklmn");
        str_assign(s1, "123");
        printf("  (2)输出串s:");
        disp_str(s);
        printf("  (3)串s的长度:%d\n", str_length(s));
        printf("  (4)在串s的第9个字符位置插入串s1而产生串s2\n");
        s2 = ins_str(s, 9, s1);
        printf("  (5)输出串s2:");
        disp_str(s2);

        printf("  (6)删除串s第2个字符开始的3个字符而产生串s2\n");
        s2 = del_str(s, 2, 3);
        printf("  (7)输出串s2:");
        disp_str(s2);

        printf("  (8)将串s第2个字符开始的5个字符替换成串s1而产生串s2\n");
        s2 = rep_str(s, 2, 5, s1);
        printf("  (9)输出串s2:");
        disp_str(s2);

        printf("  (10)提取串s的第2个字符开始的10个字符而产生串s3\n");
        s3 = sub_str(s, 2, 10);
        printf("  (11)输出串s3:");
        disp_str(s3);

        printf("  (12)将串s1和串s2连接起来而产生串s4\n");
        s4 = str_concat(s1,s2);
        printf("  (13)输出串s4:");
        disp_str(s4);
        destroy_str(s);
        destroy_str(s1);
        destroy_str(s2);
        destroy_str(s3);
        destroy_str(s4);

        return 0;
    }
    测试结果:

    顺序串的基本运算如下:
      (1)建立串s和串s1
      (2)输出串s:abcdefghijklmn
      (3)串s的长度:14
      (4)在串s的第9个字符位置插入串s1而产生串s2
      (5)输出串s2:abcdefgh123ijklmn
      (6)删除串s第2个字符开始的3个字符而产生串s2
      (7)输出串s2:aefghijklmn
      (8)将串s第2个字符开始的5个字符替换成串s1而产生串s2
      (9)输出串s2:a123ghijklmn
      (10)提取串s的第2个字符开始的10个字符而产生串s3
      (11)输出串s3:bcdefghijk
      (12)将串s1和串s2连接起来而产生串s4
      (13)输出串s4:123a123ghijklmn

    展开全文
  • 数据结构课程中动态顺序串相关操作的实现。
  • 数据结构实践——顺序串算法

    千次阅读 2015-10-10 22:15:51
    【项目 - 顺序串算法】 采用顺序存储方式存储串,实现下列算法并测试: (1)试编写算法实现将字符串S中所有值为c1的字符换成值为c2的字符: void Trans(SqString *&s, char c1, char c2); (2)试编写算法,...
  • 顺序串的基本操作,增删插改等,用了数据结构的顺序存储,当然效率可能不高,但主要是熟悉数据结构已经串
  • 数据结构顺序串的基本操作(C/C++实现)

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

    千次阅读 2016-12-11 21:12:15
    定长顺序串采用的是数组方法进行存储,空间分配一次完成,可以实行如下的基本操作 #include #include using namespace std; #define MAXSTRLEN 200 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0...
  • 实验题1:实现顺序串的各种基本运算的算法。 内容: 编写一个程序sqstring.cpp,实现顺序串的各种基本运算,并在此基础上设计一个exp4-1.cpp完成以下功能。 (1)建立串s="abcdefghefghijklmn"和串s=“xyz”. ...
  • 字符、简称,它也是一种重要的线性结构。计算机中处理的大部分数据都是字符数据,例如,学生学籍信息系统的姓名、性别、家庭住址、院系名称等信息都属于字符数据。广泛应用于各种专业的信息管理、信息检索...
  • 算法与数据结构之顺序串

    万次阅读 2015-10-21 13:35:16
    #include #include ...typedef struct //非紧缩格式的顺序串的定义 { char data[maxsize]; int length; }sqstring; void strassign(sqstring &s) //将字符串复制给串 { char a[100]; int i; getchar(); pr
  • 实现顺序串的各种模式匹配算法

    千次阅读 2019-01-20 20:56:37
    * 实现顺序串的各种模式匹配算法 * 实验目的: * 掌握串的模式匹配算法即BF(Brute Force)和KMP(克努特-莫里斯-普拉特)算法设计 * 实验内容: * 实现顺序串的各种模式匹配运算 * 1、建立目标串s="...
  • 数据结构实现顺序串的各种模式匹配算法 注意:本代码为了测试运行默认含有操作所需数据,如有需要可自己增删改相关数据 涉及基本运算流程 建立目标串s=abcabcdabcdeabcdeabcdefabcdefg 和模式串 t =abcdeabcdefab ...
  • 数据结构-顺序串的基本操作

    千次阅读 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;...
  • 动态存储分配(堆分配)的顺序串与顺序表在操作上的异同串(string)(或字符串)是由零个或多个字符组成的有限序列,一般记为 s=‘a1a2...an’ (n>=0) 串的数据元素固定为字符型的线性表,因此串的逻辑结构和...
  • 顺序串基本操作

    千次阅读 2017-02-07 17:58:18
    #include #define MaxSize 100 //最多的字符个数 typedef struct { char data[MaxSize]; //定义可容纳MaxSize个字符的空间 ... //标记当前实际长 } SqString; void StrAssign(SqString &s,char cstr[])
  • (四)顺序串和链串

    千次阅读 2017-03-10 19:41:09
    1.的概念  ,即是字符,也是一种特殊的线性表;其特殊性有两方面:  1.在逻辑结构方面,是仅限数据类型为字符,不能是其他数据类型;  2.在运算方面,将一个作为整体或者一部分进行运算。 2.几个...
  • 串的基本概念和顺序串

    千次阅读 2018-03-05 19:01:21
    一、 的基本概念(或字符),是由零个或多个字符组成的有穷序列。含零个字符的称为空串,用Ф表示。中所含字符的个数称为该的长度(或长)。通常将一个表示成“a1a2…an”的形式。其中最外边的双...
  • 请问怎样统计一个顺序串中出现的字符,和每个字符出现的次数,请大神帮帮忙
  • 实验题3:实现顺序串的各种模式匹配算法(即BF和KMP算法)设计 内容: 编写一个程序,实现顺序串的各种模式匹配运算,并在此基础上完成如下功能: (1)建立“abcabcdabcdeabcdefabcdefg”目标串s和...
  • 由用户随意输入两个:主S和模式T,设S=‘s1s2…sn’,T=‘t1t2…tm’,且0。 用简单模式匹配算法判断模式T是否在主S中,若在,则输出模式在主的第一匹配位置,否则,匹配失败,返回零值。
  • C语言实现字符的操作,这里给出的资源是实现的源代码,读者可以参照代码加以修改,若有修改意见请联系本文博主一起商讨。代码都是基于C语言。
  • /* ...*All rights reserved. *文件名称:main.cpp *作者:张旺华 *完成日期: 2016 年 7 月 2 日 ...*问题描述:编写一个程序实现顺序串的各项基本运算 * */ #include #define MaxSize 100 typedef struct { char dat
  • #include&lt;stdio.h&...//顺序存储 typedef struct st { char *ch; //存放的起始地址,中第i个字符存储在ch[i-1]中 int length; //的长度 int strsize; //分配的存储空间的大小...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,031,406
精华内容 412,562
关键字:

顺序串