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

最新推荐文章于 2022-11-21 19:25:36 发布

神迹小卒

最新推荐文章于 2022-11-21 19:25:36 发布

阅读量608

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/aiqq136/article/details/116050980

版权

数据结构与算法专栏收录该内容

69 篇文章 51 订阅

订阅专栏

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顺序串删除函数


#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 StrDelete(SString *s, int pos, int len)
/*在串s中删除从下标pos起len个字符*/
{ 
	int i;
	if (pos<0 || pos>(s->len-len))/*删除参数不合法*/
		return(0); 
	for (i=pos+len;i<s->len;i++)
		s->ch[i-len]=s->ch[i]; /*从pos+len开始至串尾依次向前移动，实现删除len个字符*/
	s->len=s->len - len; /*s串长减len*/
	return(1);
}

void main()
{
	SString *str1;
	int j,pos;
	int flag=0;
	str1 = (SString *)malloc(sizeof(SString));
	str1->len = 0;
	printf("建立字符串1:\n");
	createstring(str1);
	printf("请输入删除位置和长度:\n");
	fflush(stdin);
	scanf("%d,%d",&pos,&j);
	flag=StrDelete(str1,pos,j);
	if(flag == 0)
		printf("删除操作失败!");
	else
	{
		printf("删除后串为:\n");
		output(str1);
	}
	
}

4.3顺序串复制函数


#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"

void StrCopy(SString *s, SString t)
/*将串t的值复制到串s中*/
{ 
	int i;
	for (i=0;i<t.len;i++)
		s->ch[i]=t.ch[i];
	s->len=t.len;
}


void main()
{
	SString *str1;
	SString  str2;	
	str1 = (SString *)malloc(sizeof(SString));
	str1->len = 0;
	printf("建立字符串1:\n");
	createstring(str1);
	printf("建立字符串2:\n");
	createstring(&str2);
	StrCopy(str1,str2);
	output(str1);
	
}

4.4顺序串判空函数


#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 StrEmpty(SString s)
/*若串s为空则返回1，否则返回0 */
{
	if (s.len==0) 
		return(1);
	else
		return(0);
}


void main()
{
	SString  str2;
	int flag=0;
	printf("建立字符串2:\n");
	createstring(&str2);
	flag=StrEmpty(str2);
	if(flag == 1)
		printf("字符串为空!");
	else
	{
		printf("字符串不为空!\n");
		output(&str2);
	}
	
}

4.5顺序串比较函数


#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 StrCompare(SString s, SString t)
/*若串s和t相等则返回0；若s>t则返回正数；若s<t则返回负数*/
{ 
	int i;
	for (i=0;i<s.len&&i<t.len;i++)
		if (s.ch[i]!=t.ch[i]) 
			return(s.ch[i] - t.ch[i]);
	return(s.len - t.len);
}


void main()
{
	SString *str1;
	SString  str2;
	int flag=0;
	str1 = (SString *)malloc(sizeof(SString));
	str1->len = 0;
	printf("建立字符串1:\n");
	createstring(str1);
	printf("建立字符串2:\n");
	createstring(&str2);
	flag=StrCompare(*str1,str2);
	if(flag == 0)
		printf("字符串相等!");
	else
	{
		if(flag < 0)
			printf("字符串1小于字符串2!");
		else
			printf("字符串1大于字符串2!");
	}
	
}

4.6顺序串求串长函数


#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 StrLength(SString s)
/* 返回串s的长度*/
{
	return(s.len);
}


void main()
{
	
	SString  str2;
	int length;
	printf("建立字符串2:\n");
	createstring(&str2);
	length = StrLength(str2);
	printf("字符串长度为%d!\n",length);
	
	
}

4.7顺序串清空函数


#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"

void StrClear(SString *s)
/*将串s置为空串*/
{
	s->len=0;
}

void main()
{
	SString *str1;
	str1 = (SString *)malloc(sizeof(SString));
	str1->len = 0;
	printf("建立字符串1:\n");
	createstring(str1);
	StrClear(str1);
	output(str1);

}

4.8顺序串连接函数


#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 StrCat(SString *s, SString t)
/*将串连接在串s的后面*/
{ 
	int i, flag;
	if (s->len + t.len<=MAXLEN)  /*连接后串长小于MAXLEN*/
	{ 
		for (i=s->len; i<s->len + t.len; i++)
			s->ch[i]=t.ch[i-s->len];
		s->len+=t.len;
		flag=1;
	}
	else 
	if (s->len<MAXLEN)  /*连接后串长大于MAXLEN，但串s的长度小于MAXLEN，即连接后串t的部分字符序列被舍弃*/
	{ 
		for (i=s->len;i<MAXLEN;i++)
			s->ch[i]=t.ch[i-s->len];
		s->len=MAXLEN;
		flag=0;
	}
	else 
		flag=0;  /* 串s的长度等于MAXLEN ,串t不被连接*/
	return(flag);
}

void main()
{
	SString *str1;
	SString  str2;
	int flag=0;
	str1 = (SString *)malloc(sizeof(SString));
	str1->len = 0;
	printf("建立字符串1:\n");
	createstring(str1);
	printf("建立字符串2:\n");
	createstring(&str2);
	printf("请输入要插入的位置:");
	flag=StrCat(str1,str2);
	output(str1);

	
}

4.9顺序求子串函数


#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 SubString(SString *sub, SString s, int pos, int len) 
/*将串s中下标pos起len个字符复制到sub中*/
{ 
	int i;
	if (pos<0 || pos>s.len || len<1 || len>s.len-pos)
	{
		sub->len=0;
		return(0); 
	}
	else 
	{
		for (i=0; i<len; i++)
			sub->ch[i]=s.ch[i+pos];
		sub->len=len;
		return(1);
	}
}


void main()
{
	SString *str1;
	SString  str2;
	int j,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,%d",&pos,&j);
	flag=SubString(str1,str2,pos,j);
	if(flag == 0)
		printf("求子串操作失败!");
	else
	{
		printf("子串为:\n");
		output(str1);
	}
	
}

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;/*匹配不成功，返回空指针*/
}

神迹小卒

关注

0
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
通过代码快速上手C语言数据结构-串

4.1顺序串插入函数4.2顺序串删除函数4.3顺序串复制函数4.4顺序串判空函数4.5顺序串比较函数4.6顺序串求串长函数4.7顺序串清空函数4.8顺序串连接函数4.9顺序求子串函数4.10顺序串的简单模式匹配函数4.11堆串赋值函数4.12堆串插入函数4.13堆串删除函数曲型例题链串模式匹配...
复制链接

扫一扫