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

最新推荐文章于 2021-05-21 09:03:28 发布
原创 最新推荐文章于 2021-05-21 09:03:28 发布 · 493 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文介绍了一个链串算法库的设计与实现，包括链串的基本运算如串的创建、复制、比较等，并通过具体示例展示了各项功能。
  1. /*        
  2. Copyright (c)2016,烟台大学计算机与控制工程学院        
  3. All rights reserved.        
  4. 文件名称：第8周项目2 - 建立链串的算法库.cpp  
  5. 作    者：陈晓琳       
  6. 完成日期：2016年10月20日        
  7. 版 本 号：v1.0          
  8. 问题描述：定义链串的存储结构，实现串的基本运算，并完成测试。    
  9. 输入描述：各种串的输入。  
  10. 程序输出：各操作后的输出。  
  11. */    
头文件listring.h代码：

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. #include <stdio.h>    
  2. #include <malloc.h>    
  3. typedef struct snode    
  4. {    
  5.     char data;    
  6.     struct snode *next;    
  7. } LiString;    
  8.     
  9.     
  10. void StrAssign(LiString *&s,char cstr[]);   //字符串常量cstr赋给串s    
  11. void StrCopy(LiString *&s,LiString *t); //串t复制给串s    
  12. bool StrEqual(LiString *s,LiString *t); //判串相等    
  13. int StrLength(LiString *s); //求串长    
  14. LiString *Concat(LiString *s,LiString *t);  //串连接    
  15. LiString *SubStr(LiString *s,int i,int j);  //求子串    
  16. LiString *InsStr(LiString *s,int i,LiString *t) ;   //串插入    
  17. LiString *DelStr(LiString *s,int i,int j);  //串删去    
  18. LiString *RepStr(LiString *s,int i,int j,LiString *t);  //串替换    
  19. void DispStr(LiString *s);  //输出串    
源文件listring.cpp代码：

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

[cpp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. #include "listring.h"    
  2.     
  3.     
  4. int main()    
  5. {    
  6.     LiString *s1,*s2,*s3,*s4,*s5;    
  7.     printf("链串的基本运算如下:\n");    
  8.     printf("  (1)建立串s1和串s2\n");    
  9.     StrAssign(s1,"ABCDEFGHIJKLMN");    
  10.     printf("  (2)输出串s1:");    
  11.     DispStr(s1);    
  12.     printf("  (3)串s1的长度:%d\n",StrLength(s1));    
  13.     StrAssign(s2,"^_^");    
  14.     printf("  (4)输出串s2:");    
  15.     DispStr(s2);    
  16.     printf("  (5)串s2的长度:%d\n",StrLength(s2));    
  17.     printf("  (6)在串s1的第9个字符位置插入串s2而产生串s3\n");    
  18.     s3=InsStr(s1,9,s2);    
  19.     printf("  (7)输出串s3:");    
  20.     DispStr(s3);    
  21.     printf("  (8)串s3的长度:%d\n",StrLength(s3));    
  22.     printf("  (9)删除串s1第2个字符开始的3个字符而产生串s3\n");    
  23.     s3=DelStr(s1,2,3);    
  24.     printf("  (10)输出串s3:");    
  25.     DispStr(s3);    
  26.     printf("  (11)串s3的长度:%d\n",StrLength(s3));    
  27.     printf("  (12)将串s1第2个字符开始的5个字符替换成串s2而产生串s3\n");    
  28.     s3=RepStr(s1,2,5,s2);    
  29.     printf("  (13)输出串s3:");    
  30.     DispStr(s3);    
  31.     printf("  (14)串s2的长度:%d\n",StrLength(s3));    
  32.     printf("  (15)提取串s1的第2个字符开始的10个字符而产生串s4\n");    
  33.     s4=SubStr(s1,2,10);    
  34.     printf("  (16)输出串s4:");    
  35.     DispStr(s4);    
  36.     printf("  (17)串s4的长度:%d\n",StrLength(s4));    
  37.     printf("  (18)将串s2和串s3连接起来而产生串s5\n");    
  38.     s5=Concat(s2,s3);    
  39.     printf("  (19)输出串s5:");    
  40.     DispStr(s5);    
  41.     printf("  (20)串s5的长度:%d\n",StrLength(s5));    
  42.     return 0;    
  43. }    
运行结果：



知识点总结：

定义链串的算法库。

学习心得：

要捋清思路。

标签
#c语言 #栈 #算法 #计算机 #库
cc1562cxl
关注
用Unity Wheel Collider做坦克转向？3步实现履带式载具物理效果
最新发布
weixin_29009971的博客
03-06 186
本文详细解析了如何利用Unity的Wheel Collider组件实现履带式载具的差速转向物理效果。通过思维转换、场景搭建和核心代码实现三步，将Wheel Collider从模拟轮式车辆转向改造为控制履带扭矩差的系统，并深入探讨了参数调试与真实感提升的方法，帮助开发者打造物理反馈扎实的坦克或特种车辆模拟。
超详细neo4j安装教程
热门推荐
qq_38335648的博客
03-20 9万+
一、neo4j简介 最近开始学习知识图谱，所以首先想先学习一下neo4j的使用。 Neo4j是一个高性能的,NOSQL图形数据库，它将结构化数据存储在网络上而不是表中。由于知识图谱中存在大量的关系型信息（实体—关系—实体）, 使用结构化数据库进行存储将产生大量的冗余存储信息, 因此将图数据库作为知识图谱的存储容器成为流行的选择。当前较为常用的图数据库主要有 Neo4j 等。 二、neo4j的安装 功能快捷键 撤销：Ctrl/Command + Z 重做：Ctrl/Command + Y 加粗：Ctrl/Co
数据结构：串(c语言 链串，块链和串的模式匹配KMP算法)
weixin_46015333的博客
05-10 1759
串 定义： 串是特殊的线性表，串(string)是零个或多个字符组成的有限序列。一般记作s=“a1a2…an”，其中s是串名，双引号括起来的字符序列是串值；ai(1≦i≦n)可以是字母、数字或其它字符；串中所包含的字符个数称为该串的长度。 长度为零的串称为空串(EmptyString)，它不包含任何字符。 通常将仅由一个或多个空格组成的串称为空白串(Blank String) 注意：空串和空白串的不同，例如“ ”和“”分别表示长度为1的空白串和长度为0的空串。 子串：串中任意个连续字符组成的子序列。
字符串数据结构实现(链表方式)
03-06
字符串数据结构实现(链表方式) 支持中文操作
c语言描述链串的类型定义,数据结构第四章：串
weixin_42121058的博客
05-21 753
4.1 串类型的定义字符串可以看作是一种特殊的线性表，字符串的数据对象约束为字符集(非数值数据)。不同的应用所处理的串的特点亦不相同。在线性表的基本操作中，大多以“单个元素”作为操作对象，而在串中则是以“串的整体”或一部分作为操作对象。串的定义：串(String)是零个或多个字符组成的有限序列。一般记为：s=′a1a2…an′ (n≥0)s是串的名字， a1a2…an是串s的值ai可以是字母、数...
!实现链串各种基本运算的算法
小凤的博客
01-27 2098
/*algo4-2.cpp*/ #include #include typedef struct snode {  char data;  struct snode *next; }LiString; void StrAssign(LiString * &s,char t[]) {  int i;  LiString *r,*p;  s=(LiString *)malloc
第八周项目2 建立链串算法库
zxk201458506144的博客
11-03 532
/* *Copyright (c) 2015,烟台大学计算机学院 *All rights reserved. *文件名称：shunxuchuan.cpp *作者：朱希康 *完成日期：2015年10月30日 *版本号：vc++6.0 * *问题描述：建立顺序串算法库 *输入描述：无 *程序输出：子串，串连接，串删除，串插入等 */ #ifndef HEAD_H_INCL
第八周项目2—建立链串的算法库
mlk5739_csdn的博客
10-21 538
copyright （c） 2016，烟台大学计算机学院    All rights reserved.    文件名称：1.cpp    作者：孟令康   完成日期：2016年9月12日    版本号：v1.0    问题描述：定义链串的存储结构，实现其基本运算，并完成测试。                     要求：（1）建立串s：abcdefghijklmn 和
第八周 项目2 建立链串的算法库
S1E2L3的博客
10-20 284
问题及描述：
第八周 【项目2 - 建立链串的算法库】
qq_39837019的博客
12-14 302
/*   *Copyright  (c)2017,烟台大学计算机与控制工程学院       *All rights reservrd.            *作者：李欣豪  *完成时间：2017年12月14日       *版本号：v1.0       *问题描述：定义链串的存储结构，实现串的基本运算，并完成测试。 一、头文件liString.h#ifn
第八周 项目2-建立链串的算法库
q6826的博客
10-26 456
/* *2015，烟台大学计算机控制工程学院 *All rights reserved *文件名称：liString.cpp *作者：邱暖 *完成日期：2015年10月26号 *问题描述：定义链串的存储结构，实现其基本结构，并完成测试。 */（1）建立头文件liString.h#ifndef LISTRING_H_INCLUDED #define LISTRING_H_INCLUD
第八周项目2——建立链串的算法库
qxl1057223919的博客
10-20 611
问题： /* * Copyright (c)2016,烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称：项目2.cpp * 作 者：秦绪龙 * 完成日期：2016年10月20日 * 版 本 号：v1.0 *问题描述：定义链串的存储结构，实现其基本运算，并完成测试。 *输入描述：无 *程序输出：测试数据 */
第八周项目2--建立链串的算法库
sdchenzhe的博客
10-20 284
问题及代码： /* Copyright (c)2016,烟台大学计算机与控制工程学院 All rights reserved. 文件名称：项目2.cpp 作 者：陈哲 完成日期：2016年10月20日 版 本 号：v1.0 问题描述：定义链串的存储结构，实现其基本运算，并完成测试。 输入描述：无 程序输出：测试数据 */ 头文件LiString.h代码：
第八周项目2 -建立链串算法库
zwj201558506220的博客
10-14 722
问题描述及代码 /*     *烟台大学计控学院      *作    者：张雯婧    *完成日期：2016年10月14日  *问题描述：定义链串的存储结构，实现串的基本运算，并完成测试。  */   1.liString.h的代码 #ifndef LISTRING_H_INCLUDED #define LISTRING_H_INCLUDED typedef struct snode {
基于MATLAB的带载流子密度双温模型与德鲁德模型仿真：电子晶格温度及飞秒激光源模拟 双温模型
内容概要：本文详细介绍了带载流子密度的双温模型及其在MATLAB中的实现。双温模型用于描述电子和晶格温度之间的相互作用，以及带载流子密度随时间的变化。文中探讨了电子晶格温度与电子密度的关系，特别是在飞秒激光源照射下材料的行为。通过MATLAB进行飞秒激光源模拟，观察电子和晶格温度的变化，以及带载流子密度的动态变化。同时，采用有限元法求解涉及的偏微分方程，展示了具体的MATLAB编程实践步骤，包括定义材料参数、建立数学模型、选择数值解法和优化代码性能。适合人群：从事材料科学研究、物理建模和仿真工作的科研人员和技术爱好者。使用场景及目标：适用于希望深入了解材料中电子与晶格相互作用机制的研究人员，以及希望通过MATLAB进行相关仿真的技术人员。目标是掌握双温模型的基本原理和应用，提高对材料特性和行为的理解。其他说明：本文不仅提供了理论背景，还给出了详细的编程实践指导，帮助读者从零开始构建和优化仿真模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值