串的基本操作

#include <iostream>
#include <algorithm>
#include <cstring>
#define sqtrmax 1000
using namespace std;
typedef struct
{
    char *data;
    int length;
} sqtr;
void StrAssign (sqtr &S, char *chars);               //赋值
void Destroy(sqtr &S);                         //销毁
void StrCopy (sqtr &T,sqtr S);                  //复制
int StrLength(sqtr S);                            //长度
int StrEmpty (sqtr S);                               //判空
void Concat (sqtr &T,sqtr S1,sqtr S2);             //串联接
int StrCompare (sqtr S, sqtr T);                  //比较
int SubString (sqtr &Sub,sqtr S,int pos,int len);   //求子串
void ClearString (sqtr &S);                        //清空
int Index (sqtr S,sqtr T,int pos);                //定位函数
void Replace (sqtr &S, sqtr T,sqtr V);                  //串置换
int StrInsert (sqtr &S,int pos, sqtr T);              //插入
int StrDele (sqtr &S,int pos,int len);               //删除
void StrOutput(sqtr S) ;                              //输出
int main()
{
    char str[12]="abcssasdsss",str1[4]="sss",str2[4]="vvv";
    sqtr S,T,V,S1,Sub;
    S.data=NULL;
    T.data=NULL,V.data=NULL;
    StrAssign(S,str);
    StrAssign(T,str1);
    StrAssign(V,str2);
    cout<<"串S：";
    StrOutput(S);
    cout<<endl;
    cout<<"串T：";
    StrOutput(T);
    cout<<endl;
    cout<<"串V：";
    StrOutput(V);
    cout<<endl;
    cout<<"求第3个后S中与T相等的子串的位置";
    cout<<Index(S,T,3);
    cout<<endl;
    cout<<"求第3个后S中长度为3的子串";
    SubString(Sub,S,3,3);
    StrOutput(Sub);
    cout<<endl;
    cout<<"在串S的第10个字符之前插入串T：";
    StrInsert(S,10,T);
    StrOutput(S);
    cout<<endl;
    cout<<"删除串S从第2个字符起长度为3的子串：";
    StrDele(S,2,3);
    StrOutput(S);
    cout<<endl;
    cout<<"连接T,V到S1";
    Concat(S1,T,V);
    StrOutput(S1);
    cout<<endl;
    //cout<<"\n"<<"采用KMP算法进行模式匹配：";
    //cout<<Index_KMP(S,T,1)<<endl;
    cout<<"用串V替换S中与T相等的所有子串：";
    Replace(S,T,V);
    StrOutput(S);
    cout<<endl;






}
/**赋值**//*strcpy(S.data,chars);*/
void StrAssign (sqtr &S, char *chars)
{
    int i;
    S.data=(char *)malloc(sqtrmax *sizeof(char));
    if(!S.data) exit(0);
    for(i=0; chars[i]!='\0'; i++)
        S.data[i]=chars[i];
        S.data[i]='\0';
    S.length=i;
}
/**长度**//*strlen(S.data);*/
int StrLength(sqtr S)
{
    return S.length;
}
/**判空**/
int StrEmpty (sqtr S)
{
    if(!S.length)  //长度=0
        return 1;
    else
        return 0;
}
/**复制**//*strcpy(S.data,chars);*/
void StrCopy (sqtr &T,sqtr S)
{
    StrAssign(T,S.data);//不是S
}




/**清空**/
void ClearString (sqtr &S)
{
    if(S.data)
    {
        delete S.data;
        S.data=NULL;
    }
    S.length=0;
}
/**销毁 似清空**/
void Destroy(sqtr &S)
{
    if(S.data)
    {
        delete S.data;
        S.data=NULL;
    }
}
/**比较**//*(strcmp(S.data,T.data)==0)*/
int StrCompare (sqtr S, sqtr T)
{
    int i;
    for(i=0; i<S.length&&i<T.length; i++)
        if(S.data[i]!=T.data[i])
            return S.data[i]-T.data[i];//S的值大就>0
    return S.length-T.length;
    //注意return有终止作用，谁先执行就return谁；
}
/**删除**/
int StrDele (sqtr &S,int pos,int len)
{
    if(pos<1||pos>S.length-len+1)
        return 0;
    int i=0;
    while(i<pos-1)
        i++;
    for(i=pos-1; i<S.length-len; i++)
        S.data[i]=S.data[i+len];
    S.data[i]='\0';
    S.length-=len;


}
/**串联接**/
void Concat (sqtr &T,sqtr S1,sqtr S2)
{
    T.length=S1.length+S2.length+1;
    T.data=(char *)malloc(S1.length+S2.length *sizeof(char));
    int j=0,k=0;
    while(S1.data[j]!='\0') T.data[k++]=S1.data[j++];
    j=0;
    while(S2.data[j]!='\0') T.data[k++]=S2.data[j++];
    T.data[k]='\0';
}
/**求子串**/
int SubString (sqtr &Sub,sqtr S,int pos,int len)
{
    // 以 Sub 返回串 S 中第 pos 个字符起长度为 len 的子串
    Sub.data=(char *)malloc(len *sizeof(char));
    Sub.length=len;
    int i,k;
    if(pos<1)
        return 0;
    i=0;
    while(i<pos-1&&S.data[i]!='\0') i++;
    if(i<pos-1||S.data[i]=='\0')
        return 0;
    else
    {
        k=0;
        while(len--&&S.data[i]!='\0')
        {
            Sub.data[k++]=S.data[i++];
            //cout<<Sub.data[k-1]<<endl;
        }
        if(k<S.length) return 0;
        else
            Sub.data[k]='\0';


    }
}
/**定位函数**/
int Index (sqtr S,sqtr T,int pos)
{
    //若主串 S 中存在和串 T 值相同的子串，则返回它在主串 S 中第 pos个字符之后第一次出现的位置; 否则函数值为0。
    int i,j;
    if(pos>0)
    {
        i=pos-1;
        j=0;
        while(S.data[i+j]!='\0'&&T.data[j]!='\0')
        {
            if(S.data[i+j]==T.data[j])
            {
                j++;
            }
            else
            {
                i++;//相当于二重for循环中跳出j，进入i循环
                j=0;
            }
        }
        if(T.data[j]=='\0')
                return i+1;
            else
            return 0;
    }
}
/**串置换**///用 V 替换主串 S 中出现的所有与模式串）T 相等的不重叠的子串。
void Replace (sqtr &S,sqtr T,sqtr V)
{
    sqtr news,sub;
    news.data=(char *)malloc(sqtrmax *sizeof(char));
    news.data=NULL;
    int n=S.length,m=T.length;
    int i=1,pos=1,j=0;
    while(pos<=n-m+1&&i)//n-m+1
    {
        i=Index(S,T,pos);
        if(i!=0)//不能写i，因为i是位置，不一定啥数
        {
            SubString(sub,S,pos,i-pos);
            if(j==0)
            {
            Concat(news,sub,V);
            }
            else
            {
                if(i-pos!=0)
                Concat(news,news,sub);
                Concat(news,news,V);//当非第一次时，后面要直接连在news上
            }
            pos=i+m;
            j++;
        }


    }
    SubString(sub,S,pos,n-pos+1);
    if(n-pos+1!=0)
    Concat(S,news,sub);
    StrAssign(S,news.data);
}
/**插入**/
int StrInsert (sqtr &S,int pos,sqtr T)
{
    int sl=S.length,tl=T.length;// 在串 S 的第 pos(1≤pos≤StrLength(S)＋1) 个字符之前插入串T
    char S1[sl+1] ;            // 设S1为辅助串空间
    if (pos < 1 || pos > sl+1)
        return 0;               // 插入位置不合法;
    if (tl>0)
    {
        int i=0,k,j;
        while ( S.data[i]!='\0')
        {
            S1[i]=S.data[i];
            i++;// 暂存串S
        }
        S1[i]='\0';
        S.data= (char *)malloc((sl + tl +1) *sizeof(char));   // 重新分配空间
        for ( i=0, k=0; i<pos-1; i++)
        {
            S.data[k++] = S1[i];
            // 保留插入位置之前的子串
        }
        j = 0;
        while ( T.data[j]!= '\0')
        {
            S.data[k++] = T.data[j++];
        }     // 插入T
        while ( S1[i] != '\0')
            S.data[k++] = S1[i++];  // 复制插入位置之后的子串
        S.data[k] = '\0';
        S.length=k;                      // 置串S的结束标志
    }
}
/**输出**/
void StrOutput(sqtr S)
{
    int i=0;
    while(i<S.length)
    {
        cout<<S.data[i];
        i++;
    }
}V

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/509675.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Result window is too large, from + size must be less than or equal to: [10000] but was [12390]. See

Result window is too large, from + size must be less than or equal to: [10000] but was [12390]. See

ES 查询报错 Caused by: java.lang.IllegalArgumentException: Result window is too large, from size must be less than or equal to: [10000] but was [12390]. See the scroll api for a more efficient way to request large data sets. This limit can be set by chan…
阅读更多...
Delta3d插件机制

Delta3d插件机制

Delta3d插件机制主要通过以下两个类实现&#xff1a; class MainWindow;/**Abstract interface class for STAGE plugins*/class Plugin{public:virtual ~Plugin() {} /** Is called after instantiation */virtual void Create() {}/** Is called before destruction */virt…
阅读更多...
java中泛型学习总结

java中泛型学习总结

为什么需要使用泛型: 1):存储任意类型的数据在集合中 ,但是取出来都是Object类型的,此时就得强转.List list new ArrayList();list.add(1); //Interger类型Object ele list.get(0); //现在需要调用Interger类中的方法I nterger num (Interger) ele;System.out.println(num);…
阅读更多...
数据结构实验之栈：行编辑器

数据结构实验之栈：行编辑器

题目描述 一个简单的行编辑程序的功能是&#xff1a;接受用户从终端输入的程序或数据&#xff0c;并存入用户的数据区。 由于用户在终端上进行输入时&#xff0c;不能保证不出差错&#xff0c;因此&#xff0c;若在编辑程序中&#xff0c;“每接受一个字符即存入用户数据区”的…
阅读更多...
CDH、CM下载403，Cloudera收费无法下载解决，CDH安装包下载

CDH、CM下载403，Cloudera收费无法下载解决，CDH安装包下载

CDH下载 6.3.2 链接: https://pan.baidu.com/s/1e1LmRY7aHQSCMJq3Lz6DtA 密码: 1vje --来自百度网盘超级会员V6的分享6.3.1 链接: https://pan.baidu.com/s/1Xsj_zDvuJ12q3pGTY77BRg 密码: f9h3 --来自百度网盘超级会员V6的分享6.2.1 链接: https://pan.baidu.com/s/10s7…
阅读更多...
别说“我已经很努力了”

别说“我已经很努力了”

转自&#xff1a;http://blog.csdn.net/foruok/article/details/40247543 我们程序员的努力与挣扎有时非常尴尬&#xff0c;如果没有结果&#xff0c;都是徒然&#xff0c;都是说不得说不得…… 我自己做项目经理时&#xff0c;干的项目也经常延期……非常惭愧。而延期其实对研…
阅读更多...
Java集合框架-概述

Java集合框架-概述

Java集合框架的由来: 其实在Java2(jdk1.2)之前&#xff0c;Java是没有完整的集合框架的。它只有一些简单的可以自扩展的容器类&#xff0c;比如Vector&#xff0c;Stack&#xff0c;Hashtable等。 为什么存在容器类: 容器类(集合类)可以存储多个数据,既然数组可以存储多个数据…
阅读更多...
MySQL Binlog增量同步工具go-mysql-transfer实现详解

MySQL Binlog增量同步工具go-mysql-transfer实现详解

go-mysql-transfer产品手册:https://www.kancloud.cn/wj596/go-mysql-transfer/2111996 一、 概述 工作需要研究了下阿里开源的MySQL Binlog增量订阅消费组件canal&#xff0c;其功能强大、运行稳定&#xff0c;但是有些方面不是太符合需求&#xff0c;主要有如下三点&#x…
阅读更多...
数据结构实验之栈五：下一较大值（一）

数据结构实验之栈五：下一较大值（一）

题目描述 对于包含n&#xff08;1<n<1000&#xff09;个整数的序列&#xff0c;对于序列中的每一元素&#xff0c;在序列中查找其位置之后第一个大于它的值&#xff0c;如果找到&#xff0c;输出所找到的值&#xff0c;否则&#xff0c;输出-1。 输入 输入有多组&#xf…
阅读更多...
与 C++11 多线程相关的头文件

与 C++11 多线程相关的头文件

C11 新标准中引入了四个头文件来支持多线程编程&#xff0c;他们分别是<atomic> ,<thread>,<mutex>,<condition_variable>和<future>。 <atomic>&#xff1a;该头文主要声明了两个类, std::atomic 和 std::atomic_flag&#xff0c;另外还…
阅读更多...
数据结构实验之栈二：一般算术表达式转换成后缀式

数据结构实验之栈二：一般算术表达式转换成后缀式

题目描述 对于一个基于二元运算符的算术表达式&#xff0c;转换为对应的后缀式&#xff0c;并输出之。输入 输入一个算术表达式&#xff0c;以‘#’字符作为结束标志。输出 输出该表达式转换所得到的后缀式。示例输入 a*b(c-d/e)*f# 示例输出 ab*cde/-f* #include<stdio.h…
阅读更多...
INFINI GATEWAY 极限网关初体验 ElasticSearch 两个集群数据同步

INFINI GATEWAY 极限网关初体验 ElasticSearch 两个集群数据同步

文章目录极限网关-配置说明配置文件日志、数据目录定义入口定义路由定义流程定义资源使用Demo写入两个ES集群极限网关-常见问题shutdown: ORM handler is not registered极限网关地址极限网关-配置说明 极限网关的大部分配置都可以通过 gateway.yml 来进行配置&#xff0c;配置…
阅读更多...
std::thread详解

std::thread详解

转自&#xff1a;http://www.cnblogs.com/haippy/p/3236136.html 上一篇博客《C11 并发指南一(C11 多线程初探)》中只是提到了 std::thread 的基本用法&#xff0c;并给出了一个最简单的例子&#xff0c;本文将稍微详细地介绍 std::thread 的用法。 std::thread 在 <thread&…
阅读更多...
Kafka 详细配置参数说明

Kafka 详细配置参数说明

参数值参数文件描述auto.create.topics.enableserver.properties【说明】是否允许自动创建Topic&#xff0c;若是false&#xff0c;就需要通过命令创建Topic。【默认值】true【取值范围】true或falselog.cleaner.backoff.msserver.properties【说明】检查是否有日志需要清理的时…
阅读更多...
数据结构实验之栈三：后缀式求值

数据结构实验之栈三：后缀式求值

题目描述 对于一个基于二元运算符的后缀表示式&#xff08;基本操作数都是一位正整数&#xff09;&#xff0c;求其代表的算术表达式的值。输入 输入一个算术表达式的后缀式字符串&#xff0c;以‘#’作为结束标志。输出 求该后缀式所对应的算术表达式的值&#xff0c;并输出之…
阅读更多...
std::mutex详解

std::mutex详解

Mutex 又称互斥量&#xff0c;C 11中与 Mutex 相关的类&#xff08;包括锁类型&#xff09;和函数都声明在 <mutex> 头文件中&#xff0c;所以如果你需要使用 std::mutex&#xff0c;就必须包含 <mutex> 头文件。 <mutex> 头文件介绍 Mutex 系列类(四种) st…
阅读更多...
java中stack集合框架

java中stack集合框架

栈(Stack):数据结构的一种,存储特点:Last In First Out. Stack 类表示后进先出&#xff08;LIFO&#xff09;的对象栈. 栈结构在生活中的体现: 1):QQ消息. A,B,C三个人先后发送消息,我们查看的时候发现最顶上的是最新的消息. 2):手枪弹夹的装和发射: 要来实现栈的存储,底层…
阅读更多...
ElasticSearch Pipeline 为新增数据设置更新时间

ElasticSearch Pipeline 为新增数据设置更新时间

文章目录模拟测试测试返回结果实际应用创建Pipeline查看创建Pipeline新增数据测试查看新增数据创建索引时直接设置Pipeline模拟测试 测试 POST _ingest/pipeline/_simulate {"pipeline": {"processors": [{"set": {"field": "t…
阅读更多...
队列的基本操作

队列的基本操作

链式存储 typedef int QElemType; typedef int Status;//具体数据类型具体定义 typedef struct QNode//队列结点结构体 { QElemType data; QNode *next; } QNode, *Queueptr; typedef struct // 链队列类型 { Queueptr front; // 队头指针&#xff08;结构体类…
阅读更多...
c++阻塞队列

c++阻塞队列

基于C11的阻塞队列简单实现 转载请说明出处&#xff1a;http://blog.csdn.net/cywosp/article/details/9157379 在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于&#xff0c;当队列为空时&#xff0c;从队列获取…
阅读更多...
最新文章

Copyright @ 2022~2023