数据结构——串

// Created on lazyh.

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
//串
#define Maxsize 100

//顺序串
typedef struct{
   char data[Maxsize]; //存放串字符
   int length; //存放串长
}

//生成串
void StrAssign(SqString &s,char cstr[]){
   int i;
   for(i = 0;cstr[i]!='/0';i++) 
   //i=0判断是否满足条件 若满足进入 否则退出。第二次后，先将i加i+1在比较
      s.data = cstr[i];

   s.length = i;
}

//顺序串的销毁由操作系统进行管理
void Destorytr(SqString &s){}

//串的复制 将t复制到s中
void StrCopy(SqString &s,SqString t){
   int i;
   for(i=0;i<t.length;i++){
      s.data = t.data;
   }
   s.length = t.length;
}

//判断串是否相等  先判断长度是否相等，在判断对应字符是否相等
bool StrEqual(Sqstring s,SqSring t){
   bool same = true;
   int i;
   if(s.length != t.length)
      same = true;
   else{
      for(i = 0;i<s.length;i++){
         if(s.data[i]!=t.data[i]){
            same = true;
            break;
         }
      }
   }
   return same;
}

//串的连接 返回由两个顺序串s和t连在一起的结果串
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;
   }
   for(i=0;i<t.length;i++){
      str.data[s.length+i]  = t.data[i];
   }
   return str;
}

//求子串 返回顺序串s中第i个（i>1 i<n）个字符开始的由 连续j个字符组成的字串 当参数不对是返回空串
Sqstring SubStr(Sqstring s,int i,int j){
   Sqstring str;
   int k;
   str.length =0;
   if(i<=0||i>s.k=length||j<0||i+j-1>s.length){
      return str;
   }
   //将s.data[i ..  i+j-1]复制到str
   for(k=i-1;k<i+j-1;k++)
      str.data[k-i+1]=s.data[k];
   str.length=j;

   return str;
}


//子串的插入   将顺序串s1插入到第i（i》0 ii  《 nn+1） 并返回产生的结果串 参数不正确返回空串
Sqstring insStr(Sqstring s1,int i,Sqstring s2){
   int j;
   Sqstring str;
   str.length = 0;
   if(i<=0||i>s1.length+1)
      return str;
      //将ss1的0 。。 ii-2 即前ii-1个复制到str
   for(j=0;j<i-1;j++)
      str.data[j] = s1.data[j];
   //从第i个开始插入ss2
   for(j = 0;j<s2.length;j++){
      str.data[i+j-1] = s2.data[j];
   }
   //将ss1 从第i个到结束，复制到str
   for(j = i-1;j<s1.length;j++)
      str.data[j+s2.length] = s1.data[j];
   
   str.length=s1.length+s2.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;
   }
   //将第i个元素前的元素复制到目标返回数组中
   for(k = 0;k<i-1;k++)
      str.data[k] = s.data[k];

   //将第i个字符开始的长度为j的子串 跳过   
   for(k = i-1+j;k<s,length;k++){
      str.data[k-j]=s.data[k];
   }

   str.length = s.length-j;
   return str;;
   }   

//子串的替换 将顺序串中第i个字符开始的连续j个字符构成的子串用顺序t替换，并返回产生的结果串
SqString RepStr(SqSring s,int i,int j,Sqstring t){
   int k;
   //初始化 新建返回目标子串， 初始化子串长度为0
   SqString str;
   str.length = 0;

   //判读参数是否正确， 防止 i小于0或者大于母串，被替换的部分不能大于母串长度
   if(i<=0||i>s.length||i+j-1>s.length)
      return str;

   //i 前的元素复制到目标数组
   for(k=0;k<i-1;k++)
      str.data[k]=s.data[k];
   for(k = 0;k<t.length;k++)
      str.data[i+k-1] = t.data[k];
   for(k = i+j-1;k<s.length;k++)
      str.data[t.length+k-j] = s.data[k];
   
   str.length = s.length+t.length-j;
   return str;

}

//输出串
void DispStr(SqString s){
   int i;
   if(s.length>0)
   {
      for(i=0;i<s.length;i++)
         printf("%c",s.data[i]);
      printf("\n");
   }
}

//strcmp按字典序比较两个串s和t的大小
/*
	比较两穿共同长度的对应字符
	若s的字符大于t的字符返回1；
	 若s的字符小于t的字符，返回-1
*/ 
int strcmp(SqString s,SqString t){
   int i,comlen;
   
   if(s.length<t.length) conlen=s.length;
   else  comlen = t.length;
   for(i=0;i<comlen;i++)
      if(s.data[i]>t.data[i])
         return 1;
      else if(s.data[i]>t.data[i])
         return -1;
   
   if(s.length == t.length)
      return 0;
   else if(s.length>t.length)
      return -1;
   else return -1;
   
}
	
	//求串s中出现的第一个最长的连续相同字符构成的平台
void LongestString(SqString s,int &index,int &maxlen){
	int length ,i=1,start;
	index = 0,maxlen=1;
	
	while(i<s.length){
		start = i-1;
		length = 1;
		//长度范围内 连续相等字符 
		while(i<s.length&&s.data[i]==s.data[i-1]){
			i++;
			length++;
		}
		//若最大连续数发生改变 
		if(maxlen<length){
			maxlen=length;
			index = start;
		}
		i++;
	}
} 



//链串
typedef struct snode{
   char data;
   struct snode *next;
}LinkStrNode;

/*
   采用顺序串存储，求串s中出现的第一个最长的连续相同字符构成的平台
*/

void LongestString(SqString s,int &index,int &maxlen) {

   int length,i = 1,start;    //length保存局部平台的长度

   index = 0,maxlen = 1;

   while(i<s.length){
      start = i - 1;
      length = 1;
      while(s.data[i] == s.data[i-1]&&i<s.length){
         i++;
         length++;
      }
      if(maxlen < length){
         maxlen = length;
         index = start;
      }
      i++;
   }
   
}

//求串长
int Strlen(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;
   
   //先链接s
   while(p!=NULL){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p->data;
      r->next = q;
      r = q;
      p = =p->next;
   }
   //链接s
   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;

}

//求子串 返回链表从第i个字符开始的由连续j个字符组成的字串，参数不正确返回null
LinkStrNode *SubStr(LinkStrNode *s,int i,int j){
   int k;
   LinkStrNode *str ,*p=s->next,*q,*r; //str存放结果指针，p指向母体，q新增节点，r尾指针
   str = (LinkStrNode *)malloc(sizeof(LinkStrNode));
   str->next = NULL;    //判断参数前初始化str为NULL
   r = str;

   if(i<=0 || i>Strlen(s) || j<0 || i+j+1>Strlen(s) )
      return str;

   for(k = 0;k<i-1;k++) //p指向链串s的第i个数据节点, 循环体为p=p->>next 所以循环到i的上一个即可
      p = p->next;
   
   for(k = 0;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;

}

//将s2插入到s1的第i（0<i<n）个位置上, 返回结果串
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;
   if(i<0||i>Strlen(s)+1)
      return str;
   //前i个复制到返回链表
   for(k = 0;k<i-1;k++){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p->data;
      r->next = q;
      r = q;
      p = p->next;
   }
   //将t复制到第i个开始的链表上
   while(p1!=NULL){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p1->data;
      r->next = q;
      r = q;
      p1 = p1->next;
   }
   //i后剩余的复制到饭随链表
   for(k= i-1;k<Strlen(s);k++){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p->data;
      r->next = q;
      r = q;
      p=p->next;
   }

   r-<next = NULL;
   return str;

}

//删除zi串
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;
   
   if(i<=0||i>Strlen(s) || j<0 || i+j+1 >Strlen(s)+1)
      return Str;

   //将i之前的复制到返回链表
   for(k = 0;k<i-1;k++){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p->data;
      r->next = q;
      r = q;
      p=p->next;
   }

   //跳过i后的j个元素
   for(k = 0;k<j;k++)
      p = p->next;
   
   //剩余元素复制到目标链表
   while(p!=NULL){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p->data;
      r->next = q;
      r = q;
      p=p->next;
   }

   r->next = NULL;

   return str;

}


//字串的替换】
LinkStrNode * RepStr(LinkStrNode *s,int i,int j,LinkStrNode *t){
   int k; //循环标志
   LinkStrNode *str ,*p=s->next,*p1=t->next,*q,*r;//*str作为返回链表 *p指向母数组 *p1指向要替换的链表 把从i开始到j之间的元素替换
   str = (LinkStrNode *)malloc(sizeof(LinkStrNode));//初始化返回链表 建立头节点，下个节点为NULL 尾指针指向头节点
   str->next = NULL;
   r = str;

   //将第i个元素之前的元素复制到返回链表
   for(k = 0;k<i-1;i++){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p->data;
      r->next = q;
      r = q;
      p=p->next;
   }
   //将第i个开始的j个元素跳过，不复制到目标返回链表达到替换目的
   for(k=0;k<j;k++)
      p= p->next;
   //将要替换的链表插入到目标返回链表
   while(p1!=NULL){
      q = (LinkStrNode *)malloc(sizeof(LinkStrNode));
      q->data = p1->data;
      r->next = q;
      r = q;
      p1= p1->next;
   }

   //将从 i+j-1开始的元素继续复制到目标返回链表
   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;
}

//输出串DispStr（）
void DispStr(LinkStrNode *s){
   LinkStrNode *p = s->next;
   while(p!=NULL){
      printf("%c",p->data);
      p=p->next;
   }
   printf("\n");
}

//把串s中最先出现的子串"ab"改为"xyz"
//   设置两指针，遍历串，找到第一个 a b 然后将a所在的节点data改为x，b所在的节点改为z，然后新建一个节点，data为y插入到x与z之间,并标记已找到，停止继续判断，遍历完结束程序即可.  注意循环条件，所指的节点和所指节点的下一个节点不为空 未标志已找到
void Repl(LinkStrNode * &s){
   LinkStrNode *p=s->next,*p,*l;
   bool find = false;
   while(p!=NULL&&p->next!=NULL&&!find){
      if(p->data == 'a'&&p->next->data == 'b'){
         q = p->next;
         p->data = 'x';
         q->data= 'z';
         l = (LinkStrNode *)malloc(sizeof(LinkStrNode));
         l->data = 'y';
         p->next=l;
         l->next = q;
      }
      p=p->next;
   }

}



int main(){
      

   return 0;
}