第八周项目2--建立链串的算法库

问题及代码：

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

头文件LiString.h代码：

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

源文件LiString.cpp代码：

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

主函数main.cpp代码：

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

运行结果：

知识点总结：

建立链串的算法库。

学习心得：

通过建立链串的算法库，对链串的算法构起了框架，对以后解决实际问题有很大帮助。