通过代码快速上手C语言数据结构-串

桃扇骨 2023-01-16 02:40 139阅读 0赞

# 4.1顺序串插入函数 #

#define MAXLEN 40
    typedef struct {          /*串结构定义*/
        char ch[MAXLEN];
        int len;
    }SString;
    
    void createstring(SString *s)
    {
    	int i,j;
    	char c;
    	printf("请输入要建立的串的长度:");
    	scanf("%d",&j);
    	for(i=0; i<j; i++)
    	{
    		printf("请输入串的第%d个字符:",i+1);
    		fflush(stdin);
    		scanf("%c",&c);
    		s->ch[i] = c;
    	}
    	s->len = j;
    }
    
    void output(SString *s)
    {
    	int i;
    	for (i=0;i<s->len;i++)
    		printf("%c   ",s->ch[i]);
    	printf("\n");
    }
    
    
    #include <stdio.h>
    #include <stdlib.h>
    //#include "seqstring.h"
    
    int StrInsert(SString *s, int pos, SString t)
    /*在串s中下标为pos的字符之前插入串t */
    {
    	int i;
    	if (pos<0 || pos>s->len) /*插入位置不合法*/
    		return(0); 
    	if (s->len + t.len<=MAXLEN) /*插入后串长≤MAXLEN*/
    	{
    		for (i=s->len + t.len-1;i>=t.len + pos;i--)
    			s->ch[i]=s->ch[i-t.len];
    		for (i=0;i<t.len;i++) 
    			s->ch[i+pos]=t.ch[i];
    		s->len=s->len+t.len;
    	}
    	else
    	{
    		if (pos+t.len<=MAXLEN) /*插入后串长>MAXLEN,但串t的字符序列可以全部插入*/
    		{
    			for (i=MAXLEN-1;i>t.len+pos-1;i--) 
    				s->ch[i]=s->ch[i-t.len];
    			for (i=0;i<t.len;i++)
    				s->ch[i+pos]=t.ch[i];
    			s->len=MAXLEN;
    		}
    		else /*插入后串长>MAXLEN,并且串t的部分字符也要舍弃*/
    		{ 
    			for (i=0;i<MAXLEN-pos;i++)
    				s->ch[i+pos]=t.ch[i];
    			s->len=MAXLEN;
    		}
    		return(1);
    	}
    }
    
    		
    void main()
    {
    	SString *str1;
    	SString  str2;
    	int i,j,k,pos;
    	int flag=0;
    	str1 = (SString *)malloc(sizeof(SString));
    	str1->len = 0;
    	printf("建立字符串1:\n");
    	createstring(str1);
    	printf("建立字符串2:\n");
    	createstring(&str2);
    	printf("请输入要插入的位置:");
    	scanf("%d",&pos);
    	flag=StrInsert(str1,pos,str2);
    	if(flag == 0)
    		printf("插入操作失败!");
    	else
    	{
    		printf("插入后串为:\n");
    		output(str1);
    	}
    
    }

# 4.2顺序串删除函数 #

# 4.3顺序串复制函数 #

# 4.4顺序串判空函数 #

# 4.5顺序串比较函数 #

# 4.6顺序串求串长函数 #

# 4.7顺序串清空函数 #

# 4.8顺序串连接函数 #

# 4.9顺序求子串函数 #

# 4.10顺序串的简单模式匹配函数 #

#define MAXLEN 40
    typedef struct {          /*串结构定义*/
        char ch[MAXLEN];
        int len;
    }SString;
    
    void createstring(SString *s)
    {
    	int i,j;
    	char c;
    	printf("请输入要建立的串的长度:");
    	scanf("%d",&j);
    	for(i=0; i<j; i++)
    	{
    		printf("请输入串的第%d个字符:",i+1);
    		fflush(stdin);
    		scanf("%c",&c);
    		s->ch[i] = c;
    	}
    	s->len = j;
    }
    
    void output(SString *s)
    {
    	int i;
            if(s->len == 0)
                printf("字符串为空!");
            else
    	    for (i=0;i<s->len;i++)
    		printf("%c   ",s->ch[i]);
    	printf("\n");
    }
    
    #include <stdio.h>
    #include <stdlib.h>
    //#include "seqstring.h"
    
    /*
    int StrIndex(SString s,int pos, SString t) 
    / *求从主串s的下标pos起，串t第一次出现的位置，成功返回位置序号，不成功返回-1* /
    { 
    	int i,j;
    	if (t.len==0) 
    		return(0);
    	i=pos;
    	j=0;
    	while (i<s.len && j<t.len)
    		if (s.ch[i]==t.ch[j])
    		{
    			i++;
    			j++;
    		}
    		else 
    		{
    			i=i-j+1;
    			j=0;
    		}
    		if (j>=t.len) 
    			return(i-j);
    		else 
    			return(-1);
    }
    */
    
    int StrIndex(SString s,int pos, SString t) 
    /*求从主串s的下标pos起，串t第一次出现的位置，成功返回位置序号，不成功返回-1*/
    { 
    	int i, j, start;
    	if (t.len==0)  
    		return(0);   /* 模式串为空串时，是任意串的匹配串 */
    	start=pos; 
    	i=start; 
    	j=0;  /* 主串从pos开始，模式串从头（0）开始 */
    	while (i<s.len && j<t.len)
    		if (s.ch[i]==t.ch[j]) 
    		{
    			i++;
    			j++;
    		}   /* 当前对应字符相等时推进 */
    		else 
    		{ 
    			start++;        /* 当前对应字符不等时回溯 */
    			i=start; 
    			j=0;   /* 主串从start+1开始，模式串从头（0）开始*/
    		} 
    		if (j>=t.len) 
    			return(start);    /* 匹配成功时，返回匹配起始位置 */
    		else 
    			return(-1);    /* 匹配不成功时，返回-1 */
    }
    
    void main()
    {
    	SString *str1;
    	SString  str2;
    	int pos;
    	int flag=0;
    	str1 = (SString *)malloc(sizeof(SString));
    	str1->len = 0;
    	printf("建立字符串1:\n");
    	createstring(str1);
    	printf("建立字符串2:\n");
    	createstring(&str2);
    	printf("请输入要查找的位置:");
    	scanf("%d",&pos);
    	flag=StrIndex(*str1,pos,str2);
    	if(flag == -1)
    		printf("查找失败!");
    	else
    	{
    		printf("出现的位置为:%d\n",flag);
    	}
    	
    }

# 4.11-4.13堆串函数 #

### 4.11堆串赋值函数 ###

### 4.12堆串插入函数 ###

### 4.13堆串删除函数 ###

#include <stdio.h>
    #include <stdlib.h>
    
    typedef  struct
    { 
    	char  *ch;
    	int   len;
    }HString;
    
    int StrAssign(HString *s, char *tval)
    /*将字符串常量tval的值赋给堆串s */
    {
    	int len, i=0;
    	if (s->ch!=NULL) 
    		free(s->ch);
    	while (tval[i]!='\0')
    		i++;
    	len=i;
    	if (len) 
    	{
    		s->ch=(char *)malloc(len);
    		if (s->ch==NULL) 
    			return(0);
    		for (i=0;i<len;i++) 
    			s->ch[i]=tval[i];
    	}
    	else
    		s->ch=NULL;
    	s->len=len;
    	return(1);
    }
    
    int	StrInsert(HString *s,int pos,HString *t)
    /*在串s中下标为pos的字符之前插入串t */
    { 
    	int i;
    	char *temp;
    	if (pos<0 || pos>s->len || s->len==0) 
    		return(0);
    	temp=(char *)malloc(s->len + t->len);
    	if (temp==NULL) 
    		return(0);
    	for (i=0;i<pos;i++) 
    		temp[i]=s->ch[i];
    	for (i=0;i<t->len;i++) 
    		temp[i+pos]=t->ch[i];
    	for (i=pos;i<s->len;i++) 
    		temp[i + t->len]=s->ch[i];
    	s->len+=t->len;
    	free(s->ch);
    	s->ch=temp;
    	return(1);
    }
    
    int	StrDelete(HString *s, int pos,int len)
    /*在串s中删除从下标pos起len个字符 */
    { 
    	int i;
    	char *temp;
    	if (pos<0 || pos>(s->len - len)) 
    		return(0);
    	temp=(char *)malloc(s->len - len);
    	if (temp==NULL) 
    		return(0);
    	for (i=0;i<pos;i++)
    		temp[i]=s->ch[i];
    	for (i=pos;i<s->len - len;i++)
    		temp[i]=s->ch[i+len];
    	s->len=s->len-len;
    	free(s->ch);
    	s->ch=temp;
    	return(1);
    }
    
    void main()
    {
    	HString *str1;
    	HString  *str2;
    	char *ch1, *ch2;
    	int i,j,k,pos;
    	int flag=0;
    	ch1 = (char*)malloc(sizeof(char));
    	ch2 = (char*)malloc(sizeof(char));
    	ch1 = "abcde";
    	ch2 = "abefgh";
    	
    	str1 = (HString *)malloc(sizeof(HString));
    	str1->ch = (char*)malloc(sizeof(char));
    	StrAssign(str1,ch1);
    	/*
    	str2 = (HString *)malloc(sizeof(HString));
    		str2->ch = (char*)malloc(sizeof(char));
    		StrAssign(str2,ch2);*/
    	
    	printf("长度为%d",str1->len);
    
    	/*
    	printf("请输入要插入的位置:");
    		scanf("%d",&pos);
    		flag=StrInsert(str1,pos,str2);
    		if(flag == 0)
    			printf("插入操作失败!");
    		else
    		{
    			printf("插入操作成功!\n");
    				
    		}*/
    	
    	printf("请输入要删除的位置和长度:");
    	fflush(stdin);
    	scanf("%d,%d",&pos,&j);
    	printf("pos=%d,j=%d",pos,j);
    	flag=StrDelete(str1,pos,j);
    	if(flag == 0)
    		printf("删除操作失败!");
    	else
    	{
    		printf("删除操作成功!\n");
    		
    	}
    
    	
    }

# 曲型例题链串模式匹配 #

int  StrIndex_KMP(SString s,int pos, SString t,int next[]) 
    /*求从主串s的下标pos起，串t第一次出现的位置*/
    {
    	int i, j;
    	if (t.len==0) 
    		return(0);    /* 空串是任意字符串的子串 */
    	i=pos;  
    	j=0;
    	while (i<s.len && j<t.len)
    		if (s.ch[i]==t.ch[j])      /* 主串与子串的对应字符相等，则继续比较下一字符 */
    		{
    			i++; 
    			j++;
    		} 
    		else 
    			j=next[j];          /* 发现失配字符则用next函数值更新j值，而i值不变 */
    	if (j>=t.len) 
    		return(i-j);   /* 成功则返回主串的当前起始匹配位置 */
    	else 
    		return(-1);         /* 不成功则返回-1 */
    }

void Get_nextpos(SString t, int next[])
    /*求模式串t的next函数修正值并存入数组next[]中*/
    {
    	int i,j;
    	i=0; 
    	j=-1; 
    	next[0]=-1;
    	while(i<t.len) 
    	{
    		if(j==-1 || t.ch[i]==t.ch[j]) 
    		{
    			i++;
    			j++;
    			if (t.ch[i]!=t.ch[j]) 
    				next[i]=j;
    			else 
    				next[i]=next[j]+1;
    		}
    		else 
    			j=next[j];
    	}
    }

#include "stdio.h"
    #include <stdlib.h>
    #include <string.h>
    
    /*定义块链结构，每行作为一个结点，有80个字符*/
    typedef struct BLOCK {
      char ch[80];
      struct BLOCK *next;
      }Node,*LinkString; 
    LinkString L;
    
    
    void getnum(char sel[],int *n1,int *n2,int line)
    {/*将存放在sel中的字符串分解出n1和n2*/
    int i,k1,k2,flag=0;
    
    k1=0;k2=0;i=1;
    while(sel[i]!='\0')
       if (sel[i]>='0'&&sel[i]<='9')
       {
    	   k1=k1*10+(sel[i]-'0');
    	   flag=1;
    	   i++;
       }
       else 
    	   if (sel[i]==',') 
    	   {
    		   flag=2;
    		   i++;
    		   break;
    	   };
    //printf("哈哈");
    while(sel[i]!='\0') {
       if (sel[i]>='0'&&sel[i]<='9')
         {k2=k2*10+(sel[i]-'0');i++;}
       else break;
       };
    switch (sel[0]) {
      case 'L':
      case 'l':
      case 'D':
      case 'd':
           if (k1==0) *n1=line;
           else *n1=k1;
           if (k2==0) *n2=*n1+10;
           else *n2=k2;
           if (flag==1) *n2=*n1;
           if (flag==0) {
    	   *n1=line;*n2=line+10;
    	   }
           break;
      case 'I':
      case 'i':
      case 'E':
      case 'e':
           if (k1==0) *n1=line;
           else *n1=k1;
           break;
      }
    }
    
    void loadfile(char filename[])
    /*从磁盘读取指定的文件并存放在块链表中*/
    {
    FILE *fp;
    int i;
    char c;
    LinkString p,q;
    
    fp=fopen(filename,"r");
    if (fp==NULL)   exit(0);
    
    i=0;p=L;
    q=(LinkString)malloc(sizeof(Node));
    
    while((c=getc(fp))!=EOF) {
      q->ch[i++]=c;
      if (c==10) {
        q->ch[i]='\0';
        q->next=NULL;
        p->next=q;p=q;
        q=(LinkString)malloc(sizeof(Node));
        i=0;
        }
      }
    }
    void savefile(char filename[])
    /*将存放在块链表中的字符存放到磁盘文件filename中*/
    {
    FILE *fp;
    //int i,j;
    //char c;
    LinkString p;
    
    fp=fopen(filename,"w");
    if (fp==NULL)   exit(0);
    
    p=L->next;
    
    while(p) {
      fprintf(fp,"%s",p->ch);
      p=p->next;
      }
    fclose(fp);
    }
    
    int display(int n1,int n2)
    /*在屏幕上显示文件中第n1行到第n2行的内容*/
    {
    LinkString p,q,s;
    int i,k;
    
    if (n1>n2) return(0);
    
    p=L->next;i=0;
    while (p!=NULL&&i<n1) {
        p=p->next;i++;
        }
    if (!p) return(0);
    q=p->next;
    while (q!=NULL&&i<n2) {
        q=q->next;i++;
        }
    s=p;i=n1;
    while (s!=q) {
      k=0;printf("%2d:",i);
      while (s->ch[k]!='\0') {printf("%c",s->ch[k]);k++;}
      s=s->next;
      i++;
      }
    return(1);
    }
    
    int deletechar(int n1,int n2)
    /*删除文件中第n1行到第n2行的内容*/
    {
    LinkString p,q,s;
    int i;
    if (n1>n2) return(0);
    
    p=L;i=0;
    while (p!=NULL&&i<n1) {
        p=p->next;i++;
        }
    if (!p) return(0);
    q=p->next;
    while (q!=NULL&&i<=n2) {
        q=q->next;i++;
        }
    s=p->next;p->next=q;
    while (s!=q) {
      p=s->next;free(s);
      s=p;
      }
    return(1);
    }
    
    int edit(int  n1)
    /*修改文件中第n1行的内容*/
    {
    LinkString p;
    int i,k;
    char str[80];
    
    p=L->next;i=0;
    while (p!=NULL&&i<n1) {
        p=p->next;i++;
        }
    if (!p) return(0);
    printf("Old Line(%d):",n1);
    for (k=0;p->ch[k]!='\0';k++) printf("%c",p->ch[k]);
    printf("New Line(%d):",n1);gets(str);
    for(k=0;str[k]!='\0';k++)
      p->ch[k]=str[k];
    p->ch[k++]=10;
    p->ch[k]='\0';
    
    return(1);
    }
    
    int insert(int n1)
    /*在文件中第n1行之前插入一行*/
    {
    LinkString p,s;
    int i,k;
    char str[80];
    
    p=L;i=0;
    while (p!=NULL&&i<n1) {
        p=p->next;i++;
        }
    if (!p) return(0);
    s=(LinkString) malloc(sizeof(Node));
    printf("New Line(%d):",n1);gets(str);
    for(k=0;str[k]!='\0';k++)
      s->ch[k]=str[k];
    s->ch[k++]=10;
    s->ch[k]='\0';
    s->next=p->next;
    p->next=s;
    
    return(1);
    }
    
    void main(int argc,char *argv[])
    {
    	char sel[50],string[80];
    	int n1,n2,cur_line=0,flag=0;
    	L=(LinkString)malloc(sizeof(Node));
    	L->next=NULL;/*生成头结点*/
    //	strcpy(string,argv[1]);
    	/*打开文件*/
    	if (argc>=2) loadfile(string);
    	else {
    		printf("Input FileName:");
    		scanf("%s",string);
    		getchar();
    		loadfile(string);
    	}
    	/*从键盘接受一个字符串，转换为命令和参数*/
    	while (1) {
    		printf(">>");
    		/*gets(sel);*/
    		fflush(stdin);
    		scanf("%s",sel);
    		getnum(sel,&n1,&n2,cur_line);/*将接受的字符串转换为参数n1,n2*/
    		switch(sel[0]) {/*分别调用函数完成相应功能*/
    		case 'S':
    		case 's':   flag=1;savefile(string);break;
    		case 'Q':
    		case 'q':	flag=1;break;
    		case 'L':
    		case 'l':	display(n1,n2);break;
    		case 'D':
    		case 'd':	 deletechar(n1,n2);display(0,10);break;
    		case 'I':
    		case 'i':	 insert(n1);break;
    		case 'E':
    		case 'e':	 edit(n1);break;
    		}
    		if (flag) break;
    	}
    }

### linkstrindex ###

#include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Link{
    	char   ch;/*保存一个字符*/
    	struct Link   *next;
    }Link;
    
    typedef struct {
    	Link   *head; /*头指针*/
    	Link   *tail; /*尾指针*/
    	int     len; /*串的长度*/
    }LKString;
    
    int StrAssign(LKString *s, char *tval)
    /*将字符串常量tval的值赋给块链串s */
    { 
    	Link *p,*q;
    	int len,i=0;
    	int j;
    	if (s->head!=NULL)   /*释放原来存储在S中的结点空间*/
    	{
    		p=s->head;
    		while(p!=NULL) 
    		{
    			q=p->next;
    			free(p);
    			p=q;
    		}
    		s->head=s->tail=NULL;
    	}
    	while (tval[i]!='\0')
    		i++;
    	len=i;
    	s->len=len;
    	if (len) 
    	{
    		p=(Link *)malloc(sizeof(Link)); /*生成头结点*/
    		if (p==NULL) 
    			return(0);
    		s->head=s->tail=q=p;/*q是插入结点过程中链表的尾结点指针*/
    		i=0; 
    		while(i<len)
    		{
    			p=(Link *)malloc(sizeof(Link));/*申请一个结点，插入到链表尾部*/
    			if (p==NULL)
    				return(0);
    			q->next=p;
    			q=p;
    			p->ch=tval[i];
    			i++;
    		}
    	}
    	q->next=NULL;
    	s->tail=q;
    	s-> len =len;
    	return(1);
    }
    
    
    Link *StrIndex(LKString *s, LKString *t)
    /*求子串t在主串s中第一次出现的位置指针*/
    {
    	Link *sp,*tp,*pre;	
    	if (t->len == 0) 
    		return NULL;/*子串是空串，则返回*/
    	
    	sp = s->head->next;/*主串第一个结点指针*/
    	tp = t->head->next;/*子串第一个结点指针*/
    	
    	pre = sp;/*记录当前串比较的起始位置指针*/
    	while(sp != NULL && tp != NULL)
    	{
    		if (sp->ch == tp->ch) {
    			/*若当前sp和tp的字符都相同，则继续比较*/
    			sp = sp->next;
    			tp = tp->next;
    		}
    		else
    		{
    			/*返回到串比较起始位置的下一个结点继续比较*/
    			sp = pre->next;
    			pre = sp;/*更新比较的起始位置*/
    			tp = t->head->next;/*子串第一个结点*/
    		}
    	}
    	if ( tp == NULL) {
    		/*匹配成功，返回位置指针*/
    		return pre;
    	}
    	else
    		return NULL;/*匹配不成功，返回空指针*/
    }
    
    void output(LKString *s)
    {
    	Link *p;
    	int i,j;
    	p = s->head->next;
    	i=0;
    	while(i<s->len)
    	{
    		printf("%c  ",p->ch);
    		p = p->next;
    		i++;
    	}
    	printf("\n");
    }
    
    void main()
    {
    	LKString *str1,*str2;
    	Link *p;
    	char *t;
    	int len,pos;
    	int flag=0;
    	str1 = (LKString *)malloc(sizeof(LKString));
    	str1->head = NULL;
    	str1->tail = NULL;
    	t = (char *)malloc(sizeof(char));
    	t = "abcdefghij";
    	flag = StrAssign(str1,t);
    	if(flag == 1)
    	{
    		printf("str1赋值成功!");
    		output(str1);
    	}
    	else
    		printf("st1r赋值失败!");
    
    	str2 = (LKString *)malloc(sizeof(LKString));
    	str2->head = NULL;
    	str2->tail = NULL;
    	t = (char *)malloc(sizeof(char));
    	t = "def";
    	flag = StrAssign(str2,t);
    	if(flag == 1)
    	{
    		printf("str2赋值成功!");
    		output(str2);
    	}
    	else
    		printf("str2赋值失败!");
    	p=StrIndex(str1,str2);
    	printf("%c\n",p->ch);
    }

### lstrindex ###

#include "stdio.h"
    #include "stdlib.h"
    
    /*链式存储方式下的模式匹配，每个字符用一结点表示*/
    
    typedef struct Block{
    	char   ch;
    	struct Block   *next;
    }Block;
    
    typedef struct {
    	Block   *head;
    	Block   *tail;
    	int     len;
    }BLString;
    
    int StrAssign(BLString *s, char *tval)
    /*将字符串常量tval的值赋给块链串s*/
    {
    	Block *p,*q;
    	int len, i=0;
    
    	if (s->head != NULL) {
    		/*释放原来存储在S中的结点空间*/
    		p = s->head;
    		while (p != NULL) {
    			q = p->next;
    			free(p);
    			p = q;
    		}
    
    		s->head = s->tail = NULL;
    	}
    
    	/*计算字符串长度*/
    	while (tval[i] != '\0') i++;
    
    	len = i;s->len = len;
    
    	if (len > 0) {
    		p = (Block *)malloc(sizeof(Block));
    		if (p == NULL) return 1;
    		s->head = s->tail = q = p;
    		i=0;
    
    		while (i < len) {
    			p = (Block *)malloc(sizeof(Block));
    			if (p == NULL) return 1;
    			q->next = p;q = p;
    
    			//printf("\nCopying %c",tval[i]);
    			p->ch = tval[i++];
    		}
    	}
    
    	q->next = NULL;s->tail = q;
    
    	return 0;
    }
    
    int StrDelete(BLString *s, int pos, int len)
    {
    	/*在串s中删除从下标pos起len个字符 */
    	int i,j;
    	Block *p,*q,*r;
    
    	if (pos<0 || pos>(s->len - len)) return 1;
    
    	i = 0;
    	p = s->head;
    	while(i<pos){
    		p = p->next;
    		i++;
    	}
    
    	q = p;
    
    	j = 0;
    	p = p->next;
    	while (j<len) {
    		r = p->next;
    		//printf("\ndeleting %c",p->ch);
    		free(p);
    		p = r;
    		j++;
    	}
    
    	q->next = p;
    	s->len = s->len - len;
    	if (q->next == NULL) {
    		s->tail = q;
    	}
    
    	return 0;
    }
    
    Block *StrIndex(BLString *s, BLString *t)
    /*求子串t在主串s中第一次出现的位置指针*/
    {
    	Block *p = NULL;
    	Block *q = NULL;
    	Block *tmp = NULL;
    	int j;
    
    	if (t->len == 0) return NULL;
    
    	p = s->head->next;
    	q = t->head->next;
    	tmp = p;
    	j = 0;
    	while(p != NULL && q != NULL)
    	{
    		if (p->ch == q->ch) {
    			p = p->next;
    			q = q->next;
    		}
    		else
    		{
    			p = tmp->next;
    			tmp = p;
    			j++;
    			q = t->head->next;
    		}
    	}
    
    	if ( q == NULL) {
    		printf("\nFound!=%c in position %d\n",tmp->ch,j);
    		return tmp;
    	}
    	else return NULL;
    }
    
    int main()
    {
    	static BLString s,t;
    	char str1[80],str2[80];
    
    	printf("请输入主串s的内容：");
    	scanf("%s",str1);
    	printf("\n请输入子串t的内容：");
    	scanf("%s",str2);
    
    	StrAssign(&s,str1);
    	StrAssign(&t,str2);
    
    	Block *pos = StrIndex(&s,&t);
    	if (pos == NULL) {
    		printf("\nString not found!\n");
    	}
    
    	//释放空间
    	StrDelete(&s,0,s.len);
    	StrDelete(&t,0,t.len);
    	return 0;
    }

Link *StrIndex(LKString *s, LKString *t)
    /*求子串t在主串s中第一次出现的位置指针*/
    {
    	Link *sp,*tp,*pre;	
    	if (t->len == 0) 
    		return NULL;/*子串是空串，则返回*/
    	
    	sp = s->head->next;/*主串第一个结点指针*/
    	tp = t->head->next;/*子串第一个结点指针*/
    	
    	pre = sp;/*记录当前串比较的起始位置指针*/
    	while(sp != NULL && tp != NULL)
    	{
    		if (sp->ch == tp->ch) {
    			/*若当前sp和tp的字符都相同，则继续比较*/
    			sp = sp->next;
    			tp = tp->next;
    		}
    		else
    		{
    			/*返回到串比较起始位置的下一个结点继续比较*/
    			sp = pre->next;
    			pre = sp;/*更新比较的起始位置*/
    			tp = t->head->next;/*子串第一个结点*/
    		}
    	}
    	if ( tp == NULL) {
    		/*匹配成功，返回位置指针*/
    		return pre;
    	}
    	else
    		return NULL;/*匹配不成功，返回空指针*/
    }