建立连串算法库

[cpp] view plain copy

 

1. /*   
2. Copyright (c)2016,烟台大学计算机与控制工程学院   
3. All rights reserved.   
4. 文件名称：项目7.cbp   
5. 作    者：泮春宇 
6. 完成日期：2016年11月3日   
7. 版 本 号：v1.0    
8. 问题描述：定义链串的存储结构，实现其基本运算，并完成测试。    
9. 输入描述：无   
10. 程序输出：测试数据   
11. */   

main函数

[cpp] view plain copy

 

1. #include "sqString.h"    
2. int main()    
3. {    
4.     LiString *s,*s1,*s2,*s3,*s4;    
5.     printf("链串的基本运算如下:\n");    
6.     printf("  (1)建立串s和串s1\n");    
7.     StrAssign(s,"abcdefghijklmn");    
8.     printf("  (2)输出串s:");    
9.     DispStr(s);    
10.     StrAssign(s1,"123");    
11.     printf("  (2)输出串s1:");    
12.     DispStr(s1);    
13.     printf("  (3)串s的长度:%d\n",StrLength(s));    
14.     printf("  (4)在串s的第9个字符位置插入串s1而产生串s2\n");    
15.     s2=InsStr(s,9,s1);    
16.     printf("  (5)输出串s2:");    
17.     DispStr(s2);    
18.     printf("  (6)删除串s第2个字符开始的5个字符而产生串s2\n");    
19.     s2=DelStr(s,2,3);    
20.     printf("  (7)输出串s2:");    
21.     DispStr(s2);    
22.     printf("  (8)将串s第2个字符开始的5个字符替换成串s1而产生串s2\n");    
23.     s2=RepStr(s,2,5,s1);    
24.     printf("  (9)输出串s2:");    
25.     DispStr(s2);    
26.     printf("  (10)提取串s的第2个字符开始的10个字符而产生串s3\n");    
27.     s3=SubStr(s,2,10);    
28.     printf("  (11)输出串s3:");    
29.     DispStr(s3);    
30.     printf("  (12)将串s1和串s2连接起来而产生串s4\n");    
31.     s4=Concat(s1,s2);    
32.     printf("  (13)输出串s4:");    
33.     DispStr(s4);    
34.     return 0;    
35. }    

源文件

[cpp] view plain copy

 

1. #include "sqString.h"    
2. void StrAssign(LiString *&s,char cstr[])   //字符串常量cstr赋给串s    
3. {                                       //尾插法    
4.     int i;    
5.     LiString *r,*p;    
6.     s=(LiString *)malloc(sizeof(LiString));    
7.     r=s;                            //r始终指向尾节点    
8.     for(i=0;cstr[i]!='\0';i++)    
9.     {    
10.         p=(LiString *)malloc(sizeof(LiString));    
11.         p->data=cstr[i];    
12.         r->next=p;    
13.         r=p;    
14.     }    
15.     r->next=NULL;    
16. }    
17. void StrCopy(LiString *&s,LiString *t) //串t复制给串s    
18. {    
19.     LiString *p=t->next,*q,*r;    
20.     s=(LiString *)malloc(sizeof(LiString));    
21.     r=s;              //r始终指向尾节点    
22.     while(p!=NULL)    //将t的所有节点复制到s    
23.     {    
24.         q=(LiString *)malloc(sizeof(LiString));    
25.         q->data=p->data;    
26.         r->next=q;    
27.         p=p->next;    
28.     }    
29.     r->next=NULL;    
30. }    
31. bool StrEqual(LiString *s,LiString *t) //判串相等    
32. {    
33.     LiString *p=s->next,*q=t->next;    
34.     while(p!=NULL&&q!=NULL&&p->data ==q->data)    
35.     {    
36.         p=p->next;    
37.         q=q->next;    
38.     }    
39.     if(p==NULL&&q==NULL)    
40.         return true;    
41.     else    
42.         return false;    
43. }    
44. int StrLength(LiString *s) //求串长    
45. {    
46.     int i=0;    
47.     LiString *p=s->next;    
48.     while(p!=NULL)    
49.     {    
50.         i++;    
51.         p=p->next;    
52.     }    
53.     return i;    
54. }    
55. LiString *Concat(LiString *s,LiString *t)  //串连接    
56. {    
57.     LiString *str,*p=s->next,*q,*r;    
58.     str=(LiString *)malloc(sizeof(LiString));    
59.     r=str;       
60.     while(p!=NULL)     //将s的所有节点复制到str    
61.     {    
62.         q=(LiString *)malloc(sizeof(LiString));    
63.         q->data=p->data;    
64.         r->next=q;    
65.         r=q;    
66.         p=p->next;    
67.     }    
68.     p=t->next;   //将t的所有节点复制到str    
69.     while(p!=NULL)         
70.     {    
71.         q=(LiString *)malloc(sizeof(LiString));    
72.         q->data=p->data;    
73.         r->next=q;    
74.         r=q;    
75.         p=p->next;    
76.     }    
77.     r->next=NULL;    
78.     return str;    
79. }    
80. LiString *SubStr(LiString *s,int i,int j)  //求子串    
81. {    
82.     int k;    
83.     LiString *str,*p=s->next,*q,*r;    
84.     str=(LiString *)malloc(sizeof(LiString));    
85.     str->next=NULL;    
86.     r=str;   //r只想新建连标的尾节点    
87.     if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))    
88.         return str;          //参数不正确时的处理    
89.     for(k=0;k<i-1;k++)    
90.         p=p->next;     //走完前面n-1个节点，最后p就指向第i个的节点    
91.     for(k=1;k<=j;k++)    //将s的第i个节点开始的j个节点复制到str；    
92.     {    
93.         q=(LiString *)malloc(sizeof(LiString));    
94.         q->data=p->data;    
95.         r->next=q;    
96.         r=q;    
97.         p=p->next;    
98.     }    
99.     r->next=NULL;    
100.     return str;    
101. }    
102. LiString *InsStr(LiString *s,int i,LiString *t)    //串插入    
103. {    
104.     int k;    
105.     LiString *str,*p=s->next,*p1=t->next,*q,*r;    
106.     str=(LiString *)malloc(sizeof(LiString));    
107.     r=str;    
108.     str->next=NULL;    
109.     //参数非法时的处理    
110.     if(i<=0||i-1>StrLength(s))    
111.         return str;    
112.     //将s的前i的节点复制到str    
113.     for(k=1;k<i;k++)    
114.     {    
115.         q=(LiString *)malloc(sizeof(LiString));    
116.         q->data=p->data;    
117.         r->next=q;    
118.         r=q;    
119.         p=p->next;    
120.     }    
121.     //将t中所有节点复制到str    
122.     while(p1!=NULL)    
123.     {    
124.         q=(LiString *)malloc(sizeof(LiString));    
125.         q->data=p1->data;    
126.         r->next=q;    
127.         r=q;    
128.         p1=p1->next;    
129.     }    
130.     //将*p及其后的节点复制到str    
131.     while(p!=NULL)    
132.     {    
133.         q=(LiString *)malloc(sizeof(LiString));    
134.         q->data=p->data;    
135.         r->next=q;    
136.         r=q;    
137.         p=p->next;    
138.     }    
139.     r->next=NULL;    
140.     return str;    
141. }    
142. LiString *DelStr(LiString *s,int i,int j)  //串删去    
143. {    
144.     int k;    
145.     LiString *str,*p=s->next,*q,*r;    
146.     str=(LiString *)malloc(sizeof(LiString));    
147.     r=str;          //r指向新建链表的尾节点    
148.     str->next=NULL;    
149.      //参数不正确时返回空串    
150.     if(i<=0||i>StrLength(s)||j<0 || i+j-1>StrLength(s))    
151.         return str;    
152.      //将s的前i-1个节点复制到str    
153.     for(k=1;k<i-1;k++)    
154.     {    
155.         q=(LiString *)malloc(sizeof(LiString));    
156.         q->data=p->data;    
157.         r->next=q;    
158.         r=q;    
159.         p=p->next;    
160.     }    
161.      //让p沿next跳j个节点    
162.     for(k=0;k<j;k++)    
163.         p=p->next;    
164.      //将*p及其后的节点复制到str    
165.     while(p!=NULL)    
166.     {    
167.         q=(LiString *)malloc(sizeof(LiString));    
168.         q->data=p->data;    
169.         r->next=q;    
170.         r=q;    
171.         p=p->next;    
172.     }    
173.     r->next=NULL;    
174.     return str;    
175. }    
176. LiString *RepStr(LiString *s,int i,int j,LiString *t)  //串替换    
177. {    
178.     int k;    
179.     LiString *str,*p=s->next,*p1=t->next,*q,*r;    
180.     str=(LiString *)malloc(sizeof(LiString));    
181.     r=str;          //r指向新建链表的尾节点    
182.     str->next=NULL;    
183.      //参数不正确时返回空串    
184.     if(i<=0||i>StrLength(s) || j<0 || i+j-1>StrLength(s))    
185.         return str;    
186.     //将s的前i-1个节点复制到str    
187.     for(k=1;k<i-1;k++)    
188.     {    
189.         q=(LiString *)malloc(sizeof(LiString));    
190.         q->data=p->data;    
191.         r->next=q;    
192.         r=q;    
193.         p=p->next;    
194.     }    
195.     //让p沿next跳j个节点    
196.     for(k=0;k<j;k++)    
197.         p=p->next;    
198.     //将t的所有节点复制到str    
199.     while(p1!=NULL)    
200.     {    
201.         q=(LiString *)malloc(sizeof(LiString));    
202.         q->data=p1->data;q->next=NULL;    
203.         r->next=q;    
204.         r=q;    
205.         p1=p1->next;    
206.     }    
207.     //将*p及其后的节点复制到str    
208.     while(p!=NULL)    
209.     {    
210.         q=(LiString *)malloc(sizeof(LiString));    
211.         q->data=p->data;    
212.         r->next=q;    
213.         r=q;    
214.         p=p->next;    
215.     }    
216.     r->next=NULL;    
217.     return str;    
218. }    
219. void DispStr(LiString *s)  //输出串    
220. {    
221.     LiString *p=s->next;    
222.     while(p!=NULL)    
223.     {    
224.         printf("%c",p->data);    
225.         p=p->next;    
226.     }    
227.     printf("\n");    
228. }    

头文件

[cpp] view plain copy

 

1. #include <stdio.h>    
2. #include <malloc.h>    
3. typedef struct snode    
4. {    
5.     char data;    
6.     struct snode *next;    
7. } LiString;    
8.     
9. void StrAssign(LiString *&s,char cstr[]);   //字符串常量cstr赋给串s    
10. void StrCopy(LiString *&s,LiString *t); //串t复制给串s    
11. bool StrEqual(LiString *s,LiString *t); //判串相等    
12. int StrLength(LiString *s); //求串长    
13. LiString *Concat(LiString *s,LiString *t);  //串连接    
14. LiString *SubStr(LiString *s,int i,int j);  //求子串    
15. LiString *InsStr(LiString *s,int i,LiString *t) ;   //串插入    
16. LiString *DelStr(LiString *s,int i,int j);  //串删去    
17. LiString *RepStr(LiString *s,int i,int j,LiString *t);  //串替换    
18. void DispStr(LiString *s);  //输出串