精华内容
下载资源
问答
  • 数据结构—顺序

    2018-12-02 17:16:10
    学过《C语言程序设计》的都应该知道字符串的定义和相关操作。串跟字符串基本一样,只不过分为顺序存储结构和链式存储结构。这里只讲顺序存储结构,即顺序串。 串的相关定义 ... 串长:串中所含字...

      学过《C语言程序设计》的都应该知道字符串的定义和相关操作。串跟字符串基本一样,只不过分为顺序存储结构和链式存储结构。这里只讲顺序存储结构,即顺序串。

    串的相关定义

      虽然都知道,但还是要提一下,哈哈

      串:字符串的简称,是由零个或多个字符组成的有限序列。零个字符的串叫做空串。     
      子串:一个串中任意个连续的字符组成的序列,叫做该串的子串。空串是任何串的子串!
      串长:串中所含字符个数。  
      串与串的关系:
        串s = 串str:当且仅当两个串的长度相等并且各个对应位置上的字符都相同;
        串s > 串str:设s[n],str[n]是串s,str第一对对应位置上不相等的字符,若s[n]>str[n],则a>b;
        串s < 串str:设s[n],str[n]是串s,str第一对对应位置上不相等的字符,若s[n]<str[n],则s<str;

    串类型定义

    #include<stdio.h>
    #include<stdlib.h>
    #define MaxSize 100
    typedef struct lei
    {
     char data[MaxSize];   //存放串字符
     int length;           //存放串长
    }lei;                  //串的类型

    基本操作

    void StrAssign(lei &s,char str[]);   //生成串        //初始化
    void Dwatorystr(lei &s);             //销毁串
    void strcpy(lei &s_str,lei s);       //复制串        //c语言字符串复制函数strcpy包含在头文件#include<string.h>内;
    int strcmp(lei s,lei s_str);         //比较函数      //c语言字符串比较函数strcpy包含在头文件#include<string.h>内;
    int strlen(lei s);                   //求串长度      //c语言字符串求长度函数strlen包含在头文件#include<string.h>内
    lei strcat(lei s,lei s_str);         //串链接函数    //c语言字符串连接函数strcat包含在头文件#include<string.h>内
    lei substr(lei s,int i,int j);       //求子串        // 从第 i 个元素开始之后的 j 个元素
    lei InsStr(lei s,int i,lei s_str);   //子串的插入    //把串s_str插入到 s 的第 i 个元素的位置
    lei Delstr(lei s,int i,int j);       //子串的删除    //把串中第 i 个字符开始的长度为 j 的子串删除
    lei repstr(lei s,int i,int j,lei s_str);//子串的替换 //把串中第i个元素开始的长度为 j 的子串替换成 s_str
    void print(lei s);                   //输出串

    基本操作的函数实现

    void StrAssign(lei &s,char str[])      //生成串  //初始化
    {
        int i;
        for(i=0;str[i]!='\0';i++)
        {
            s.data[i]=str[i];
        }
        s.length=i;//设置串的长度
    }
    void Dwatorystr(lei &s)                //销毁串        
    {}
    void strcpy(lei &s_str,lei s)          //复制串  //把串s中的字符复制到空串s_str中
    {
        for(int i=0;i<s.length;i++)
        {
            s_str.data[i]=s.data[i];
        }
        s_str.length=i;//设置串的长度
    }
    int strcmp(lei s,lei s_str)            //比较函数  //返回值:s大于s_str:1;等于:0;小于:-1;  
    {
        int m=0;
        for(int i=0;i<=s.length;i++)
        {
            if(s.data[i]>s_str.data[i])//s>s_str
            {
                m=1;
                break;
            }
            if(s.data[i]<s_str.data[i])//s<s_str
            {
                m=-1;
                break;
            }
        }
        return m;
    }
    int strlen(lei s)                      //求串长度  //返回串长
    {
        return(s.length);
    }
    lei strcat(lei s,lei s_str)            //串连接函数  //将s和s_str链接成一个串
    {
        lei ss;
        for(int i=0;i<s.length;i++)
        {
            ss.data[i]=s.data[i];
        }
        for(int j=0;j<s_str.length;j++,i++)
        {
            ss.data[i]=s_str.data[j];
        }
        ss.length=i;
        return ss;
    }
    lei substr(lei s,int i,int j)          //求子串
    {
        lei ss;
        ss.length=0;//设置ss串为空
        if(i<0||i>s.length||j<0||i+j-1>s.length)//参数不正确时返回空串
            return ss;
        for(int k=i-1;k<i+j-1;k++)
        {
            ss.data[k-i+1]=s.data[k];
        }
        ss.length=j;//设置串长度
        return ss;
    }
    lei InsStr(lei s,int i,lei s_str)      //子串的插入 
    {
        lei ss;
        ss.length=0;
        if(i<0||i>s.length)//参数不正确则返回空串
            return ss;
        for(int j=0;j<i-1;j++)
        {
            ss.data[j]=s.data[j];
        }
        for(j=0;j<s_str.length;j++)
        {
            ss.data[i+j-1]=s_str.data[j];
        }
        for(j=i-1;j<s.length;j++)
        {
            ss.data[s_str.length+j]=s.data[j];
        }
        ss.length=s.length+s_str.length;
        return ss;
    }
    lei Delstr(lei s,int i,int j)          //子串的删除
    {
        lei ss;
        ss.length=0;
        if(i<=0||i>s.length||i+j-1>s.length)
            return ss;
        for(int k=0;k<i-1;k++)
        {
            ss.data[k]=s.data[k];
        }
        for(k=i+j-1;k<s.length;k++)//因为要小于s.length,所以可j的值可以超限
        {
             ss.data[k-j]=s.data[k];
        }
        ss.length=s.length-j;
        return ss;
    }
    lei repstr(lei s,int i,int j,lei s_str)//子串的替换
    {
        lei ss;
        int k;
        ss.length=0;
        if(i<0||i>s.length||i+j-1>s.length)
            return ss;
        for(k=0;k<i-1;k++)
        {
            ss.data[k]=s.data[k];
        }
        for(k=0;k<s_str.length;k++)
        {
            ss.data[i-1+k]=s_str.data[k];
        }
        for(k=i+j-1;k<s.length;k++)
        {
            ss.data[s_str.length+k-j]=s.data[k];
        }
        ss.length=s.length+s_str.length-j;
        return ss;
    }
    void print(lei s)                      //输出串
    {
        if(s.length>0)
        {
            for(int i=0;i<s.length;i++)
            {
                printf("%c",s.data[i]);
            }
            printf("\n");
        }
    }

    代码示例

    int main()
    {
        lei s,s_str;
        char str[]="123456789";
        StrAssign(s,str);
        printf("初始化串:\n");
        print(s);
        strcpy(s_str,s);
        printf("\n将串s复制给串s_str:\ns_str=");
        print(s_str);
        printf("\n求串s的长度:\n%d\n",strlen(s));
        printf("比较串s、s_str的大小:\n%d\n\n",strcmp(s,s_str));
        printf("链接串s、s_str:\n");
        print(strcat(s,s_str));
        printf("\n求串s第三个字符开始长度为四的子串:\n");
        print(substr(s,3,4));
        printf("\n将串s_str插入到s的第三个字符的位置:\n");
        print(InsStr(s,3,s_str));
        printf("\n删除串s第三个字符开始长度为四的子串:\n");
        print(Delstr(s,3,4));
        printf("\n将s第二个字符开始长度为5的子串替换成s_str:\n\n");
        print(repstr(s,2,5,s_str));
        Dwatorystr(s);
        printf("串已销毁\n");
        return 0;
    }

    输出如下

    展开全文
  • 串长:串中所含字符的字数称为该串的长度 空串:含零个字符组成的串称为空串 子串:一个串中任意个连续字符组成的序列称为该串的子串,空串是任何串的子串 主串:包含子串的串相应的成为主串 顺序串的基本操作 #...

    串的基本概念

    是由零个或者多个字符组成的有序的序列
    串长:串中所含字符的字数称为该串的长度
    空串:含零个字符组成的串称为空串
    子串:一个串中任意个连续字符组成的序列称为该串的子串,空串是任何串的子串
    主串:包含子串的串相应的成为主串
    Brute-Force算法:
    算法的实现使具有暴力的性质,模式串和主串同时从第一个位置开始进行判断,若对应位置字符相等则继续向后判断,若不相
    等,则模式串回到串首,主串字符位置指针回退,重新匹配。

    // B-F算法 时间复杂度O(n*m) 
    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);
    } 
    

    KMP算法:
    此算法可以在O(m+n)的数量级上完成串的匹配操作。其改进在于,每一趟匹配过程中出现字符比较不相等的时候,不需要回
    退指针i,而是利用已经匹配到的部分结果将模式串向右滑动尽可能远的距离,继续匹配。

    void GetNext(SqString s,int next[]){ //由模式串s求出next数组 
    	int j,k;
    	j=0;k=-1;               //扫描t,k,记录t[j]之前与t开头相同的字符个数 
    	next[0]=-1;				//设置next[0]的值 
    	while(j<s.length-1){     //求t所有位置的next值 
    		if(k==-1||s.data[j]==s.data[k]){  //k为-1或比较的字符相等时 
    			j++;k++;    //j,k依次移动到下一个字符 
    			next[j]=k;
    		}
    		else
    		k=next[k];    //k回退 
    	}
    	
    }
    int KMPIndex(SqString s,SqString t){
    	int next[MAXSIZE],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);
    }
    

    顺序串的基本操作

    #include<iostream>
    #include<stdio.h>
    using namespace std;
    
    #define MAXSIZE 100
    
    //进行类型的声明; 
    typedef struct{
    	char data[MAXSIZE];//存放串的字符 
    	int length;        //存放串的长度 
    }SqString;              //串的类型 
    
    //生成串
    void StrAssgin(SqString &s,char cstr[]){  //s为引用类型的参数 
    	int i;
    	for(i=0;cstr[i]!='\0';i++){
    		s.data[i]=cstr[i];   //字符串常量cstr赋给串 
    	}
    	s.length=i; //设置串的长度 
    } 
    
    //销毁串,由于不是顺序串指针,由操作系统管理,有操作系统分配存储空间
    //在超出作用域时释放存储空间,所以这里销毁顺序串不包含任何的操作; 
    void DestroyStr(SqString &s){
    	
    } 
    
    //串的复制,将顺序串t复制给顺序串s; 
    void StrCopy(SqString &s,SqString t){
    	int i;
    	for(i=0;i<t.length;i++) {
    		s.data[i]=t.data[i];  //复制t的所有的字符 
    	}
    	s.length=t.length;//设置串s的长度 
    } 
    
    //判断两个串是不是相等 
    bool StrEquel(SqString t,SqString s){
    	bool flag=true;    			//设置标志位 
    	int i;
    	if(t.length!=s.length){    //判断两个串的长度是否相等 
    		flag=false;
    	} 
    	else{
    			for(i=0;i<s.length;i++)
    			{
    				if(s.data[i]!=t.data[i])  //串中的数据有一个不符合条件的就返回假; 
    				{
    					flag=false;
    					break;
    				}
    			}
    		}
    	return flag;
    } 
    
    //求串的长度
    int StrLength(SqString s){
    	return s.length;  //直接返回串的长度 
    }
    
    //串的连接,将s和t串进行连接形成结果串 
    SqString Concat(SqString s,SqString t){
    	SqString str; //存放结果串
    	int i;
    	str.length=t.length+s.length;  //结果串的容量 
    	for(i=0;i<s.length;i++){
    		str.data[i]=s.data[i];   //将s串复制到str中 
    	}
    	for(i=0;i<t.length;i++){
    		str.data[s.length+i]=t.data[i];  //将t串复制到str中 
    	}
    	return str;
    } 
    
    //求子串 从第i个元素开始j个连续的字符;
    SqString SubStr(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];//将连续j个字符复制到结果串; 
    	}
    	str.length=j;
    	return str;  
    } 
    
    //子串的插入 在子串s的第i个位置插入子串t 
    SqString InsStr(SqString s,int i,SqString t){
    	int j; 
    	SqString str;//存放结果串
    	str.length=0; //设置子串为空
    	if(i<0||i>s.length+1){
    		return str;  //参数不正确返回空串 
    	}
    	for(j=0;j<i-1;j++){
    		str.data[j]=s.data[i];  //将串s的前i个元素复制给结果串 
    	} 
    	for(j=0;j<t.length;j++){
    		str.data[i+j-1]=t.data[j];  //在结果串str的i位置插入子串t 
    	}
    	for(j=i-1;j<s.length;j++){
    		str.data[j+t.length]=s.data[j]; //将串s的i后面的元素复制给结果串str; 
    	}	
    	str.length=s.length+t.length;    
    	return str;
    } 
    
    //删除子串 在串s中的第i个位置开始删除长度为j的子串
    SqString DelStr(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++){          //第i个元素的串下标为i-1; 
    		str.data[k]=s.data[k];  //将串[0..i-2]复制到结果串中 
    	} 							//从i-1个元素开始删除,总共删i-1+j; 
    	for(k=i+j-1;k<s.length;k++){
    		str.data[k]=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]; //将s串中的第i个元素前的元素复制给结果串str 
    	} 
    	for(k=0;k<t.length;k++){
    		str.data[i+k-1]=t.data[k]; //将t串的元素复制给结果串 
    	}
    	for(k=i+j-1;k<s.length;k++){
    		str.data[t.length+k-j]=s.data[k]; //将s串中剩余的元素给结果串 
    	}
    	str.length=s.length;
    } 
    
    //输出串s
    void DispStr(SqString s){
    	int i;
    	if(s.length>0){
    		for(i=0;i<s.length;i++){
    			cout<<s.data[i]<<endl;
    		}
    	}
    } 
    
    //比较两个串的大小
    int Strcmp(SqString s,SqString t){
    	int i,comlen;
    	if(s.length<t.length) 
    	comlen=s.length;
    	else 
    	comlen=t.length; //求两个串的共同长度;
    	for(i=0;i<comlen;i++){   
    		 if(s.data[i]>t.data[i]){  //串s大于串t返回1 
    		 return 1;	 
    		 }
    		 else if(s.data[i]<t.data[i]) //串s小于串返回-1 
    		 {
    		 	return -1;
    		 }
    	} 
    	if(s.length=t.length){   //若是共同长度都相等,返回0; 
    		return 0;
    	}
    	else if(s.length>t.length){ //s串长返回1 
    		return 1;
    	}
    	else
    	 return -1;              //t串长返回-1; 
    }
     
    
    //求s串中出现的第一个最长的连续的相同字符构成的平台
    void LongesString(SqString s,int &index ,int &maxlen){
    	int length,i=1,start; //length保存局部的平台的长度
    	index =0,maxlen=1;
    	while (i<s.length){
    		start=i-1;  //start代表最长相同字符的起始位置 
    		length=1;  //length代表相同字符的长度 
    		 while(i<s.length&&s.data[i]==s.data[i-1]){
    		 	i++;
    		 	length++;
    		 }
    		 if(maxlen<length){
    		 	index=start;   
    		 	maxlen=length;
    		 } 
    		 i++;
    	} 
    } 
    
    int main(){
        SqString s;
        char b[11]="asdasdasaa";
    	StrAssgin(s,b);
    	DispStr(s);
    	system("pause");
    	return 0;
    } 
    

    链串的基本操作:

    #include<iostream>
    #include<malloc.h> 
    using namespace std;
    
    #define MAXSIZE 100
    
    //链串节点类型LinkStrNode的声明 
    typedef struct snode{
    	char data;
    	struct snode *next;
    }LinkStrNode;
    
    //生成串
    void StrAssign(LinkStrNode *&s,char sctr[]){
    	int i;
    	LinkStrNode *p,*r;
    	s=(LinkStrNode *)malloc(sizeof(LinkStrNode));  
    	r=s;   //r始终指向尾节点
    	for (i=0;sctr[i]!='\0';i++){  //采用尾插法建立链表 
    		p=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		p->data=sctr[i];  //数据拷贝 
    		r->next=p;        //r->next指向p 
    		r=p;			  //r=p->next 
    	} 
    	r->next=NULL;
    	
    } 
    
    //销毁串
    void DestroyStr(LinkStrNode *&s){
    	LinkStrNode *pre=s,*p=s->next;
    	  while(p!=NULL){  //扫描链表 
    	  	free(pre);  //释放pre节点 
    	  	pre=p;    //pre,p节点后移 
    	  	p=p->next;
    	  } 	  
    	  free(pre);	
    } 
    //串的复制  把串t复制给串s 
    void StrCopy(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 StrEqual(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(p==NULL&&q==NULL){
    		return true;
    	}
    	else 
    	  return false;
    } 
    
    //求串的长度
    int StrLength(LinkStrNode *s){
    	LinkStrNode *p=s->next;
    	int i=0;
    	while(p!=NULL){
    		p=p->next;
    		i++;
    	}
    	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 *SubStr(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>StrLength(s)||j<0||i+j-1>StrLength(s)){
    		return str; //输入不合法返回一个空串 
    	} 
    	for(k=1;k<i;k++){  //让p沿着next跳i-1个节点 
    		p=p->next; 
    	} 
    	for(k=1;k<=j;k++){ //将子串拷贝进str目标串中 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;
    		r=q;
    		p=p->next; 
    	}
    	r->next=NULL; //将尾节点置为空 
    	return str;
    }
    
    //子串的插入
    LinkStrNode *InsStr(LinkStrNode *s,int i,LinkStrNode *t){
    	LinkStrNode *str,*p=s->next,*q,*r,*p1=t->next;
    	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    	str->next=NULL;
    	r=str;
    	int k;
    	if(i<0||i>StrLength(s)+1){
    		return str; //参数不对返回空串; 
    	}
    	for(k=1;k<i;k++){ //将前i-1个节点拷贝进str中 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;
    		r=q;
    		p=p->next;
    	} 
    	while(p1!=NULL){ //将串t插入进去 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p1->data;
    		r->next=q;
    		r=q;
    		p1=p1->next;
    	}
    	while(p!=NULL){ //将s剩余的节点拷贝进str中 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;
    		r=q;
    		p=p->next;
    	}
    	r->next=NULL;  //尾节点置空 
    	return str;
    } 
    
    //子串的删除
    LinkStrNode *DelStr(LinkStrNode *s,int i,int j){
    	LinkStrNode *str,*p=s->next,*q,*r;
    	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    	str->next=NULL;  //置结果串str为空串 
    	r=str;
    	int k;
    	if(i<0||i>StrLength(s)+1||j<0||i+j-1>StrLength(s)){
    		return str; //参数不对返回空串; 
    	}
    	for(k=1;k<i;k++){   //将s的前i-1个节点复制到str中 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;
    		r=q;
    		p=p->next;
    	} 
    	for(k=1;k<=j;k++){ //让p沿next跳j个节点 
    		p=p->next;
    	}
    	
    	while(p!=NULL){ //将s剩下的节点拷贝进str中 
    		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){
    	LinkStrNode *str,*p=s->next,*q,*r,*p1=t->next;
    	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    	str->next=NULL;
    	r=str;
    	int k;
    	if(i<0||i>StrLength(s)+1||j<0||i+j-1>StrLength(s)){
    		return str; //参数不对返回空串; 
    	}
    	for(k=1;k<i;k++){  //将子串的前i-1个结点拷贝到结果链表 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;
    		r=q;
    		p=p->next;
    	}
    	for(k=0;k<j;k++){  //让p沿next调j个节点 
    		p=p->next;
    	} 
    	while(p1!=NULL){   //将串t所有的加点拷贝到str上 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p1->data;
    		r->next=q;
    		r=q;
    		p1=p1->next;
    	}
    	while(p!=NULL){   //将串s剩下的节点拷贝到str上 
    		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;
    		r=q;
    		p=p->next;				
    	}
    	r->next=NULL;		//尾节点置空 
    	return str;
    } 
     
    //输出串
    void DispStr(LinkStrNode *s){
    	LinkStrNode *p=s->next;  //p指向s的首节点 
    	while(p!=NULL){         //扫描s中所有的节点 
    		cout<<p->data;     //输出节点p 
    		p=p->next; 
    	}
    	cout<<endl;
    } 
    
    //设计一个算法把串s中最先出现的子串cd改为xyz
    void Repl(LinkStrNode *&s){
    	LinkStrNode *p=s->next,*q;
    	bool find=false;      //设置标志位  
    	while(p!=NULL&&p->next!=NULL&&!find){
    		if(p->data=='c'&&p->next->data=='d'){  //查找串中第一次出现连续的cd 
    			p->data='x';
    			p->next->data='z';             //把cd改为xz 
    			q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    			q->data='y';                 //在xz中间插入y 
    			q->next=p->next;
    			p->next=q;
    			find=true;
    		} 
    		else
    		    p=p->next;   //尚未找到时继续查找 
    	}
    } 
    
    int main(){
    	LinkStrNode *s;
    	char sctr[10]="asdasdada";
    	StrAssign(s,sctr);
    	DispStr(s); 
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 字符串的基本概念 串的基本概念:串(字符串的简称)是由零个或多个字符组成的有限序列。...- 串中所含字符的个数成为该串的长度(或串长) - 含零个字符的串(即:"")称为空串,用Ф表示,空串不包含任何字符。

    字符串的基本概念

    串的基本概念:串(字符串的简称)是由零个或多个字符组成的有限序列。字符可以是数字、字母、下划线。字符串是编程语言中表示文本的数据类型。

    • 串中所含字符的个数成为该串的长度(或串长)

    • 含零个字符的串(即:"")称为空串,用Ф表示,空串不包含任何字符。

    • 串的逻辑表示:“a1a2…an”,双引号不是串的内容,起标识作用,ai(1≤i≤n)代表一个字符。

    • 串相等:两个串的长度相等并且各个对应位置上的字符都相同时。如:“abcd” ≠ “abc”、“abcd” ≠ “abcde”、“abc” = “abc”,所有空串是相等的。

    • 子串:一个串中任意个连续字符组成的子序列(含空串)称为该串的子串。
      例如, “abcde”的子串有:
         “”、“a”、“ab” 、“abc”、“abcd”和“abcde”等
      真子串是指不包含自身的所有子串。

    串抽象数据类型=逻辑结构+基本运算(运算描述),通常以串的整体作为操作对象,如:在串中查找某个子串、求取一个子串、在串的某个位置上插入一个子串以及删除一个子串等。串的基本运算如下:

    • StrAssign(&s,cstr):将字符串常量cstr赋给串s,即生成其值等于cstr的串s。
    • StrCopy(&s,t):串复制。将串t赋给串s。
    • StrEqual(s,t):判串相等。若两个串s与t相等则返回真;否则返回假。
    • StrLength(s):求串长。返回串s中字符个数。
    • Concat(s,t):串连接:返回由两个串s和t连接在一起形成的新串。
    • SubStr(s,i,j):求子串。返回串s中从第i(1≤i≤n)个字符开始的、由连续j个字符组成的子串。
    • InsStr(s1,i,s2):插入。将串s2插入到串s1的第i(1≤i≤n+1)个字符中,即将s2的第一个字符作为s1的第i个字符,并返回产生的新串。
    • DelStr(s,i,j):删除。从串s中删去从第i(1≤i≤n)个字符开始的长度为j的子串,并返回产生的新串。
    • RepStr(s,i,j,t):替换。在串s中,将第i(1≤i≤n)个字符开始的j个字符构成的子串用串t替换,并返回产生的新串。
    • DispStr(s):串输出。输出串s的所有元素值。

    字符串的存储结构

    串的两种最基本的存储方式是顺序存储方式和链接存储方式。

    顺序存储

    串的顺序存储(顺序串)有两种方法:

    • 每个单元(如4个字节)只存一个字符,称为非紧缩格式(其存储密度小)。
    • 每个单元存放多个字符,称为紧缩格式(其存储密度大)。

    顺序串基本运算的算法

    #include <stdio.h>
    #define MaxSize 100
    typedef struct
    {	
    	char data[MaxSize];
    	int length;			//串长
    } SqString;
    void StrAssign(SqString &s,char cstr[])	//字符串常量赋给串s
    {
    	int i;
    	for (i=0;cstr[i]!='\0';i++)
    		s.data[i]=cstr[i];
    	s.length=i;
    }
    void DestroyStr(SqString &s)	//销毁串
    {  }
    
    void StrCopy(SqString &s,SqString t)	//串复制
    {
    	int i;
    	for (i=0;i<t.length;i++)
    		s.data[i]=t.data[i];
    	s.length=t.length;
    }
    bool StrEqual(SqString s,SqString t)	//判断串相等
    {
    	bool same=true;
    	int i;
    	if (s.length!=t.length)				//长度不相等时返回0
    		same=false;
    	else 
    		for (i=0;i<s.length;i++)
    			if (s.data[i]!=t.data[i])	//有一个对应字符不相同时返回0
    			{	same=false;
    				break;
    			}
    	return same;
    }
    int StrLength(SqString s)	//求串长
    {
    	return s.length;
    }
    SqString Concat(SqString s,SqString t)	//串连接
    {
    	SqString str;
    	int i;
    	str.length=s.length+t.length;
    	for (i=0;i<s.length;i++)	//将s.data[0..s.length-1]复制到str
    		str.data[i]=s.data[i];
    	for (i=0;i<t.length;i++)	//将t.data[0..t.length-1]复制到str
    		str.data[s.length+i]=t.data[i];
    	return str;
    }
    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++)  		//将s.data[i..i+j]复制到str
    		str.data[k-i+1]=s.data[k];
    	str.length=j;
    	return str;
    } 
    SqString InsStr(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;
    }
    SqString DelStr(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++)       		//将s.data[0..i-2]复制到str
    		str.data[k]=s.data[k];
    	for (k=i+j-1;k<s.length;k++)	//将s.data[i+j-1..s.length-1]复制到str
    		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-1>s.length) //参数不正确时返回空串
    		return str;
    	for (k=0;k<i-1;k++)				//将s.data[0..i-2]复制到str
    		str.data[k]=s.data[k];
    	for (k=0;k<t.length;k++)   		//将t.data[0..t.length-1]复制到str
    		str.data[i+k-1]=t.data[k];
    	for (k=i+j-1;k<s.length;k++)	//将s.data[i+j-1..s.length-1]复制到str
    		str.data[t.length+k-j]=s.data[k];
    	str.length=s.length-j+t.length;
    	return str;
    }
    void DispStr(SqString s)	//输出串s
    {
    	int i;
    	if (s.length>0)
    	{	for (i=0;i<s.length;i++)
    			printf("%c",s.data[i]);
    		printf("\n");
    	}
    }
    

    链式存储

    链串的组织形式与一般的链表类似。链串中的一个结点可以存储多个字符。通常将链串中每个结点所存储的字符个数称为结点大小。

    链串基本运算的算法:

    #include <stdio.h>
    #include <malloc.h>
    typedef struct snode 
    {	
    	char data;
    	struct snode *next;
    } LinkStrNode;
    void StrAssign(LinkStrNode *&s,char cstr[])	//字符串常量cstr赋给串s
    {
    	int i;
    	LinkStrNode *r,*p;
    	s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    	r=s;						//r始终指向尾结点
    	for (i=0;cstr[i]!='\0';i++) 
    	{	p=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		p->data=cstr[i];
    		r->next=p;r=p;
    	}
    	r->next=NULL;
    }
    void DestroyStr(LinkStrNode *&s)
    {	LinkStrNode *pre=s,*p=s->next;	//pre指向结点p的前驱结点
    	while (p!=NULL)					//扫描链串s
    	{	free(pre);					//释放pre结点
    		pre=p;						//pre、p同步后移一个结点
    		p=pre->next;
    	}
    	free(pre);						//循环结束时,p为NULL,pre指向尾结点,释放它
    }
    void StrCopy(LinkStrNode *&s,LinkStrNode *t)	//串t复制给串s
    {
    	LinkStrNode *p=t->next,*q,*r;
    	s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    	r=s;						//r始终指向尾结点
    	while (p!=NULL)				//将t的所有结点复制到s
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;r=q;
    		p=p->next;
    	}
    	r->next=NULL;
    }
    bool StrEqual(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 (p==NULL && q==NULL)
    		return true;
    	else
    		return false;
    }
    int StrLength(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;						//r指向结果串的尾结点
    	while (p!=NULL)				//用p扫描s的所有数据结点
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;		//将p结点复制到q结点中
    		r->next=q;r=q;			//将p结点复制到q结点中
    		p=p->next;
    	}
    	p=t->next;
    	while (p!=NULL)				//用p扫描t的所有数据结点
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;		//将p结点复制到q结点中
    		r->next=q;r=q;			//将q结点链接到str的末尾
    		p=p->next;
    	}
    	r->next=NULL;				//尾结点的next域置为空
    	return str;
    }
    LinkStrNode *SubStr(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;						//r指向新建链表的尾结点
    	if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
    		return str;				//参数不正确时返回空串
    	for (k=0;k<i-1;k++)
    		p=p->next;
    	for (k=1;k<=j;k++) 			//将s的第i个结点开始的j个结点复制到str
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;r=q;
    		p=p->next;
    	}
    	r->next=NULL;
    	return str;
    }
    LinkStrNode *InsStr(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;								//r指向新建链表的尾结点
    	if (i<=0 || i>StrLength(s)+1)		//参数不正确时返回空串
    		return str;
    	for (k=1;k<i;k++)					//将s的前i个结点复制到str
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;r=q;
    		p=p->next;
    	}
    	while (p1!=NULL)					//将t的所有结点复制到str
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p1->data;
    		r->next=q;r=q;
    		p1=p1->next;
    	}
    	while (p!=NULL)						//将结点p及其后的结点复制到str
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;r=q;
    		p=p->next;
    	}
    	r->next=NULL;
    	return str;
    }
    LinkStrNode *DelStr(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;						//r指向新建链表的尾结点
    	if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
    		return str;				//参数不正确时返回空串
    	for (k=0;k<i-1;k++)			//将s的前i-1个结点复制到str
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p->data;
    		r->next=q;r=q;
    		p=p->next;
    	}
    	for (k=0;k<j;k++)				//让p沿next跳j个结点
    		p=p->next;
    	while (p!=NULL)					//将结点p及其后的结点复制到str
    	{	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;							//r指向新建链表的尾结点
    	if (i<=0 || i>StrLength(s) || j<0 || i+j-1>StrLength(s))
    		return str;		 			//参数不正确时返回空串
    	for (k=0;k<i-1;k++)  			//将s的前i-1个结点复制到str
    	{	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沿next跳j个结点
    		p=p->next;
    	while (p1!=NULL)				//将t的所有结点复制到str
    	{	q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
    		q->data=p1->data;q->next=NULL;
    		r->next=q;r=q;
    		p1=p1->next;
    	}
    	while (p!=NULL)					//将结点p及其后的结点复制到str
    	{	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");
    }
    

    字符串的模式匹配

    设s、t是两个串,求s在t中首次出现的位置的运算叫做模式匹配。
    成功是指在目标串s中找到一个模式串t->t是s的子串,返回t在s中的位置。
    不成功则指目标串s中不存在模式串t->t不是s的子串,返回-1。

    Brute-Force算法

    Brute-Force简称为BF算法,亦称简单匹配算法。采用穷举的思路。BF是指暴力的意思!
    例如,s=“aaaabcd”,t=“abc”。
    在这里插入图片描述

    BF算法思路:从s的每一个字符开始依次与t的字符进行匹配。

    1. i,j分别扫描字符串s和t
    2. i从0到s.length-t.length循环。
    3. 对于每个s[i],k=i,j=0开始比较
    4. 如果t扫描完毕,则返回i
    5. 若s全部比较完毕都没有返回,则返回-1

    算法代码实现:

    int index(SqString s,SqString t)
    {  
        int i,j,k;
        for (i=0;i<=s.length-t.length;i++) 
        {  
            for (k=i,j=0; k<s.length && j<t.length && 
                s.data[k]==t.data[j]; k++,j++);
            if (j==t.length)
    	        return(i);
        }
        return(-1);
    }
    

    实际上,可以只采用两个变量i、j,通过i回退实现:
    在这里插入图片描述

    对应的BF算法如下:

    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)		//或者if (j==t.length)
            return(i-t.length);	//返回匹配的第一个字符的下标
        else
            return(-1);		//模式匹配不成功
    }
    

    BF算法分析

    • 算法在字符比较不相等,需要回溯(即i=i-j+1):即退到s中的下一个字符开始进行继续匹配。
    • 最好情况下的时间复杂度为O(m)。
    • 最坏情况下的时间复杂度为O(n×m)。
    • 平均的时间复杂度为O(n×m)。

    KMP算法

    KMP算法是D.E.Knuth、J.H.Morris和V.R.Pratt共同提出的,简称KMP算法。

    该算法较BF算法有较大改进,主要是消除了主串指针的回溯,从而使算法效率有了某种程度的提高。

    KMP算法的思路:

    • 基于BF算法,采用空间换时间的方式,提取保存有利于匹配的信息。
    • 提取s还是t中的信息?每次从s不同字符开始匹配,而t总是从t0开始匹配 ->提取t中的信息
    • t中的什么信息-> 部分匹配信息。

    KMP算法用next数组保存部分匹配信息
    KMP算法:

    void GetNext(SqString t,int next[])		//由模式串t求出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]) 	//k为-1或比较的字符相等时
    		{	
    			j++;k++;
    			next[j]=k;
           	}
           	else
    		{
    			k=next[k];
    		}
    	}
    }
    int KMPIndex(SqString s,SqString t)  //KMP算法
    {
    	int next[MaxSize],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++;  			//i,j各增1
    		}
    		else j=next[j]; 		//i不变,j后退
        }
        if (j>=t.length)
    		return(i-t.length);  	//返回匹配模式串的首字符下标
        else  
    		return(-1);        		//返回不匹配标志
    }
    

    KMP算法分析:

    • 设串s的长度为n,串t长度为m。
    • KMP算法中求next数组的时间复杂度为O(m),在后面的匹配中因主串s的下标不减即不回溯,比较次数可记为n,所以KMP算法平均时间复杂度为O(n+m)。
    • 最坏的时间复杂度为O(n×m)。
    展开全文
  • 算法目的:确定主串中所含子串第一次出现的位置,这里的子串也称为模式串。 设计思想: (1)主串和模式串逐个字符进行比较 (2)当出现字符不匹配(失配)时,主串的比较位置重置为起始位置的...

    一、BF算法原理

    BF算法是一种蛮力算法,其实现过程没有任何技巧,就是简单粗暴地拿一个串同另一个串中的字符一一比对,得到最终结果。

    算法目的:确定主串中所含子串第一次出现的位置,这里的子串也称为模式串。

    设计思想:

    (1)主串和模式串逐个字符进行比较

    (2)当出现字符不匹配(失配)时,主串的比较位置重置为起始位置的下一个字符位置,模式串的比较位置重置为起始字符

    回溯关系的确定:i = i - j + 1; //主串指针回溯到比较起始位置的下一个字符位置
    关键字:循环比较

    第一次回溯
    因为i=j=0都是从0开始,因此逐一比较时下标相等。回溯下标需要使i=1


    第二轮回溯经过第一次回溯,i的下标比j的下标大1,因此进行i=i-j+1=2,i指针又往前挪移一位

    因此i-j是保留之前累积的i>j的差值,然后+1,利用循环便可以继续累加,达到指针不断向前移,回溯到比较起始位置的下一个字符位置的效果。

    (3)匹配成功返回主串中匹配串的起始位置,否则返回错误代码

    简单理解返回位置,此时i=5为结束匹配时主串指针所指下标,j=3,为子串最后位置元素下标即子串长度,+1便表示位置而不是下标。

    二、时间复杂度

    设主串长度为m,子串长度为n
    该算法最理想的时间复杂度 O(n),n 表示子串的长度,即第一次匹配就成功。

    BF 算法最坏情况的时间复杂度为 O(n×m),即两个串每次匹配,都必须匹配至子串的最末尾才能判断匹配失败,因此运行了 n×m 次字。

    在对数据量大的串进行模式匹配时,算法的效率很低。因此BF 算法还可以改进,就是 KMP 算法,下次再写文章解释。

    三、C++实现代码

    int BF(const char* S, const char* T) 
    {
    	int i = 0, // i主串的起始下标
    		j = 0; // j子串的起始下标
    	while (i < strlen(S) && j < strlen(T)) 
    	{
    		if (S[i] == T[j]) 
    		{
    			i++;
    			j++;
    		}
    		else 
    		{
    			i = i - j + 1;	//主串指针回溯到比较起始位置的下一个字符位置
    			j = 0;			//子串回到起始字符
    		}
    	}
    
    	//j=strlen(T),说明子串遍历完成,在主串中成功匹配
    	if (j == strlen(T)) 
    	{
    		return i - strlen(T) + 1;
    	}
    	//跳过if运行到此,为i==strlen(B)的情况,说明已经遍历完主串,匹配失败
    	return -1;
    }
    
    int main()
    {
    	int number = BF("aaaaabcaaaacac", "aaaac");
    	cout << number;
    	return 0;
    }
    

    如有不足之处,还望指正 1


    1. 如果对您有帮助可以点赞、收藏、关注,将会是我最大的动力 ↩︎

    展开全文
  • 数据结构---(结构体实现)

    千次阅读 2018-10-14 11:25:23
    目录 顺序串及其基本运算的...串中所含字符的个数称为该串的长度。一般情况下,英文字母、数字和常用的变电符号以及空格符都是合法的字符。 两个串相等当且仅当它们的长度相等并且各对应位置上的字符都相同。 ...
  • 输入文件含有待格式化(或成为待排版)的文本,它由多行文字组成,例如一篇英文文章。... 脚长(Footing Length)——每页页底空行数(页号行) . 起始页号(Starting Page Number)——首页的页号。
  • 当输入字符串中包含空格、回车或者跳格字符时,空格、回车和跳格将被认为是2个字符串之间的分隔,因此用这种方法输入的字符串中不可能包含空格、回车和跳格字符的。 3:当需要以行为单位,输入一行一行的字符串,...
  • 任何计算机、操作系统和编译器。书的范例在Windows XP系统、Macintosh OS X系统和Linux系统上进行 了测试。只有为数不多的几个程序会受编译器不兼容问题的影响。本书前一版面世后,编译器在遵循C++标 准方面更...
  • 任何计算机、操作系统和编译器。书的范例在Windows XP系统、Macintosh OS X系统和Linux系统上进行 了测试。只有为数不多的几个程序会受编译器不兼容问题的影响。本书前一版面世后,编译器在遵循C++标 准方面更...
  • 任何计算机、操作系统和编译器。书的范例在Windows XP系统、Macintosh OS X系统和Linux系统上进行 了测试。只有为数不多的几个程序会受编译器不兼容问题的影响。本书前一版面世后,编译器在遵循C++标 准方面更...
  • 任何计算机、操作系统和编译器。书的范例在Windows XP系统、Macintosh OS X系统和Linux系统上进行 了测试。只有为数不多的几个程序会受编译器不兼容问题的影响。本书前一版面世后,编译器在遵循C++标 准方面更...
  • 说明:Oracle需要创建用户一定是要具有dba(数据库管理员)权限的用户才能创建,而且创建的新用户不具备任何权限,连登录都不可以。 用法:create user 新用户名 identified by 密码 例子: 2. 修改密码 说明:...
  • 请补充函数fun(),该函数的功能是:把从主函数输入的字符str2接在字符str1的后面。 例如:str1=“How do”,...请勿改动主函数main和其他函数任何内容,仅在函数fun的横线上填入编写的若干表达式或语句。
  • 随机电压产生器设计: 1、用一个单片机和DA转换组成一个随机电压...4、如果提示缺少MSCOMM32.OCX,可将文件夹中所带的MSCOMM32.OCX复制粘帖到c:\windows\system32\下即可(不会对您的系统造成任何危害)。 附件内容截图:
  • 它的精髓在于,通过已翻开格子提示的周围格地雷数,来判断未翻开格子里是否是地雷。 现在给出n行m列的雷区的地雷分布,要求计算出每个非地雷格的周围格地雷数。 注:每个格子周围格有八个:上、下、左、右、...
  • VBSCRIPT中文手册

    热门讨论 2010-11-12 10:13:06
    Len 函数 返回字符串中的字符数量,或者存储变量需的字节数。 Length 属性 返回在搜索字符串中匹配的长度。 LoadPicture 函数 返回图片对象。仅用于 32 位平台。 Log 函数 返回数的自然对数。 LTrim 函数 返回...
  • ExecuteGlobal 语句 执行一个或多个在全局脚本名字空间中所指定的语句。 Exit 语句 退出 Do...Loop、For...Next、 Function 或 Sub 代码块。 Exp 函数 返回 e (自然对数的底)的多少次方。 自乘运算符 (^) 指数...
  • System.out.printf() 可插入带 % 的输入类型,前两种只可以插入转义符, 不能插入 % 的数据或字符 在 printf 里面,输出有5个部分 %[argument_index$][flags][width][.precision]conversion 以“%”开头,[第几个...
  • 1005 0x000003ED 储存媒体未含任何可辨识的档案系统。 请确定以加载需的系统驱动程序,而且该储存媒体并未毁损。 1006 0x000003EE 储存该档案的外部媒体发出警告,表示该已开启档案已经无效。 1007 0x000003EF ...
  • C语言 琐碎知识点

    2021-03-17 21:02:34
    1 #include 的用法有两种,如下示: 使用尖括号< >和双引号" "的区别在于头文件的搜索路径不同: ...字符串中可以含任何字符,它可以是常数、表达式、if 语句、函数等,预处理程序对它不作任何检查,如有
  • 给定一个字符sss和一个模式ppp,ppp中含字母,'?'或者'*'。其中'?'可以匹配任何单个字符,'*'可以匹配任意字符,包括空串。问sss是否符合ppp代表的模式。 该题的思考方式与Regular Expression Matching这个...
  • 给定一个字符sss和一个模式ppp,ppp中含字母,'.'或者'*'。其中'.'可以匹配任何单个字符,'*'可以匹配其之前的字符重复000次或大于等于111次。问sss是否符合ppp代表的模式。 参考...
  • 给定一个字符sss和一个模式ppp,ppp中含字母,'.'或者'*'。其中'.'可以匹配任何单个字符,'*'可以匹配其之前的字符重复000次或大于等于111次。问sss是否符合ppp代表的模式。 思路是动态规划。设f[i][j]f[i][j]...
  • VBSCRIP5 -ASP用法详解

    2010-09-23 17:15:46
    ExecuteGlobal 语句 执行一个或多个在全局脚本名字空间中所指定的语句。 Exit 语句 退出 Do...Loop、For...Next、 Function 或 Sub 代码块。 Exp 函数 返回 e (自然对数的底)的多少次方。 自乘运算符 (^) 指数...
  • VBScript 语言参考

    2008-10-07 21:30:05
    ExecuteGlobal 语句 执行一个或多个在全局脚本名字空间中所指定的语句。 Exit 语句 退出 Do...Loop、For...Next、 Function 或 Sub 代码块。 Exp 函数 返回 e (自然对数的底)的多少次方。 自乘运算符 (^) 指数...
  • vb Script参考文档

    2009-07-28 22:13:02
    Len 函数 返回字符串中的字符数量,或者存储变量需的字节数。 Length 属性 返回在搜索字符串中匹配的长度。 LoadPicture 函数 返回图片对象。仅用于 32 位平台。 Log 函数 返回数的自然对数。 LTrim 函数 返回...
  • 转换为回文的步数

    2014-08-14 11:38:00
    任何给定的字符,他可以减少其中任何一个字符的值,例如'd'可以变成'c',这算是一次操作。(另外,他最多只能将字符的值减少至'a','a'不能再被减少成'z')。找出将给定字符转换成回文需的最少操作次数。 ...
  • 任何给定的字符,他可以减少其中任何一个字符的值,例如'd'可以变成'c',这算是一次操作。(另外,他最多只能将字符的值减少至'a','a'不能再被减少成'z')。找出将给定字符转换成回文需的最少操作次数。 ...
  • 一、基本概念 短语:在一个句型对应的语法树, 以某非终结符为根的一棵子树的所有叶子自左至右... 素短语:一个文法G的句型的素短语是指这样一个短语,它至少含有一个终结符,并且,除它自身之外不再含任何更小的...
  • 短语和直接短语的概念:一个句型的语法树任一子树叶结点组成的符号都是该句型的短语,当子树不包含其他更小的子树时,该子数叶结点组成的字符就是该句型的直接(简单)短语。 句柄的概念:一个句型的最...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 153
精华内容 61
关键字:

任何串中所含