创新实践实验报告

创新实践实验报告（精选8篇）

创新实践实验报告篇1

课程名称：

学生学号：

所属院部：

（文科类）

创新创业实践专业班级： 12物流管理(2)韩怡洁学生姓名： 1201107042

商学院指导教师：顾姝玲 14 ——20 15 学年第 2 学期

金陵科技学院教务处制

实践报告书写要求

实践报告原则上要求学生手写，要求书写工整。若因课程特点需打印的，要遵照以下字体、字号、间距等的具体要求。纸张一律采用A4的纸张。

实践报告书写说明

实践报告中一至四项内容为必填项，包括实践目的和要求；实践环境与条件；实践内容；实践报告。各院部可根据学科特点和实践具体要求增加项目。

填写注意事项

（1）细致观察，及时、准确、如实记录。（2）准确说明，层次清晰。（3）尽量采用专用术语来说明事物。

（4）外文、符号、公式要准确，应使用统一规定的名词和符号。（5）应独立完成实践报告的书写，严禁抄袭、复印，一经发现，以零分论处。

实践报告批改说明

实践报告的批改要及时、认真、仔细，一律用红色笔批改。实践报告的批改成绩采用百分制，具体评分标准由各院部自行制定。

实践报告装订要求

实践报告批改完毕后，任课老师将每门课程的每个实践项目的实践报告以自然班为单位、按学号升序排列，装订成册，并附上一份该门课程的实践大纲。

实践项目名称：创新创业实践-模拟企业经营实践学时： 20 同组学生姓名：翁楠1201107102

实践地点： 7204 实践日期：第3～7周周四1～4节实践成绩：批改教师：批改时间：

指导教师评阅：

一、实践目的和要求

使学生掌握公司创建和运营的基本策略和方法，了解公司运营所涉及的生产制造、研发、人力资源管理、营销、财务等若干要素的综合运用，对创新活动形成初步认识。

二、实践环境与条件 7204教室创业之星软件

三、实践内容

(一)(二)(三)学习创业之星软件的基本功能、学习创业之星软件的基本功能。选择玩具市场, 进行公司创建的各项筹备活动。

完成六阶段的模拟操作，并在每个阶段及时为后续阶段的策划进行方案再设计。(四)撰写创业活动实践报告, 对创业活动总结

四、实践报告（附件）

创新创业实践心得体会

将近五周的时间，我们小组学习创业之星软件的基本功能，学习创业之星软件的基本功能，我们选择了玩具市场，一共进行了六个阶段的模拟学习。

我们创建了“呵呵哒”玩具公司，公司主要有制造部，研发部，人力资源部，市场部这几个主要部门，各个部门分工明确，接下来我分别对这几个部门所做的工作进行介绍。

首先是制造部，我们进行原料采购、厂房购置、设备购置、资质认证和生产工人这几项主要工作。在购买原材料方面，我们前期投资比较大，原因是我们主要考虑了原料的价格波动和折扣还有到货周期这几个方面，前期购买原材料的价格比较低，而且买的多的话会有折扣，这在总体的投资方面可以省下一部分投资，所以我们前期购买原材料的投资较大。然后是厂房购置，一共是大型厂房、中型厂房、小型厂房，设备购置有柔线型、自动线和手工线这三个。在资质认证方面我们选择了ZSO9001认证，一共花了两个周期认证，每个周期3万。在研发部，我们进行了产品设计和产品研发两方面的工作，我们设计了四种玩具。在人力资源部，有签订合同，解除合同和员工培训三方面的工作，在第一季度我们招了一个工人一个业务员，第二季度招了两个一个业务员，第三第四季度也都招了一个工人，第三季度招了一个业务员。市场部有市场开发和广告宣传两方面工作，除了北京之外，我们先后开发了上海广州和武汉三个市场，上海和广州花了一个周期的时间和两万，武汉用了两个周期一共四万。在广告宣传方面，投入随着时间的推移，影响力逐渐减弱。最后是销售部门包括销售人员和产品保价这两个主要工作，北京上海广州武汉我们各投入了一个销售人员，我们根据最终给出的最低价和最高价选择我们认为最合适的报价。

通过我们组员的努力，我们组每个季度的最终成绩的排名都是第一名，但是我们还是有在很多方面存在着不足，我们到第五季度的时候有较多的存货没有交货，之前我们的报价较高，导致我们的市场占有率不是很高。但是在这六个季度的模拟实践中，我们学习到很多，知道在一个公司生产运作方面有很多复杂的事情，从产品的研发到最终产品投入到市场都有很多问题要考虑，每一步都需要谨慎的思考，不仅仅是需要创新更需要丰富的专业知识。

-撰写创业计划书实践学时： 20 同组学生姓名：实践地点：校外

实践日期：第3～7周实践成绩：批改教师：批改时间：

指导教师评阅：

一、实践目的和要求

创业计划是创业者在初创企业成立之前就已经准备好的一份书面计划，用来描述创办一个新的企业时所有的内部和外部要素。当创业者选定了创业目标与确定创业的动机之后，而在资金、人脉、市场等各方面的条件都已准备妥当或已经累积了相当实力，这时候，就必须提出一份完整的创业计划书，创业计划书是整个创业过程的重要内容，在创业计划书中，应详细描述一切和创业相关的内容，包括创业种类、资金规划、阶段目标、财务预算、营销策略、风险防范、管理规划等等，在创业的过程中，这些都是不可或缺的元素。

创业计划书不仅能让创业者清楚明白自己的创业方向与主要内容，坚定创业的发展目标，而且也是对创办企业进行有效宣传推广的资料。通过创业计划书，可以更好的向风险投资商、银行、政府部门等外部相关机构介绍企业及其发展规划，为企业筹措资料、吸引投资带来帮助。在企业成立以后的初期经营管理中，创业计划书也可以为企业管理者提供必要的经营指导与评价标准。

要求每组完成一份创业计划书的书写，创业计划书要求：语言通顺、流畅，结构清晰，逻辑性强，观点正确、富有较强的可行性与一定的创新性。

二、实践环境与条件校外调研

三、实践内容

百元创业心得体会

每个小组集资100元，自选投资项目完成项目的创业计划和实际投入运营。一份完整的创业体会主要包括以下内容：计划摘要；项目简介；市场分析；竞争分析；产品与服务；市场营销活动的过程与经验总结；财务报告等。

创新实践实验报告篇2

当今世界, 科技创新是提高社会生产力和综合国力的战略支撑, 是驱动国家发展的核心动力, 为此十八大报告明确提出实施创新驱动发展的战略。创新离不开创新型人才, 创新型人才兼具知识面宽、理论基础扎实、实践能力强、综合素质高、创造性思维活跃、团队意识强等特质[1]。高等工程教育对于培养创新型人才的重大任务责无旁贷。

二、现阶段创新人才培养方面存在的问题

基于创新性人才培养的目标, 近10多年来高等工科院校教学改革如火如荼地进行着, 并已经取得了令人欣慰的成果。比如, 学科发展兼顾深度和广度, 开设跨学科公选课程拓宽学生的知识面, 开设专业性强的选修课程为精英学生提高专业素养提供机会;充分认识到实践教学在培养学生创新能力方面的重要作用[2], 配合理论教学的实验、课程设计、实习等实践环节在教学中的比重不断提高;各类以服务社会为宗旨的科技类竞赛层出不穷, 促使学生从简单的模仿与重复的学习方式向理论联系实际, 注重工程能力养成的学习方式转变等等。

尽管各大工科院校的教学改革成果斐然, 但若要实现创新型工程人才的培养目标, 教学改革在很多方面仍需不断深化。比如, 尽管为了培养学生的工程意识和理论联系实际的能力, 实践环节比重增加, 实验课时数增多, 但实验教学内容多数仍为匹配少数甚至是单一知识点的验证性实验, 综合设计型实验比例少, 难以全面锻炼学生发现问题、分析问题和解决问题的综合能力;在为数不多综合设计型实验的教学过程中, 学生往往只需按照实验要求和操作提示完成实验, 实验过程没有给学生提供自由思考、发挥、创造的机会, 只单纯地锻炼了学生的动手能力, 却仍然未能增强学生的创新意识, 促成学生创新性思维模式的形成, 提高学生创新性解决问题的能力[3]。

为充分发挥实验教学在培养学生创新能力方面的重要作用, 我校从2002年开始, 面向机械类大二本科生开设了“慧鱼创意组合模型”综合实验项目。该实验项目设立之初旨在通过利用德国慧鱼公司开发的慧鱼系列产品教具创意组合、搭接出实现一定功能的完整机械系统模型的过程, 使学生熟悉机械系统概念, 掌握机械系统运动方案设计方法, 锻炼学生综合设计能力, 提高学生创新意识和创新能力。该创意实验已开设10余年, 然而受6学时学时数的限制, 实验教学过程一直围绕着范例式教学开展。即学生往往只是从参考手册中选取一个机械模型, 按手册给出的步骤搭接、调试完成。整个实验过程只是在简单的模仿中获取相应的技术知识, 未能体现出创意实验开设的真正意图, 没能充分立足学生, 充分激发学生思考、学习和设计热情, 没能全面锻炼学生的综合设计能力, 没有提供给学生创新创意机会, 提高学生的创新能力更是无从谈起。

三、以创新能力培养为目标的实验教学新模式构建

1.“慧鱼创意模型组合实验”简介。

慧鱼创意组合模型是由德国慧鱼公司开发的工程技术类智趣拼接模型, 部件采用优质尼龙塑胶制造, 主要包括机械构件、各类传感器、微型电机、气动元件等。工业燕尾槽的专利设计, 使得各部件能够任意组合、反复拆装, 随心所欲搭接实现特定功能的机械系统模型。并可以利用计算机和控制软件, 通过接口板实现对机械系统的自动控制。该模型是展示机械系统运动方案和设计原理的理想教具, 是运动方案创意设计的便捷验证手段, 为创新教育和创新实验提供了最佳的载体。为充分发挥该实验在提高学生研究性学习能力和综合设计能力, 增强学生的创新意识和创新能力方面的优势, 克服原有实验教学模式的不足, 自2013起开始构建以学生为主, 教师为辅, 项任务驱动的研究性实验教学新模式, 并面向学生进行试验性实施和逐步推广。新教学模式以激发学生探索激情、提高学生研究性学习和创新性实践能力为目标, 在明确实验任务是设计、搭接和运行符合主题要求的机械系统模型的前提下, 促使学生自主且有计划地进行作品前期准备、设计方案实施和结果整理, 最终由教师给出成绩评定结果。整个实验过程强化学生的主体地位, 教师只起辅助引导作用。

2. 实验教学新模式实施。

(1) 作品前期准备:这是整个实验过程最核心、最关键的一步, 却不占用分配的实验学时, 需在正式进入实验室之前完成。学生从已建设好的实验课程网站中获取实验任务、主题, 了解作品要求和成绩评定方法、准则, 下载需自学的相关知识的文档和视频资料。学生自由成组, 建议4~6人, 确定设计主题, 贴近工程实际设定功能要求, 自行查阅参考资料、讨论功能实现原理, 发散思维, 综合运用和拓展各学科知识, 创造新方案, 也可对现有方案进行合理科学地改进, 初步完成机械系统的运动方案设计, 绘制出系统运动方案草图。 (2) 设计方案实施:正式进入实验室, 领取慧鱼组件, 按设计方案进行模型搭接、程序编制和系统调试, 在此过程中不断修改、完善初始设计, 及时捕捉创意性想法, 实践检验其可行性和合理性, 完成系统运行演示, 确定机械系统的最终运动方案。 (3) 整理设计资料, 撰写实验报告并提交。实验报告中需详细陈述作品的设计背景、功能、原理、运动方案、创新点、成果和应用意义。

3. 教师辅助工作。

为保证实验过程每一环节的顺利实施, 实验指导教师须在相应环节做足准备工作, 包括:建设实验课程网站。将实验任务、主题、实施前准备内容、作品要求、成绩评定方法和准则以及范例参考等在网站上公布, 网站上同时提供自学内容下载, 充分利用网络平台克服实验学时限制。开学初, 理论课教师要提示学生到课程网站上了解实验相关内容, 尤其是实验任务、主题和作品要求, 下载并学习需自学的相关文件。设计作品主题。作品主题设计是实验能否顺利实施的关键问题之一, 既要结合我校的学科优势 (如工程机械、装备制造、汽车构造、仿生机械等) , 又要贴合工程实际, 兼顾实验面向机械工程类学生的适应性, 同时还要考虑学时限制。利用《机械原理》课堂教学 (30分钟之内) , 教师或参加过创新大赛的学生进行基本技能讲解 (包括搭接模型和软件编程) 和主题作品准备辅导, 引导学生贴近工程实际发现和分析问题, 创新性解决问题, 帮助学生对初步设计的机械系统运动方案进行可行性分析。关注项目实施过程, 及时启发学生进行创意性思考。如搭接挖掘机工作装置, 学生设计方案时通过自由度计算确定需要3个原动件, 这时可以启发学生用2个能不能实现挖掘功能?工作性能差别在哪里?这一过程对启发学生的创新思维, 提高学生的创新能力十分重要。指导教师对实验作品进行成绩评定, 需综合考虑作品的完成情况、创新性、实验报告的撰写情况和学生个体在作品设计、实施和调试过程中的参与情况, 最终给出每个学生的实验成绩。

4. 实验教学新模式实践效果。

实验教学新模式首先在机械工程专业的卓越班中进行了实践, 图1为学生作品示例。

完成本实验后, 学生普遍反映熟悉了机械系统运动方案设计的全过程, 理解了机电一体化系统的内涵, 了解了自己知识结构中的不足之处, 深刻认识到创新在产品设计中的重要性, 是应用所学理论知识解决工程问题的一次有效实践, 是一次从大量信息中提取有用信息, 并进行发散性思考、升华、演化成创意性设计的有益尝试, 同时深刻意识到团队合作、分工协调的重要性。

四、结束语

从上述论述可以看出, 基于“慧鱼创意组合模型实验”构建的研究性实验教学新模式, 真正突出了学生在实践过程中的主体地位, 通过明确的贴合工程实际的设计任务驱动学生积极主动地完成从资料信息收集、创意构思、运动方案设计、可行性分析、方案实施到结果整理的研究性学习全过程。激发了学生的探索激情, 培养了学生的综合设计能力, 启发了学生的创新思维, 增强了学生的创新意识, 实践效果较好, 适合推广, 使更多学生受益。

摘要：以激发学生的探索激情、培养学生的综合设计和创造性思维能力为目标, 基于“慧鱼创意组合模型实验”构建了研究性实验教学新模式。该模式借助网络平台, 克服学时限制, 通过设置贴合工程实际的设计任务, 驱动学生主动、创造性地完成实验作品前期准备、设计方案实施和结果整理的研究性学习全过程。新模式实践效果较好, 适合面向更多学生推广。

关键词：实验,创新,教学模式

参考文献

[1]杨洪涛, 张新.慧鱼模型在机电类创新型人才培养中的应用[J].科技信息, 2010, (20) :420-422.

[2]张仕娥, 缪芸芸.机械工程类学生创新教育调查与探析[J].江苏科技大学学报:社会科学版, 2006, 6 (4) :101-104.

创新实践实验报告篇3

[关键词]物理实验教学培养创新能力

物理是一门以实验为基础的科学，通过实验能很好地培养学生的动手实践能力。当前农村学校的实验教学一直没有从根本上重视起来，大多数还是以教师“讲”实验为主。这种教学方法违背了教育教学规律，长期以来造成了教师、学生做实验的兴趣淡漠，甚至根本不想做或不去做，因此调动学生做实验的积极性和主动性就显得特别重要，要想做到这一点，我们全体师生必须从根深蒂固的“应试教育”的圈子里跳出来，冲进素质教育的潮流中，去加强我们的实验教学，培养学生的创新能力，下面谈谈我在教学实践中的几点体会，让我们共同探讨、交流、提高。

一、努力增强物理实验教学的趣味性，培养学生主动做实验的欲望

只有学得有趣，学生才会产生做实验的欲望，主动地做，才能做得好。怎样才能使“兴趣”成为最好的老师呢?众所周知，实验教学是“师生”共同的双边活动，学生是课堂的主人，应以学生活动为中心。

因此，实验中，教师应努力为学生创造参与主动学习的机会和条件，充分调动学生的积极性和兴趣性。其次要信任学生，相信他们能够做好，即使做得不太规范，也要鼓励他们下次做好。如果做得很好，应替他们鼓掌喝彩。最后，教师上课时应千方百计地增强实验教学的趣味性，要善于布阵设疑，创设问题的情景，引导学生生动活泼地学习，使学生在整个过程中充满乐趣，积极探索。

如，我在讲“电功率的计算”一节时，我首先提出问题：为什么家里深夜的灯比傍晚要明亮得多，这是什么原因呢?顿时课堂上议论纷纷，课堂上气氛活跃，产生了浓厚的兴趣和强烈的求知欲望，同学们各抒己见，然后我又画图分析并结合演示实验，顿时同学们豁然开朗，起到了“山穷水复疑无路，柳暗花明又一村”的效果，增强了同学们学习的兴趣。

二、让学生当回老师过把瘾，培养学生的创新能力

演示实验是物理课堂教学的重要组成部分，深受教师们的重视，很多教师教学时都能认真做，仔细讲，也做得比较准确，操作规范，但这种“教师当演员学生为观众”的做法，忽略了学生是课堂的主人，同学们只能过“眼瘾”，自己体会不到其中的乐趣和奥妙，时间长了也就“视而不见”了。

针对上面的片面教学方法，如何进行改进呢?

教师应先把握教材中所有的演示实验，有针对性地选择适宜的实验，让学生登台演示和讲解，例如“做功可以改变物体的内能”这个实验，将其放给了“学生”，我在一旁引导，台下学生注意观察“老师”的操作步骤是否正确，并提示“老师”注意指导学生观察实验现象，虽然当时的效果并不太明显，但台上的“老师”累得满头大汗，做得小心谨慎，力求规范，台下的学生看得仔细、精力集中。这样既增加了学生动手的机会，又便于发现“老师”存在的问题，同时还使学生有较强的新鲜感和兴奋点，从而也培养了学生一定的创新能力。

三、让学生参与实验课的准备工作

初中学生实验大部分都由学生做了，但是实践证明：部分学生对有些仪器还不会使用，甚至不认识，操作能力低，究其原因；因为他们只重视实验结果，不重视过程，我认为主要责任在于教师，实验的准备过程都被教师或实验员包办了，学生到了实验室，有现成的器材，只测量一下结果，然后走之，没有弄清事情的来龙去脉。

针对上述现象，如何改变呢?

第一，如果某个实验学校器材都有，应让学生自己挑选，然后教师检查，像顾客在“超市”中选择商品一样。随心所欲，

第二，如果学校没有的器材，让学生动脑想办法，这样也便于培养学生的创新能力。

四、做课外小实验，充分挖掘学生的创造潜力

初中物理教材中的课外小实验有30多个，在整个实验内容中占有相当大的比例，是学生实验的重要组成部分，也是学生发挥创造潜力的重要阵地，同时也是实验教学的一种有效补充和延伸。但大多数教师没重视小实验的教学，这不仅是实验教学的空白，而且也不利于学生创新能力的培养和挖掘。

针对上述现象，我安排了间周一次的学生小实验，并亲自检查、指导。

如一次要求学生做“筷子提米”这一实验，那场面可热闹了，因为方案的设计、器材的使用及管理、现象的观察和实验结果的分析、数据的处理等环节均由学生独立完成，并在过程中遇到的各种问题也由他们自己独立解决，当时我看到一位同学做这一实验，开始时并没有成功，但通过一次次的实验，终于悟出了一些道理：摩擦力的大小与加水的多少与加水后的时间有关，还与大米压紧的程度有关，最后还是成功了，脸上也露出了笑容，因为他的“创新”能力有了提高。

综合实践实验报告篇4

本学期我们学校又有新的学年加入此项活动。这次综合实践活动是一次社会活动，全体实验年级利用假期时间走出校门，走出课堂，走进了社会这个大课堂的不同角落，他们积极热情地对待自己的这项活动。

在本次活动的初期准备阶段，各个班级的班长和其他的班级干部协同班主任老师进行了周密的安排，保证了这相活动的有序进行。活动期间，同学们克服了各种困难，全身心地投入到活动中，用我们中学的独特视角和方式了解社会、感知社会，在活动中同学们的各种能力得到了发展，实践能力、劳动能力、对事物的辨认能力、交往能力等都有了一定的发展。在活动中，学生们学到了校园里、课堂上无法获取的知识和能力。

这次活动的末期是整理材料，书写实践报告，这一阶段小组同学撰写实验报告，首先在班级交流，然后各班选出三个优秀小组，每个小组又在学校的交流中经过评选，最后42组仅选出24组参加汇报。

活动中我们又聘请了孙茂霞、丁庆波、马玉平、刘敏、孙宗渊、李鹏、贾清松、范雪、尚云芳、孟小微、10位教师做初评评委，此后，黄校长和教务处主任对这次活动进行了三次检查。最后学校的成果汇报交流又聘请了范雪、王静、孟晓薇、丁庆波、马玉萍、贾青松为评委，李鹏、孙宗渊为记分员，同时还请到了宋玉洪、仁莹为这次活动全程照相。

本次活动在上次活动的基础上有了明显的进步。上学期一个学年就选出了29组参加汇报，本次我们学校两个学年选出24组进行汇报，很显然，我们对这次活动的要求提高了，汇报的质量也有了很大的进步，同学们的实践能力和汇报的能力也比以前更进步了。他们的成绩证明了“没有辛勤的一天，就没有最后的收获。

《计算机实践》实验报告篇5

—数据结构

班号： 0316102 学号： 031650106

姓名：郭砚璞 Email： 2755858446@qq.com

签名：

南京航空航天大学

2018年10月21日

目录…………………………………………………………2

实验一：约瑟夫斯问题求解………………………………3

实验二：停车场管理问题…………………………………12

实验三：管道铺设施工的最佳方案问题…………………25

实验四：内部排序算法的实现与比较……………………35

参考资料……………………………………………………44

源程序清单…………………………………………………44

实验一、约瑟夫斯问题求解

一、问题描述

1）问题描述

约瑟夫斯（Josephus）问题的一种描述是：编号为 1，2，…，n 的 n 个人按顺时针方向

围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值 m，从

第一个人开始按顺时针方向自 1 开始报数，报到 m 时停止报数。报 m 的人出列，将他的密码作为新的 m 值，从他在顺时针方向下一个人开始重新从 1 报数，如此下去，直至所有的人全部出列为止。试设计一个程序，按出列顺序印出各人编号。

2）实验目的与基本要求

利用单向循环链表存储结构模拟此过程，按照出列的顺序印出各人的编号。

3）测试数据

n=7，7 个人的密码依次为：3，1，7，2，4，8，4。m 初值为 6（正确的出列顺序应为

6，1，4，7，2，3，5）。

4）提示

程序运行后，首先要求用户指定初始报数上限 m，然后读取个人的密码。可设 n≤30。注意链表中空表和非空表的界限。

5）输入输出

输入数据：建立输入处理，输入 n 输入以及每个人的密码；m 的初值。

输出形式：建立一个输出函数，输出正确的序列。

6）选作内容

添加采用顺序存储结构实现问题求解的模块。

以上是本实验的题目要求，下面我将介绍我的实现算法，程序调试结果以及编程过程中遇到的具体问题，并且谈谈我的收获和感悟！

二、需求分析

1、本实验用于求出一组排列数的约瑟夫斯出列顺序。

2、程序运行后显示提示信息，提示用户输入人数n和初始报数上限m，程序需判断m与n的大小，如果m>n，需提示用户重新输入n值和m值。

3、m和n输入有效后，程序提示用户继续输入n个数据，作为n个人的密码。

4、用户输入完毕后，程序需自动显示输入的数据，并且按照出列顺序将n个出列者的编号结果显示出来。

三、概要设计

为了实现上述功能，应以循环链表的数据结构存储n个人的编号、密码信息和顺序关系，因此需要一个循环链表的数据类型。

1、循环链表抽象数据类型定义：

ADT CircularLinkList{

数据对象：一个循环链表，每个结点数据域是一个人的编号和密码。

数据关系：一个结点的指针域指向按照编号下一个结点。

基本操作：

CREATE_SL(SLNODE*);//构建顺序链表

ShowOutput(SLNODE *h, int m);//递归程序，按顺序依次输出出列者的编号

}ADT CircularLinkList

2、本程序保护模块

主函数模块

建立链表模块：将输入数据赋给结点数据域，并构建循环链表的数据关系

核心算法模块：按照算法移动指针、删除节点，依次输出出列者的编号。

调用关系：

3、算法流程图

四、详细设计

1.元素类型、结点类型和结点指针类型：

#define ElemType int

#define SLNODE struct sl_node

SLNODE

{

ElemType data[2];

SLNODE *next;

};

2、建立链表的伪码

SLNODE *CREATE_SL(SLNODE *h,int n)//创建一个h为头指针的链表，h指向的结点数据域用不到

{

ElemType data;

int i = 1;

SLNODE *p, *s;

p = h;

while(i<=n)

{

printf(“请输入第%d个元素:t”,i);

scanf_s(“%d”, &data);

s =(SLNODE *)malloc(sizeof(SLNODE));

s->data[0]=i;

s->data[1] = data;

if(h->next == NULL)

{

h->next = s;

}

else

{

p->next = s;

}

p = s;

i++;

}

p->next = h;

return h;

}

3、主函数伪码

int main()

{

int m,n,mistake=1;

SLNODE *Head;

PrintInformation1();//输出程序信息和个人信息

while(mistake)

{

printf(“输入人数n:n”);

scanf_s(“%d”, &n);

printf(“请指定初始报数上限m(m应必须小于等于n):n”);

scanf_s(“%d”, &m);

if(m>n)

{

printf(“输入数据有误，请重新输入n”);

}

else mistake=0;

}

Head =(SLNODE *)malloc(sizeof(SLNODE));

Head->next = NULL;

Head = CREATE_SL(Head,n);

ShowInput(Head,n);

printf(“正确的出列顺序为:rn”);

ShowOutput(Head,m);

PrintInformation2();//程序结束信息

system(“pause”);

return 0;

}

五、调试分析与核心算法解释

程序的调试主要是针对循环链表，所以调试对象明确，按照算法思路来调试，难度不大。

本题在建立好链表以后，开始执行核心程序ShowOutput递归函数，也就是想办法按照约瑟夫斯问题的规则来删除指针指向的结点、移动指针等，从而以一定排列输出n个人的密码。程序刚开始，先由用户依次输入人数n和初始报数上限m，并判断是否m<=n，如果m>n，则显示重新输入（程序并不会结束）。

然后程序建立头指针Head并且执行CREATE_SL函数，创建链表。

执行ShowInput函数，将n个人的密码依次输出。

下面开始执行本程序的关键函数，也是整个算法的核心函数ShowOutput，这也是整个算法的体现：

函数整体是个递归函数，运用递归的思想，效率很高，占用内存小，不需要设置标志位来判断是否某个结点被访问，而是访问到一个应该出列的结点“出列”，然后以此结点为下一次递归的头结点，然后删除本次递归程序充当头结点的那个结点。

图解：

h，p，s均为指向节点的指针，第一次执行此函数时，h指向头结点。

p指针寻找到要“出列”的节点，h指向要出列的结点作为下一次递归的新的头结点。

利用p指针和s指针重新改造循环链表,然后s指针用于记录本次递归的头结点位置，即将用于删除、释放空间。

下面执行free(s),删除所指内存空间，开始下一次递归调用。

后面执行递归函数时，h刚开始指向的是上一次输出的结点（还没删除），程序一开始先让s指向h，等这一趟程序快结束找到下一个要出列的结点时，h指向该结点作为下一次递归函数的头结点，并且让p找到s指向的充当本次头结点的结点，把它删除，再执行此递归程序。

终止条件是p->next=h，说明没有需要输出的节点了，于是便实现了递归。如图所示：

截图如图：

六、使用说明

按照程序界面指示输入即可，逐个整数数字输入，每输入一个数字按一个回车。

七、调试结果

按照测试要求进行了测试，结果如下：

八、遇到的问题及解决方法（程序调试日志）

2018/9/不详

问题：先建立了一个链表实现插入算法的小功能，再进行约瑟夫问题求解，结果程序不停的输出不完整的数据，陷入死循环。

解决：p指针所指空间逻辑上不该释放但被不正确释放，删去free(p)代码，一切正常。

2018/9/不详

问题：递归程序死循环。

解决：单步执行发现递归的终止条件不正确，修改为p->next=h，程序功能实现！

2018/10/20

最后一天，完善程序，将程序中的注释写清楚，百度找到了显示系统时间的方法，按格式输出，截屏、书写报告。

九、实验的收获与感想

个人感想：循环链表虽然不是很容易理解，但是处理约瑟夫斯这样的删除元素的操作真的十分便利，比起数组要方便的多。但是代价是编程要仔细，不要释放错内存空间。

个人方法优点：

1、建立链表时，将头结点和头指针同时运用，使头指针一开始指向头结点，这样操作方便，同时个人的算法要利用s删除上一次h指向的头结点，所以一开始让头指针指向一个头结点对于个人的算法是有一定好处的。

2、本人采用递归的算法，每次找到要出列的点后，先不马上删除结点，而是将h指针指向此结点作为下一次递归的h结点，等下一次递归找到新的出列结点并用h指向来作为头结点后，再将废弃结点删除，这样“改变头结点”，操作简便，很适合递归的条件。

个人方法缺点：本人认为此程序缺点是陌生人刚看到此程序不能马上理解，因为递归程序本身不易理解。所以为了更好给别人使用，本人已将程序注释的很清楚了。

建议：本实验很好，建议像第四题那样，增加一项计算程序空间复杂度和时间复杂度（移动次数）的要求，组织同学进行讨论，展示最优的算法。

十、源程序

见源程序清单。

实验二、停车场管理问题

一、问题描述

1）问题描述

设停车场是一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端）。若停车场内已经停满 n 辆车，那么后来的车只能在门外的便道上等候。一旦有车开走，则排在便道上的第一辆车即可开入。当停车场内某辆车要离

开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再

按原次序进入车场。每辆停放在车场的车在它离开停车场时必须按它停留的时间长短缴纳

费用。试为停车场编制按上述要求进行管理的模拟程序。

2）基本要求

以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入数据的序列进行模拟管

理。每一组输入数据包括三个数据项：汽车的“到达”（‘A’表示）或“离去”（‘D’表示）信息、汽车标识（牌照号）以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或者便道上的停车位置；若是车辆离去，则输出汽车在停车场停留的时间和应缴纳的费用（便道上停留的时间不收费）。栈以顺序

结构实现，队列以链表结构实现。

3）测试数据

设 n=2,输入数据为：（‘A’，1，5），（‘A’，2，10），（‘D’，1，15），（‘A’，3，20），（‘A’，4，25），（‘A’，5，30），（‘D’，2，35），（‘D’，4，40），（‘E’，0，0）。每一组输入数据包括三个数据项：汽车 “到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，其中，‘A’表示到达；‘D’表示离去，‘E’表示输入结束。其中：（‘A’，1，5）表示 1 号牌照车在 5 这个时刻到达，而（‘D’，1，15）表示 1 号牌照车在 15 这个时刻离去。

4）提示

需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车。输入数据

按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。

5）输入输出:

输入数据：

程序接受 5 个命令，分别是：到达（‘A’,车牌号,时间)；离去(‘D’,车牌号,时间)；停车场（‘P’, 0, 0）显示停车场的车数；候车场（‘W’, 0, 0）显示候车场的车数；退出（‘E’, 0, 0）退出程序。

输出数据：

对于车辆到达，要输出汽车在停车场内或者便道上的停车位置；对于车辆离去，则输出汽车在停车场停留的时间和应缴纳的费用（便道上不收费）。

二、需求分析

1、本程序用来模拟停车场进场、进便道、场外等候、出场、收费等操作。

2、程序运行后显示提示信息，提示用户输入停车每小时需缴纳的费用，用户输入后，提示信息提示用户输入命令：驶入停车场A，离开停车场D，查看停车场内车数P 0 0，查看候车厂内车数W 0 0，程序结束E 0 0。

3、程序需判断用户输入的进场出场时间的有效性，后来输入的时间要大于以前输入的时间。

4、用户输入有效命令后，程序显示汽车进出场信息，若是车辆到达，则输出汽车在停车场内或者便道上的停车位置；若是车辆离去，则输出汽车在停车场停留的时间和应缴纳的费用。

三、概要设计

为了实现上述功能，需要用栈模拟停车场，用一个备用的栈存储暂时出场的外部汽车，用队列模拟便道。

1、停车场“栈”抽象数据类型定义：

ADT stack{

数据对象：车牌号、进场时间、汽车数量

数据关系：先入后出

基本操作：

*Init_Parking();//置空栈

IsEmpty_Parking(Parking *s);//判空栈

Push_Parking(Parking *s,ElemType license,ElemType timeIn);//入栈

Pop_Parking(Parking *s,ElemType *license,ElemType *timeIn);//出栈

}ADT stack

2、备用存储“栈”抽象数据类型定义：

ADT stack1

{

数据对象：车牌号、进场时间、汽车数量

数据关系：先入后出

基本操作：

*Init_Backup();//置空栈

IsEmpty_Backup(Backup *s);//判空栈

Push_Backup(Backup *s, ElemType license, ElemType timeIn);//入栈

Pop_Backup(Backup *s, ElemType *license,ElemType* timeIn);//出栈

}

3、链式队列抽象数据类型定义：

ADT linkqueue

{

数据对象：车牌号、汽车数量

数据关系：先入先出

基本操作：

*Init_LQueue();//创建一个带头结点的空队

In_LQueue(LinkQueue *q, ElemType license);//入队

IsEmpty_LQueue(LinkQueue *q);//判队空

Out_LQueue(LinkQueue *q, ElemType *license);//出队

}

4、本程序保护模块

主函数模块

进场模块：对于进场的命令进行完善地操作处理并进行状态显示的模块

出场模块：对于出场的命令进行完善地操作处理并进行状态显示的模块

置空栈、置空队、进出栈、进出队、判栈空栈满、判队空队满模块：对栈、备用栈、队列进行的基本操作

调用关系：

5、算法流程图

四、详细设计

1、元素类型、结点类型和结点指针类型：

#define Maxsize 2 //停车场最多能停的车数

#define ElemType int

int Prize;//每停一个时刻收费多少元

static int num = 0;//num用于记录入队的车所在的位置

typedef struct stack //模拟停车场的栈

{

ElemType license[Maxsize];//用于存放车牌号

ElemType timeIn[Maxsize];//用于存放入停车场时间

int top;

}Parking;

typedef struct stack1 //退车时暂时存放

{

ElemType license[Maxsize-1];

ElemType timeIn[Maxsize-1];

int top;

}Backup;

typedef struct road

{

ElemType license;

struct road *next;

}Road;

typedef struct linkqueue//队列模拟便道

{

Road *front,*rear;

}LinkQueue;

2、部分基本操作的伪码类型

//给停车场用的配置函数

Parking *Init_Parking()//置空栈

{

Parking *s;

s=(Parking*)malloc(sizeof(Parking));

s->top=-1;

return s;

}

int IsEmpty_Parking(Parking *s)//判空栈

{

if(s->top==-1)

return 1;

else return 0;

}

int Push_Parking(Parking *s,ElemType license,ElemType timeIn)//入栈

{

if(s->top==Maxsize-1)

return 0;

else

{

s->top++;

s->license[s->top]=license;

s->timeIn[s->top]=timeIn;

return 1;

}

int Pop_Parking(Parking *s,ElemType *license,ElemType *timeIn)//出栈

{

if(IsEmpty_Parking(s))

return 0;

else

{

*license = s->license[s->top];

*timeIn = s->timeIn[s->top];

s->top--;

return 1;

}

//给备用栈配置的函数

Backup *Init_Backup()//置空栈

{

Backup *s;

s =(Backup*)malloc(sizeof(Backup));

s->top =-1;

return s;

}

int IsEmpty_Backup(Backup *s)//判空栈

{

if(s->top ==-1)

return 1;

else return 0;

}

int Push_Backup(Backup *s, ElemType license, ElemType timeIn)//入栈

{

if(s->top == Maxsize-1)

return 0;

else

{

s->top++;

s->license[s->top] = license;

s->timeIn[s->top] = timeIn;

return 1;

}

int Pop_Backup(Backup *s, ElemType *license,ElemType* timeIn)//出栈

{

if(IsEmpty_Backup(s))

return 0;

else

{

*license = s->license[s->top];

*timeIn = s->timeIn[s->top];

s->top--;

return 1;

}

//给候车便道链式队列配置的函数

LinkQueue *Init_LQueue()//创建一个带头结点的空队

{

LinkQueue *q;

Road *p;

q =(LinkQueue*)malloc(sizeof(LinkQueue));

p =(Road*)malloc(sizeof(Road));

p->next = NULL;

q->front = q->rear = p;

return q;

}

void In_LQueue(LinkQueue *q, ElemType license)//入队

{

Road *p;

p =(Road*)malloc(sizeof(Road));

p->license = license;

p->next = NULL;

q->rear->next = p;

q->rear = p;

}

int IsEmpty_LQueue(LinkQueue *q)//判队空

{

if(q->front == q->rear)

return 1;

else

return 0;

}

int Out_LQueue(LinkQueue *q, ElemType *license)//出队

{

Road *p;

if(IsEmpty_LQueue(q))

{

printf(”队空“);

return 0;

}

else

{

p = q->front->next;

q->front->next = p->next;

*license = p->license;

free(p);

if(q->front->next == NULL)

q->rear = q->front;

return 1;

}

3、主函数的伪码

void main()

{

ElemType license, time,timelast=0;//timeInlast是最近一次有车进停车场的时间，提示以后输入的进场时间要大于此数值

char command;//进入A还是离开D

Parking *s;

Backup *s1;

LinkQueue *q;

PrintInformation1();//输出程序信息和个人信息

s = Init_Parking();//停车场

q = Init_LQueue();//便道队列

s1 = Init_Backup();//退车时的备用栈

printf(”请输入停车每小时需交纳的费用（元）rn“);

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

scanf(”%d“,&Prize);

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

while(1)

{

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

Loop:printf(”请输入操作的命令，驶入停车场A，离开停车场D，查看停车场内车数P 0 0，查看候车厂内车数W 0 0，程序结束E 0 0:n“);

scanf(”%c%d%d“,&command, &license,&time);

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

if(command == A)

{

if(time <= timelast)

{

printf(”输入的时间必须大于上一次输入的时间:t“);

printf(”%dt“, timelast);

printf(”请重新输入n“);

goto Loop;

}

else

{

timelast = time;

GetIn(s,q,license,time);

}

if(command == D)

{

if(time <= timelast)

{

printf(”输入的时间必须大于上一次输入的时间:t“);

printf(”%dt“, timelast);

printf(”请重新输入n“);

goto Loop;

}

else

{

timelast = time;

GetOut(s, s1, q, license, time);//车开走的函数

}

if(command == P)

{

if(license == 0 && time == 0)

printf(”停车场内停了%d辆车n“,s->top+1);//显示停车场车数

}

if(command == W)

{

if(license == 0 && time == 0)

printf(”侯车场内停了%d辆车n“,num);//显示候车场车数

}

if(command == E)

{

if(license == 0 && time == 0)

{

PrintInformation2();//程序结束信息

system(”pause“);

return;

}

五、调试分析与核心算法解释

程序本身是利用栈、队列的进出完成停车场汽车进出场的模拟的，只要按照模块化的函数，按照基本的逻辑编写，调试是比较容易的。

程序一开始会要求用户输入每小时缴纳多少元费用，显示“请输入停车每小时需交纳的费用（元）”。

以栈模拟停车场，以队列模拟车场外的便道，在while循环开始让用户输入命令、车牌号、时间三个变量，对三个变量进行判断，并执行相应函数。

程序显示“请输入操作的命令，驶入停车场A，离开停车场D，查看停车场内车数P 0 0，查看候车厂内车数W 0 0，程序结束E 0 0:”

如果后来输入的时间比之前输入的时间小，程序会提示“输入的时间必须大于上一次输入的时间: xx 请重新输入”。

其中驶入函数先判断是否栈满，如果栈满则执行入队操作，否则入栈，并将车牌号、驶入时间存入栈元素数组，top值加一，用于记录车的数量，用于判断是否栈满。

如果栈不满，程序显示“车牌号为xx的汽车在xx时刻停在xx车位”。

如果栈满，程序显示“xx号车停在候车便道的第xx个位置”。

离开函数先判断是否栈空，如果栈空则输出没有车辆提示，否则进一步比较是否有栈内车牌号元素与命令的离开的车牌号一致，有则出栈，计算停车时间和计价，无则输出没有此车牌号的车的提示。

如果没有命令的车牌号的汽车，则显示“对不起！停车场内没有车牌号为xx的车”。

如果停车场已空，会显示“对不起！停车场已空！”。

如果原先栈满，离开一辆车以后，最早到便道上的一辆车进栈，并显示“xx号汽车此时退出便道，进入停车场最后一个位置”。

队列和栈的top记录了车的数量，可用于输出内部车数，也可用于判断是否栈满。

如果三个变量分别为P,0,0，则输出停车场内车的个数。

如果三个变量分别为E,0,0，则输出便道上车的个数。

如果三个变量分别为E ,0, 0,则结束程序。

六、使用说明

注意：命令字符（A D P W E）用大写，输入的三个数据之间用空格隔开。如A 1 5。代表1号1号汽车在5时刻进场。

七、调试结果

按照测试要求给的数据进行了测试：

八、遇到的问题和解决方法（程序调试日志）

2018/9/不详

问题：程序全部结束，执行时能基本完成功能，但是总是会间隔有一次命令无效，重复输出“请输入命令.......”。

解决方法：后来百度发现，这是因为数据缓存区没有清除的缘故，每次回车都会在数据缓存区遗留下来一个Enter字符，可被char型变量读取，因此在每次输入数据前后加入一个清除数据缓存区的函数setbuf(stdin, NULL)即可解决问题。

2018/10/20

最后一天，完善程序，将程序中的注释写清楚，百度找到了显示系统时间的方法，按格式输出，截屏、书写报告。

九、实验的收获与感想

个人感想：

这道题目和后面的第四道题目都是属于比较透彻的题目，先做了第二题，还是对第二题印象最深，首先这道题很讲究编程的条理性，里面的初始化栈、判栈空、栈满、入栈、出栈以及初始化队列、判队空、队满、入队、出队等函数在书上都有，主要的工作是利用模块化的思想，由整体到局部逐渐求精地去写整个程序，从而把整个停车场的5个命令功能给实现，感觉收获很多，模块化的思想很厉害！

方法的优点：

整体程序思路比较简单，因此个人没有什么更优算法，只是在这里面有一个逻辑，就是后面输入的时间不能比之前输入的时间小，因为这不符合日常逻辑，同时也影响了入栈出栈次序，因此我程序里使用了不常用的goto函数，一般这个函数是不建议用的，它会跳转程序，但是在这里判断后面输入的时间大于之前输入的时间后，goto函数可以让程序跳转到while循环开始的地方，让用户重新输入命令，这里感觉很方便！

建议：

希望多多布置这样的习题，有助于教会学生利用模块化思想，不过希望布置的题目可以是多方向的比如有关界面制作的题目，把模块化的函数给大家，大家进行使用，根据自己爱好设计出相应的模块化功能的程序。

十、源程序

见源程序清单。

实验三、管道铺设施工的最佳方案问题

一、问题描述

1）问题描述

需要在某个城市 n 个居民小区之间铺设煤气管道，则在这 n 个居民小区之间只需要铺设 n-1 条管道即可。假设任意两个小区之间都可以铺设管道，但由于地理环境不同，所需要的费用也不尽相同。选择最优的方案能使总投资尽可能小，这个问题即为求无向网的最小生成树。

2）基本要求

在可能假设的 m 条管道中，选取 n-1 条管道，使得既能连通 n 个小区，又能使总投资最小。每条管道的费用以网中该边的权值形式给出，网的存储采用邻接表的结构。

3）测试数据

使用下图给出的无线网数据作为程序的输入，求出最佳铺设方案。右侧是给出的参考解。

以上是本实验的题目要求，下面我将介绍我的实现算法，程序调试结果以及编程过程中遇到的具体问题，并且谈谈我的收获和感悟！

二、需求分析

1、此程序用来求无向带权网的最小生成树。

2、程序的输入数据放在一个dat格式的文件中，想要修改输入数据，用记事本打开文件直接修改即可。任何时刻想看到结果，点击一下exe文件即可一键解决。

3、输入数据的形式是一个矩阵形式，行和列的元素依次代表A、B、C....，两点之间有边，则数据是一个不为0的数，否则为0。

4、程序运行结果不仅会在控制台显示出来，同时还要在一个新的文件中显示出来，点击一下exe文件即可一键解决，满足用户“即点即看”，输出文件令用户能“随时且长久”看到结果，不必每一次都要运行程序。

三、概要设计

为实现上述功能，应以图的邻接表数据结构，即链表与数组相结合的数据结构。

1、邻接表抽象数据类型定义：

ADT ALGraph{

数据对象：结点A、B、C....数据关系：存储结构上链表式指针相连，物理结构上点之间相连成边

基本操作：CreateALGraph(ALGraph *G);//建立无向图的邻接表存储

}ADT ALGraph

2、文件操作模块

基本操作：

read_data(void);//只读方式打开文件

read_array(double *array,int n1,int n2,FILE *fp);//读取文件中的边值信息

cout_data(void);//只写方式打开或建立文件

cout_array(double *array,int n1,int n2,FILE *fp);//向文件中写入边值信息

3、本程序保护模块

主程序模块

建立无向图模块：根据读入文件的边值信息创建无向图邻接表存储

最小生成树模块：由无向图生成最小生成树

读入数据模块：只读方式读取文件数据

输出结果模块：将结果输出到控制台

输出到文件模块：将结果输出到文件

调用关系：

四、详细设计

需要建立一个无向图的邻接表存储结构，进行最小生成树的提取。

1、元素类型、结点类型和结点指针类型：

#define MaxVertexNum 100 //设置小区数最多为100

#define VertexNum 9

double LeastNum;//用于记录最短边长度

double LongestNum;//用于记录最长边长度，程序过程中不改变

double adjacent[VertexNum][VertexNum];

//邻接矩阵，不用于处理数据，而是用于暂时存储从文件读来的数据

//进而在邻接表存储数据时读取此数组数据即可

//二维数组数据为0的元素说明之间没有通道

//在处理完数据后，此数组会用来暂时存储处理后的数据，并写入到另一个文件中

typedef struct vnode

{//顶点表结点

char vertex;

EdgeNode *firstedge;

}VertexNode;

typedef struct

{

VertexNode adjlist[MaxVertexNum];

int n,e;

}ALGraph;

2、有序表类型：

typedef struct node

{//边表结点

char adjvex;

double weight;//权值

struct node *next;

}EdgeNode;

3、主函数的伪码：

void main()

{

ALGraph *G;

PrintInformation1();

G =(ALGraph*)malloc(sizeof(ALGraph));

G->n = VertexNum;//为G指向的图分配空间，设置点数（小区数）

read_data();

CreateALGraph(G);

MinimumSpanningTree(G);

cout_data();//输出到文件

ResultOutput((double *)adjacent,VertexNum,VertexNum);//输出到控制台

PrintInformation2();

system(”pause“);

}

4、算法流程图

五、调试分析与核心算法解释

此题按照Prim算法，设置一个用于存储点的点集，找短边从一个点向两点、三个....更多逐渐扩张，即可得到最小生成树。

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空；

3).重复下列操作，直到Vnew = V：

a.在集合E中选取权值最小的边，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合Vnew中，将边加入集合Enew中；

4).输出：使用集合Vnew和Enew来描述所得到的最小生成树。

具体可以参考资料：https://baike.baidu.com/redirect/cb1fkztQc2TOscNlcMemKsGZ1fsgTprJsdBq_APeZx74W4q4TzbKXHsvSYW_6aM1DqhF56eTgD8EZLzBCQHKBGa6ExWmgXbju_gm13Qbbu0KxbHuiIS_DxEp2fgT3BU

六、使用说明

输入数据已经在”gyp_program3_Input.dat“中写好，如果想做修改可以在该文件中修改即可，输出的数据既在控制台显示，也会输出到”gyp_program3_Output.dat“。

七、调试结果

输入数据文件：

这是一个矩阵，例如：第2行，第3列代表B，C两点间的边，0代表无边，不为0代表有边。

控制台程序显示：

输出数据到输出文件

八、遇到的问题和解决方法（程序调试日志）

2018/9/不详

问题：一进入建立无向图的函数程序就中止出错。

解决方法：给建立无向图函数传递的形参是指针，而在主函数中G指针没有赋给内存空间，所以函数无法对G所指的空间进行初始化，在主程序中加入这样一句代码就好了：

G =(ALGraph*)malloc(sizeof(ALGraph));

2018/10/17

问题：输出的二维数组只有一位正常，其余全是0。如下图所示：

解决方法：后来发现是里面flag2这个标志位刚开始是1，程序执行过程中被置0用于判断，但是判断以后没有再次重置为1，导致要用很多次的标志位只发挥了一次作用，后面就误判了，在循环结束加入重置1的语句即可。

问题：输出的二维数组输出数据不完整，里面总有最小的边（问题切入点）。

解决方法：单步执行后发现，某一次循环中Leastnum这个变量得到的最小值恰好是所有边中最小的一个，它在发挥完比较作用后，没有被置为一个很大的数（不小于这些边中最大值即可），结果在下一次循环的时候，导致后面的边都比它大，以至于后面的边都被舍去了，解决方法就是每次循环第一句先把原图的最大边赋给leastnum。

问题：直接运行debug文件夹里的exe程序，且debug程序终止，怀疑是文件数据读取失败，无法打开文件，即文件不存在。

解决方法：如果不详细说明文件路径，程序本身会在当前文件夹内找文件，存数据的文件gyp_program3_Input.dat要保存在当前文件中。也就是和源代码在同一个文件夹中，但是这样子的话，只有用编程软件打开代码运行，dat文件才有效，若想在debug里直接运行exe程序，则把存数据的输入文件同名复制到debug文件夹里即可。

九、实验的收获和感想

个人感想：这个程序可以说是算法感十足了，也是我遇到问题最大的一个程序，但是也证明了自己的能力，学到了很多，收获最大的就是：对于用的不止一次的标志位，一定不可能只单方向置位，一定是双向置位，一次循环结束一定要记得置位，否则用了这一次以后，后面的循环就会误判！

Prim算法真的很好用，不仅适合求带球图的最小生成树，还适合寻找一个点到另一点的最短路径。

个人方法优点：输入方便，输出简洁。读取文件中的数据，不用手动输入，想修改数据在文件中修改就可以，另外输出有两种形式，一种是控制台输出，一种是输出到文件，输出的是一个二维数组，行和列都有表头，看起来很清晰，两个点之间若有边，相应二维坐标的元素就是边值，无边则相应的位置为0。

建议：可以要求用顺序表的方法，因为从理解和编程难度角度考虑，图的邻接表找边会很慢每次都要顺着其中一个链表头结点去寻找，不过这也很锻炼人的能力！

十、源程序

见源程序清单。

实验四、内部排序算法的实现与比较

一、问题描述

1）问题描述

在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。

2）基本要求

(1)对常用的内部排序算法进行比较：直接插入排序、简单选择排序、冒泡排序、快速排序、希尔排序。

(2)利用随机函数产生N（如30000）个随机整数，作为输入数据作比较；比较的指标为关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。

(3)对结果作出简要分析。

3）测试数据

随机函数产生。

4）提示

主要工作是设法在已知算法中适当位置插入对关键字的比较次数和移动次数的计数操作。注意采用分块调试的方法。

5）输入输出:

输入数据：参加排序的整数个数 n（如 n=30000）；

输出数据：各种排序方法的关键字比较次数和移动次数（从小到大排列）。

二、需求分析

1、本程序用来比较5种排序的关键字比较次数和关键字移动次数。

2、本程序用srand()和rand()函数产生N个随机数用于排序方法的比较，用户无需输入。

3、运行程序后，程序需按从小到大的顺序分别输出5种排序的关键字比较次数和移动次数。

三、概要设计

为实现上述功能，程序需要产生N个随机数，并且需要写出这5种排序的排序函数。

1、产生N个随机数的方法

srand((unsigned)(time(NULL)));

for(int j = 0;j < N;j++)

{

num0[j] = rand();

}

2、保证每次排序的数据都相同的方法

num0数组用于得到随机数，num数组每次排序前先用num0数组赋值即可。

for(int j=0;j

{

num[j] = num0[j];

}

InsertSort(num,N);3、5种排序函数

void InsertSort(int R[], int n);//插入排序

void SelectSort(int R[], int n);//选择排序

void BubbleSort(int R[], int n);//冒泡排序

void QuickSort(int R[],int low,int high);//快速排序

void ShellInsert(int R[],int m,int n);//快速排序

void Shellsort(int R[],int n);//希尔排序

4、本程序保护模块

主程序模块

排序模块

比较输出模块

调用关系：

4、算法流程图

四、详细设计

1、排序函数基本操作的伪码实现

void InsertSort(int R[], int n)//插入排序

{

int i, j;

for(i = 2;i <= n;i++)

{

R[0] = R[i];

MoveNum[0]++;

j = i-1;

while(R[0] < R[j])

{

KeyCompareNum[0]++;

R[j + 1] = R[j];

MoveNum[0]++;

j--;

}

R[j + 1] = R[0];

MoveNum[0]++;

}

void SelectSort(int R[], int n)//选择排序

{

int i, j, k;

for(i = 1;i < n;i++)

{

k = i;

for(j = i + 1;j <= n;j++)

if(R[j] < R[k])

{

k = j;

KeyCompareNum[1]++;

}

if(k!= i)

{

R[0] = R[k];

R[k] = R[i];

R[i] = R[0];

MoveNum[1]+=3;

}

void BubbleSort(int R[], int n)//冒泡排序

{

int i, j, flag = 0;

for(i = 1;(i < n && flag == 0);i++)

{

flag = 1;

for(j=1;j

if(R[j + 1] < R[j])

{

KeyCompareNum[2]++;

flag = 0;

R[0] = R[j];

R[j] = R[j+1];

R[j + 1] = R[0];

MoveNum[2]+=3;

}

void QuickSort(int R[],int low,int high)//快速排序

{

int i,j;

i=low;

j=high;

R[0]=R[i];

MoveNum[3]++;

while(i

{

while((R[j]>=R[0])&&(j>i))

{

j--;

KeyCompareNum[3]++;

}

if(j>i)

{

R[i]=R[j];

MoveNum[3]++;

i++;

}

while((R[i]<=r[0])&&(j>i))

{

i++;

KeyCompareNum[3]++;

}

if(j>i)

{

R[j]=R[i];

MoveNum[3]++;

j--;

}

R[i]=R[0];

MoveNum[3]++;

if(low

QuickSort(R,low,i-1);

if(i

QuickSort(R,j+1,high);

}

void ShellInsert(int R[],int m,int n)

{//一趟希尔排序，按间隔m划分子序列

int temp,j;

for(int i=m;i

{

temp=R[i];

MoveNum[4]++;

j=i;

while(j>=m && temp

{

KeyCompareNum[4]++;

R[j]=R[j-m];

MoveNum[4]++;

j-=m;

}

R[j]=temp;

MoveNum[4]++;

}

void Shellsort(int R[],int n)//希尔排序

{

int m;

m=n/2;

while(m>=1)

{

ShellInsert(R,m,n);

m=(m==2?1:(m/2));

}

2、主函数伪码实现

int main()

{

//数组设为N+1个是因为有些算法是从数组1到N存储的，0位有的不用，有的用作了哨兵

int num0[N+1];//记录最原先随机产生的N个数字，因为num[N]每排序一次都会改变

int num[N+1];//每次排序前先读入num0[N]数据

//srand函数只增加一次就够了，用系统当前时间设置rand()随机序列种子，保证每次运行随机序列不一样

srand((unsigned)(time(NULL)));

for(int j = 0;j < N;j++)

{

num0[j] = rand();

}

PrintInformation1();

for(int j=0;j

{

num[j] = num0[j];

}

InsertSort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

SelectSort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

BubbleSort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

Shellsort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

QuickSort(num,0,N-1);

printf(”关键字比较次数按从小到大排列分别是：rn“);

KeyCompareNum_pailie();

printf(”rn“);

printf(”移动次数按从小到大排列分别是：rn“);

MoveNum_pailie();

PrintInformation2();

system(”pause“);

return 0;

}

五、调试分析与核心算法解释

程序的5种排序函数可以自己写，也可以百度找源码，总之五种排序函数写完以后，调试的关键是设置计数变量，并在这些函数的合适位置进行加1计数或加3计数，因此注意分块调试，分函数调试，做到这几点调试难度总体不大。

六、使用说明

随机数产生，5种排序用的都是同一组N个随机数，用户无需输入，直接运行程序即可输出运算结果。

七、调试结果

八、遇到的问题和解决方法（程序调试日志）

2018/10/19

问题：第一种排序输出很大，后面输出很小，几乎没作用。

解决方法：每经过一个排序函数，数组已经排好序了，不能直接调用其余的排序函数，而是要在程序一开始就用另一个数组num0[N]记录了随机数产生的数组num[N]，因此只需要在每次排序前，把num0数组中数据重新赋给num数据即可参与排序了。

问题：数据输出个数少于5个，单步执行发现循环不到5次。

解决方案：分析后发现，程序的几个for循环，内层的循环里面的计数加1变量如i，j，和外层循环设置的加1变量用的是一个变量，导致内层循环计数变量的改变会影响外层循环，导致输出个数小于5。将这些变量设置成不同变量就不影响了（相互独立的循环可能不会影响，但内外层关系的两个循环绝对不能用同一个计数变量）。

问题：程序末尾会跳出一个程序中止警告框，说是栈释放的问题。

解决方案：百度发现，这实际上是数组越界的问题，把数组个数设置为N+1大小的，就好了。

九、实验的收获和感想

个人感想：这个程序难度不大，关键在于在合适的位置插入用于记录的变量+1或者+3,真正有技术含量的在于按照从小到大的顺序输出相应数据。收获比较大的一个技巧：相互独立的循环计数变量可能不会影响，但内外层关系的两个循环绝对不能用同一个计数变量，否则程序循环次数就会乱！

从关键字比较次数和移动次数来看，选择和快速排序都是非常高效的，希尔排序也不错，不要用或少用冒泡排序和直接插入排序。

个人方法的优点：只产生了1次随机数，5次排序的用的都是同一组数据，可以更好地更严谨地比较出这5种算法的优劣。

个人方法的缺点：因为要“长久”保留产生的随机数，因此需多设置一个数组，占用内存空间比较大。

十、源程序

源程序见源程序清单。

参考资料

https://blog.csdn.net/guanyasu/article/details/53153705

https://jingyan.baidu.com/article/49711c616b8a1ffa441b7cdc.html

https://zhidao.baidu.com/question/***684.html

源程序清单

实验一、约瑟夫斯问题求解

#include

#define ElemType int

#define SLNODE struct sl_node

SLNODE

{

ElemType data[2];

SLNODE *next;

};

SLNODE *CREATE_SL(SLNODE*,int);

void ShowInput(SLNODE*h,int n);//每个人的密码输入

void ShowOutput(SLNODE*,int);//排列输出

void PrintInformation1();//输出程序信息和个人信息

void PrintInformation2();//程序结束信息

void PrintTime();//输出时间

int main()

{

int m,n,mistake=1;

SLNODE *Head;

PrintInformation1();//输出程序信息和个人信息

while(mistake)

{

printf(”输入人数n:n“);

scanf_s(”%d“, &n);

printf(”请指定初始报数上限m(m应必须小于等于n):n“);

scanf_s(”%d“, &m);

if(m>n)

{

printf(”输入数据有误，请重新输入n“);

}

else mistake=0;

}

Head =(SLNODE *)malloc(sizeof(SLNODE));

Head->next = NULL;

Head = CREATE_SL(Head,n);

ShowInput(Head,n);

printf(”正确的出列顺序为:rn“);

ShowOutput(Head,m);

PrintInformation2();//程序结束信息

system(”pause“);

return 0;

}

void PrintTime()

{

time_t t;

time(&t);

printf(”%s“, ctime(&t));

printf(”rn“);

}

void PrintInformation1()

{

printf(”实验名称:实验一.约瑟夫斯问题求解rn“);

printf(”学号:031650106rn“);

printf(”姓名:郭砚璞rn“);

printf(”====================rn“);

printf(”程序运行开始,Current local time and date:“);

PrintTime();

}

void PrintInformation2()

{

printf(”rn====================rn“);

printf(”程序运行结束,Current local time and date:“);

PrintTime();

}

SLNODE *CREATE_SL(SLNODE *h,int n)

//创建一个h为头指针的链表，h指向的结点数据域用不到

{

ElemType data;

int i = 1;

SLNODE *p, *s;

p = h;

while(i<=n)

{

printf(”请输入第%d个元素:t“,i);

scanf_s(”%d“, &data);

s =(SLNODE *)malloc(sizeof(SLNODE));

s->data[0]=i;

s->data[1] = data;

if(h->next == NULL)

{

h->next = s;

}

else

{

p->next = s;

}

p = s;

i++;

}

p->next = h;

return h;

}

void ShowInput(SLNODE *h,int n)

{

SLNODE *p;

p = h;

printf(”%d“,n);

printf(”个人的密码依次为:“);

while((p->next)!= h)

{

p = p->next;

printf(”%dt“, p->data[1]);

}

printf(”n“);

}

void ShowOutput(SLNODE *h, int m)

{

SLNODE *p, *s;//s用于记录上一个节点，从而使p结点找到它将其删除

int j = 0;

s = h;//第一次执行此函数时，h指向头结点；后面递归执行时，h刚开始指向的是上一//次输出的结点（还没删除）

//都用s来记录，等那一趟程序快结束找到下一个要出列的的点时，h指向那个结点作为头结点，并且让p找到s指向的 //上一个结点，把它删除。

p = h;

while(j < m-1)

{

p = p->next;

if(p->next==h)//不能让h所指向的结点（上一次输出的结点，暂时用作头结点所以//还未删除）影响小循环次数

{

p=p->next;//所以此处让p多移动一下，等下一次小循环让p顺利移动到下一//个节点（从而忽略掉h指向的结点）

}

//等找到下一个该出列的结点时，h指向那个结点（充当下一次的头节点），充当上一次头//结点的结点利用s删除

j++;

}//此时p指向第m-1个结点

if(p->next == h)//整个程序的终止条件，依次回到上个函数结尾，相当于全部结束了

{

return;

}

h= p->next;

p = h;//此时h和p均指向要出列的结点

printf(”%dt“, h->data[0]);

j = 0;//j用于while循环，使h指针指向要出列的点的前一个结点，所以及时清零

while(p->next!=s)//找s废弃节点

{

p = p->next;

}

s = p->next;

p->next = s->next;//连接新结点

free(s);//释放s所指空间

ShowOutput(h,h->data[1]);

}

实验二、停车场管理问题

#include ”stdio.h“

#include ”stdlib.h“

#include ”time.h“

#define Maxsize 2 //停车场最多能停的车数

#define ElemType int

int Prize;//每停一个时刻收费多少元

static int num = 0;//num用于记录入队的车所在的位置

typedef struct stack //模拟停车场的栈

{

ElemType license[Maxsize];//用于存放车牌号

ElemType timeIn[Maxsize];//用于存放入停车场时间

int top;

}Parking;

typedef struct stack1 //退车时暂时存放

{

ElemType license[Maxsize-1];

ElemType timeIn[Maxsize-1];

int top;

}Backup;

typedef struct road

{

ElemType license;

struct road *next;

}Road;

typedef struct linkqueue//队列模拟便道

{

Road *front,*rear;

}LinkQueue;

void GetIn(Parking *s, LinkQueue *q, ElemType license, ElemType timeIn);//有车进来

void GetOut(Parking *s, Backup *s1, LinkQueue *q, ElemType license, ElemType timeOut);//有车//出去

void PrintInformation1();//输出程序信息和个人信息

void PrintInformation2();//程序结束信息

void PrintTime()

{

time_t t;

time(&t);

printf(”%s“, ctime(&t));

printf(”rn“);

}

void PrintInformation1()

{

printf(”实验名称:实验二.停车场管理问题rn“);

printf(”学号:031650106rn“);

printf(”姓名:郭砚璞rn“);

printf(”====================rn“);

printf(”程序运行开始,Current local time and date:“);

PrintTime();

}

void PrintInformation2()

{

printf(”rn====================rn“);

printf(”程序运行结束,Current local time and date:“);

PrintTime();

}

//给停车场用的配置函数

Parking *Init_Parking()//置空栈

{

Parking *s;

s=(Parking*)malloc(sizeof(Parking));

s->top=-1;

return s;

}

int IsEmpty_Parking(Parking *s)//判空栈

{

if(s->top==-1)

return 1;

else return 0;

}

int Push_Parking(Parking *s,ElemType license,ElemType timeIn)//入栈

{

if(s->top==Maxsize-1)

return 0;

else

{

s->top++;

s->license[s->top]=license;

s->timeIn[s->top]=timeIn;

return 1;

}

int Pop_Parking(Parking *s,ElemType *license,ElemType *timeIn)//出栈

{

if(IsEmpty_Parking(s))

return 0;

else

{

*license = s->license[s->top];

*timeIn = s->timeIn[s->top];

s->top--;

return 1;

}

//给备用栈配置的函数

Backup *Init_Backup()//置空栈

{

Backup *s;

s =(Backup*)malloc(sizeof(Backup));

s->top =-1;

return s;

}

int IsEmpty_Backup(Backup *s)//判空栈

{

if(s->top ==-1)

return 1;

else return 0;

}

int Push_Backup(Backup *s, ElemType license, ElemType timeIn)//入栈

{

if(s->top == Maxsize-1)

return 0;

else

{

s->top++;

s->license[s->top] = license;

s->timeIn[s->top] = timeIn;

return 1;

}

int Pop_Backup(Backup *s, ElemType *license,ElemType* timeIn)//出栈

{

if(IsEmpty_Backup(s))

return 0;

else

{

*license = s->license[s->top];

*timeIn = s->timeIn[s->top];

s->top--;

return 1;

}

//给候车便道链式队列配置的函数

LinkQueue *Init_LQueue()//创建一个带头结点的空队

{

LinkQueue *q;

Road *p;

q =(LinkQueue*)malloc(sizeof(LinkQueue));

p =(Road*)malloc(sizeof(Road));

p->next = NULL;

q->front = q->rear = p;

return q;

}

void In_LQueue(LinkQueue *q, ElemType license)//入队

{

Road *p;

p =(Road*)malloc(sizeof(Road));

p->license = license;

p->next = NULL;

q->rear->next = p;

q->rear = p;

}

int IsEmpty_LQueue(LinkQueue *q)//判队空

{

if(q->front == q->rear)

return 1;

else

return 0;

}

int Out_LQueue(LinkQueue *q, ElemType *license)//出队

{

Road *p;

if(IsEmpty_LQueue(q))

{

printf(”队空“);

return 0;

}

else

{

p = q->front->next;

q->front->next = p->next;

*license = p->license;

free(p);

if(q->front->next == NULL)

q->rear = q->front;

return 1;

}

void main()

{

ElemType license, time,timelast=0;

//timeInlast是最近一次有车进停车场的时间，提示以后输入的进场时间要大于此数值

char command;//进入A还是离开D

Parking *s;

Backup *s1;

LinkQueue *q;

PrintInformation1();//输出程序信息和个人信息

s = Init_Parking();//停车场

q = Init_LQueue();//便道队列

s1 = Init_Backup();//退车时的备用栈

printf(”请输入停车每小时需交纳的费用（元）rn“);

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

scanf(”%d“,&Prize);

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

while(1)

{

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

Loop:printf(”请输入操作的命令，驶入停车场A，离开停车场D，查看停车场内车数P 0 0，查看候车厂内车数W 0 0，程序结束E 0 0:n“);

scanf(”%c%d%d“,&command, &license,&time);

setbuf(stdin, NULL);//使stdin输入流由默认缓冲区转为无缓冲区,必不可少

if(command == A)

{

if(time <= timelast)

{

printf(”输入的时间必须大于上一次输入的时间:t“);

printf(”%dt“, timelast);

printf(”请重新输入n“);

goto Loop;

}

else

{

timelast = time;

GetIn(s,q,license,time);

}

if(command == D)

{

if(time <= timelast)

{

printf(”输入的时间必须大于上一次输入的时间:t“);

printf(”%dt“, timelast);

printf(”请重新输入n“);

goto Loop;

}

else

{

timelast = time;

GetOut(s, s1, q, license, time);//车开走的函数

}

if(command == P)

{

if(license == 0 && time == 0)

printf(”停车场内停了%d辆车n“,s->top+1);//显示停车场车数

}

if(command == W)

{

if(license == 0 && time == 0)

printf(”侯车场内停了%d辆车n“,num);//显示候车场车数

}

if(command == E)

{

if(license == 0 && time == 0)

{

PrintInformation2();//程序结束信息

system(”pause“);

return;

}

//停车函数

void GetIn(Parking *s, LinkQueue *q,ElemType license, ElemType timeIn)

{

if(Push_Parking(s, license, timeIn)== 1)//说明成功进入停车场

{

printf(”%d号车在%d时刻停在停车场第%d个位置nn“,license,timeIn,s->top+1);

}

else //栈满，汽车要进入便道，即入队

{

num++;

In_LQueue(q,license);

printf(”%d号车停在候车便道的第%d个位置nn“,license,num);

}

void GetOut(Parking *s, Backup *s1,LinkQueue *q, ElemType license, ElemType timeOut)

{

ElemType *licen, *tim;//两个指针赋给出栈函数，用于读取车牌号和进停车场时间

ElemType ParkTime;//汽车在停车场停留的时间

ElemType Money;//汽车应缴金额

licen =(ElemType*)malloc(sizeof(ElemType));

tim=(ElemType*)malloc(sizeof(ElemType));

if(IsEmpty_Parking(s))//先判断停车场内是否有车

{

printf(”对不起！停车场已空！nn“);

return;

}

while(s->license[s->top]!= license)

{

Pop_Parking(s,licen,tim);

Push_Backup(s1, *licen, *tim);

if(IsEmpty_Parking(s)==1)

{

printf(”对不起！停车场内没有车牌号为%d的车nn“,license);

while(IsEmpty_Backup(s1)!= 1)

{

Pop_Backup(s1, licen, tim);

Push_Parking(s, *licen, *tim);

}

return;

}

if(s->license[s->top] == license)

{

ParkTime = timeOut-s->timeIn[s->top];

Money = ParkTime * Prize;

printf(”汽车在停车场内停留的时间为%d小时,应缴费%d元nn“,ParkTime,Money);

Pop_Parking(s, licen, tim);

while(IsEmpty_Backup(s1)!= 1)

{

Pop_Backup(s1,licen,tim);

Push_Parking(s,*licen,*tim);

}

if(IsEmpty_LQueue(q)!= 1)

{

Out_LQueue(q,licen);

Push_Parking(s,*licen,timeOut);

printf(”%d号汽车此时退出便道，进入停车场最后一个位置nn“,*licen);

num--;

}

实验三、管道铺设施工的最佳方案问题

#include ”stdio.h“

#include ”stdlib.h“

#include ”time.h“

#define MaxVertexNum 100 //设置小区数最多为100

#define VertexNum 9

double LeastNum;//用于记录最短边长度

double LongestNum;//用于记录最长边长度，程序过程中不改变

double adjacent[VertexNum][VertexNum];

//邻接矩阵，不用于处理数据，而是用于暂时存储从文件读来的数据

//进而在邻接表存储数据时读取此数组数据即可

//二维数组数据为0的元素说明之间没有通道

//在处理完数据后，此数组会用来暂时存储处理后的数据，并写入到另一个文件中

typedef struct node

{//边表结点

char adjvex;

double weight;//权值

struct node *next;

}EdgeNode;

typedef struct vnode

{//顶点表结点

char vertex;

EdgeNode *firstedge;

}VertexNode;

typedef struct

{

VertexNode adjlist[MaxVertexNum];

int n,e;

}ALGraph;

void PrintInformation1();//输出程序信息和个人信息

void PrintInformation2();//程序结束信息

void CreateALGraph(ALGraph *);//将文件中数据导入进来构建无向图邻接表

void MinimumSpanningTree(ALGraph *);//将无向图转化为最小生成树

void ResultOutput(double *array,int n1,int n2);//将数据在控制台显示出来

void read_data(void);//从输入文件读取数据到邻接矩阵

void cout_data(void);//将邻接矩阵中的数据输出到输出文件

void read_array(double *array,int n1,int n2,FILE *fp);//内部函数，用户无需调用

void cout_array(double *array,int n1,int n2,FILE *fp);//内部函数，用户无需调用

void main()

{

ALGraph *G;

PrintInformation1();

G =(ALGraph*)malloc(sizeof(ALGraph));

G->n = VertexNum;//为G指向的图分配空间，设置点数（小区数）

read_data();

CreateALGraph(G);

MinimumSpanningTree(G);

cout_data();//输出到文件

ResultOutput((double *)adjacent,VertexNum,VertexNum);//输出到控制台

PrintInformation2();

system(”pause“);

}

void PrintTime()

{

time_t t;

time(&t);

printf(”%s“, ctime(&t));

printf(”rn“);

}

void PrintInformation1()

{

printf(”实验名称:实验三.管道铺设施工的最佳方案问题rn“);

printf(”学号:031650106rn“);

printf(”姓名:郭砚璞rn“);

printf(”====================rn“);

printf(”程序运行开始,Current local time and date:“);

PrintTime();

}

void PrintInformation2()

{

printf(”rn====================rn“);

printf(”程序运行结束,Current local time and date:“);

PrintTime();

}

void CreateALGraph(ALGraph *G)

{

//建立无向图的邻接表存储

int i=0,j=0,k=0;

EdgeNode *s;

for(i = 0;i < G->n;i++)

{

G->adjlist[i].vertex = 65 + i;

printf(”t%c“,(G->adjlist[i].vertex));//控制台输出列表头

G->adjlist[i].firstedge=NULL;

}

printf(”n“);

for(k=0;kn;k++)

{

for(j=0;jn;j++)

{

if(adjacent[k][j]!=0)

{

s =(EdgeNode*)malloc(sizeof(EdgeNode));

s->adjvex = 65+j;

s->weight=adjacent[k][j];

s->next = G->adjlist[k].firstedge;

G->adjlist[k].firstedge = s;

}

void read_data(void)

{

int i,j;

FILE *fp;

fp=fopen(”gyp_program3_Input.dat“,”r“);// 输入数据文件

read_array((double *)adjacent,VertexNum,VertexNum,fp);

fclose(fp);

for(i = 0;i < VertexNum;i++)

{

for(j = 0;j < VertexNum;j++)

{

if(adjacent[i][j] > LongestNum)

{

LongestNum = adjacent[i][j];//即给LongestNum设置的初值为最大边边值

}

void read_array(double *array,int n1,int n2,FILE *fp)

{

int i,j;

float q;

for(i=0;i

for(j=0;j

{

fscanf(fp,”%f“,&q);

*array++ =(double)q;

}

void cout_data(void)

{

FILE *fp;

fp=fopen(”gyp_program3_Output.dat“,”w“);//输出数据文件

cout_array((double *)adjacent,VertexNum,VertexNum,fp);

fclose(fp);

}

void cout_array(double *array,int n1,int n2,FILE *fp)

{

int i,j;

for(i = 0;i < n2;i++)

{

fprintf(fp, ”t%c“, 65 + i);//输出文件里打印列表头

}

fprintf(fp,”n“);

for(i=0;i

{

fprintf(fp,”%ct“,65+i);//输出文件里打印行表头

for(j=0;j

{

fprintf(fp,”%.1ft“,*array);

array++;

}

fprintf(fp,”n“);

}

void ResultOutput(double *array,int n1,int n2)

{

int i,j;

for(i=0;i

{

printf(”%ct“,65+i);//控制台输出行表头

for(j=0;j

{

printf(”%.1ft“,*array);

array++;

}

printf(”n“);

}

void MinimumSpanningTree(ALGraph *G)

{//将无向图转化为最小生成树

int i, j, k;

int flag2=1,point;

int start, end;

EdgeNode *s;

char NowAdjacent[VertexNum];

for(i=0;i

{

for(j = 0;j < VertexNum;j++)

{

adjacent[i][j] = 0;//先将邻接矩阵所有值清零

}

NowAdjacent[0]=G->adjlist[0].vertex;//初始点放入点集

for(i=0;i

//刚开始只有一个起始点，之后加入剩余的VertexNum个点，即VertexNum-1次循环

{

LeastNum = LongestNum;//这一步很重要，每加入一个点，应把LeastNum初始化为//最大值，避免受之前数值的影响

for(j = 0;j < i + 1;j++)//第i次点集里有i+1个点，即比较这i+1个点与生于点边的大//小，找最小边的另一个点

{

point = NowAdjacent[j]-A;//用于指示已经存进点集中的点是图的第几个点

s = G->adjlist[point].firstedge;

while(s!= NULL)

{

for(k = 0;k < i + 1;k++)

{

if(s->adjvex == NowAdjacent[k])

{

flag2 = 0;//flag2=0用于指示此时s所指的点已经在点集内

break;

}

if(flag2 == 1)//确保仅当s指向的点是不在点集里的点时，才被比较处理

{

if((LeastNum > s->weight)&&(s->weight!=0))

{

end = s->adjvex-A;//flag用于指示最短边是第几个点

start = point;

LeastNum = s->weight;

}

s = s->next;

flag2 = 1;//标志位有可能已经被清0，必须重设为1，确保不影响下一次

}

//启发：对于用的不止一次的标志位，一定不可能只单方向置位，一定是双向置位，//否则用了一次，后面就会误判

}

adjacent[start][end] = LeastNum;

adjacent[end][start] = LeastNum;

NowAdjacent[i + 1] = G->adjlist[end].vertex;//向点集加入新点

}

实验四、内部排序算法的实现与比较

#include ”stdio.h“

#include ”stdlib.h“

#include ”time.h“

const int N=3000;//随机产生N个随机整数

void PrintInformation1();//输出程序信息和个人信息

void PrintInformation2();//程序结束信息

void PrintTime();

void InsertSort(int R[], int n);//插入排序

void SelectSort(int R[], int n);//选择排序

void BubbleSort(int R[], int n);//冒泡排序

void QuickSort(int R[],int low,int high);//快速排序

void ShellInsert(int R[],int m,int n);//快速排序

void Shellsort(int R[],int n);//希尔排序

void KeyCompareNum_pailie();

void MoveNum_pailie();

int KeyCompareNum[5]={0};//分别存储这5种排序的关键字比较次数

int MoveNum[5]={0};//分别存储这5种排序的移动次数

int main()

{

//数组设为N+1个是因为有些算法是从数组1到N存储的，0位有的不用，有的用作了哨兵

int num0[N+1];//记录最原先随机产生的N个数字，因为num[N]每排序一次都会改变

int num[N+1];//每次排序前先读入num0[N]数据

//srand函数只增加一次就够了，用系统当前时间设置rand()随机序列种子，保证每次运行随机序列不一样

srand((unsigned)(time(NULL)));

for(int j = 0;j < N;j++)

{

num0[j] = rand();

}

PrintInformation1();

for(int j=0;j

{

num[j] = num0[j];

}

InsertSort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

SelectSort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

BubbleSort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

Shellsort(num,N);

for(int j = 0;j < N;j++)

{

num[j] = num0[j];

}

QuickSort(num,0,N-1);

printf(”关键字比较次数按从小到大排列分别是：rn“);

KeyCompareNum_pailie();

printf(”rn“);

printf(”移动次数按从小到大排列分别是：rn“);

MoveNum_pailie();

PrintInformation2();

system(”pause“);

return 0;

}

void KeyCompareNum_pailie()//关键字比较次数排列

{

int i,j,k,m;

int printnum=0;//用于记录上一次输出的是数组KeyCompareNum的第几个数

int minimum;//用于输出最小的数字

int maximum=0;

for(i = 0;i < 5;i++)

{

if(maximum < KeyCompareNum[i])

maximum = KeyCompareNum[i];

}

for(m = 0;m< 5;m++)

{

minimum = maximum;

//minimum在每次输出是都是全新的，不能受之前数值的影响，因此每次输出第一步先//把minimum设为最大值

for(j = 0;j < 5;j++)

{

if((minimum >=KeyCompareNum[j])&&(KeyCompareNum[j]!= 0))

{

minimum = KeyCompareNum[j];

}

for(k = 0;k < 5;k++)//编程时k原先用的还是i,结果i=4这个情况,break以后到紧接//着的外层循环时，i的数值影响到了外层循环，跳了出来，因此换成了k

{

if(minimum == KeyCompareNum[k])

{

KeyCompareNum[k] = 0;

printnum = k;

break;

}

if(printnum == 0)

printf(”直接插入排序:%dt“, minimum);

if(printnum == 1)

printf(”选择排序:%dt“,minimum);

if(printnum == 2)

printf(”冒泡排序:%dt“, minimum);

if(printnum == 3)

printf(”快速排序:%dt“, minimum);

if(printnum == 4)

printf(”希尔排序:%dt“, minimum);

}

printf(”rn“);

}

void MoveNum_pailie()//移动次数排列

{

int i, j, k, m;

int printnum = 0;//用于记录上一次输出的是数组KeyCompareNum的第几个数

int minimum;//用于输出最小的数字

int maximum = 0;

for(i = 0;i < 5;i++)

{

if(maximum < MoveNum[i])

maximum = MoveNum[i];

}

for(m = 0;m < 5;m++)

{

minimum = maximum;//minimum每次输出是都是全新的，不能受之前数值的影响，//因此每次输出第一步先把minimum设为最大值

for(j = 0;j < 5;j++)

{

if((minimum >= MoveNum[j])&&(MoveNum[j]!= 0))

{

minimum = MoveNum[j];

}

for(k = 0;k < 5;k++)//编程时k原先用的还是i,结果i=4这个情况,break以后到紧接//着的外层循环时，i的数值影响到了外层循环，跳了出来

{//因此换成了k

if(minimum == MoveNum[k])

{

MoveNum[k] = 0;

printnum = k;

break;

}

if(printnum == 0)

printf(”直接插入排序：%dt“, minimum);

if(printnum == 1)

printf(”选择排序：%dt“, minimum);

if(printnum == 2)

printf(”冒泡排序：%dt“, minimum);

if(printnum == 3)

printf(”快速排序：%dt“, minimum);

if(printnum == 4)

printf(”希尔排序：%dt“, minimum);

}

printf(”rn“);

}

void InsertSort(int R[], int n)//插入排序

{

int i, j;

for(i = 2;i <= n;i++)

{

R[0] = R[i];

MoveNum[0]++;

j = i-1;

while(R[0] < R[j])

{

KeyCompareNum[0]++;

R[j + 1] = R[j];

MoveNum[0]++;

j--;

}

R[j + 1] = R[0];

MoveNum[0]++;

}

void SelectSort(int R[], int n)//选择排序

{

int i, j, k;

for(i = 1;i < n;i++)

{

k = i;

for(j = i + 1;j <= n;j++)

if(R[j] < R[k])

{

k = j;

KeyCompareNum[1]++;

}

if(k!= i)

{

R[0] = R[k];

R[k] = R[i];

R[i] = R[0];

MoveNum[1]+=3;

}

void BubbleSort(int R[], int n)//冒泡排序

{

int i, j, flag = 0;

for(i = 1;(i < n && flag == 0);i++)

{

flag = 1;

for(j=1;j

if(R[j + 1] < R[j])

{

KeyCompareNum[2]++;

flag = 0;

R[0] = R[j];

R[j] = R[j+1];

R[j + 1] = R[0];

MoveNum[2]+=3;

}

void QuickSort(int R[],int low,int high)//快速排序

{

int i,j;

i=low;

j=high;

R[0]=R[i];

MoveNum[3]++;

while(i

{

while((R[j]>=R[0])&&(j>i))

{

j--;

KeyCompareNum[3]++;

}

if(j>i)

{

R[i]=R[j];

MoveNum[3]++;

i++;

}

while((R[i]<=r[0])&&(j>i))

{

i++;

KeyCompareNum[3]++;

}

if(j>i)

{

R[j]=R[i];

MoveNum[3]++;

j--;

}

R[i]=R[0];

MoveNum[3]++;

if(low

QuickSort(R,low,i-1);

if(i

QuickSort(R,j+1,high);

}

void ShellInsert(int R[],int m,int n)

{//一趟希尔排序，按间隔m划分子序列

int temp,j;

for(int i=m;i

{

temp=R[i];

MoveNum[4]++;

j=i;

while(j>=m && temp

{

KeyCompareNum[4]++;

R[j]=R[j-m];

MoveNum[4]++;

j-=m;

}

R[j]=temp;

MoveNum[4]++;

}

void Shellsort(int R[],int n)//希尔排序

{

int m;

m=n/2;

while(m>=1)

{

ShellInsert(R,m,n);

m=(m==2?1:(m/2));

}

void PrintTime()

{

time_t t;

time(&t);

printf(”%s“, ctime(&t));

printf(”rn“);

}

void PrintInformation1()

{

printf(”实验名称:实验四.内部排序算法的实现与比较rn“);

printf(”学号:031650106rn“);

printf(”姓名:郭砚璞rn“);

printf(”====================rn“);

printf(”程序运行开始,Current local time and date:“);

PrintTime();

}

void PrintInformation2()

{

printf(”rn====================rn“);

printf(”程序运行结束,Current local time and date:");

PrintTime();

机械系统设计综合实践实验报告篇6

实验名称：

机械系统设计综合实践

学号姓名1：20090540 张世荣；

学号姓名2：20090581 严郡

实验目的：

1.将各个小部件按照实验说明书拼凑成完整的机器模型

2.通过机器组装过程，培养学生之间的团队合作能力，阅读图形的能力，空间想象能力，和动手能力

实验要求：

2—4个同学一组，互相协助配合，完成机器模型的组装过程，检查无错误后，请老师验收，拍下视频，照片，完成实验报告

实验仪器：

机器模型零部件，产品说明书十字形螺丝刀

实验步骤：

1，观察机器模型的大致组装过程，形成初步印象

2，实际动手，按照说明书进行各部件的分别组装，两个同学分工，分别组装各部件

3，各大的部件组装完成后，将各部件连接为一个整体，初步形成机器模型 4，将各个小零件组装到初步的模型当中，形成完整的机器模型

5，讨论组装过程遇到的问题，解决问题，将不清楚的问题向同学，老师请教 6 检查是否有遗漏，确认没有错误后，拍下照片，录制视频 7 将模型拆卸，放回工具箱，锁好

实验结果：

化工原理实验教学创新与实践篇7

关键词：化工原理实验,实验教学,改革

化工原理实验是我院化学工程与工艺、应用化学、高分子材料、生物工程、食品科学与工程、环境工程、生物技术、轻化工程等专业的一门必修实验课。化工原理实验具有明显的工程特点, 紧密联系化工生产实际, 是实践性很强的一门技术课。

化工原理实验属于工程实验范畴, 不同于前置课程实验的是它具有工程的特点, 每个单元操作实验就相当于化工生产中的一个基本过程, 通过它能建立起一定的工程概念。同时, 随着实验课的进行, 会遇到大量的工程实际问题, 对理工科学生来说可以从做实验过程中更实际、更有效地学到更多工程实验方面的原理及测试手段, 可以发现复杂的真实设备与工艺过程同描述这一个过程的数学模型之间的关系, 也可以认识到对于一个看似复杂的过程, 一经了解, 可以只用最基本的原理来解释和描述。因此, 化工原理实验不仅是演证化工原理的基本理论, 加深对课堂教学内容的理解, 更为重要的还在于对未来的科技工作者进行实验方法、实验技能的基本训练, 培养独立组织和完成实验的能力及严肃认真的工作作风和实事求是的科学态度, 为将来从事科学研究和解决工程实际问题打基础。

一、化工原理实验目的

化工原理实验目的为:第一, 化工原理实验课程的首要目的就是要培养学生能找出工程实际问题的主要实质, 提出问题并解决之。为了养成科技工作者的这种必备素质和工程观点, 应该经常提出如下一类的问题并试图回答:这套设备或工艺过程最关键的特征是什么?包含哪些基本原理?这些理论如何应用于此?我是否掌握?能否找出操作的平衡状态、稳定状态和过渡状态?如何达到这些状态及如何操作?独立变量有哪些?如何测量和控制它们?仪器检测范围?是否其它方式来测量和控制这些独立变量?相关参数有哪些?如何测量?误差产生的原因?误差有多大?如何控制或减少误差?装置中测量出参数的真实意义?装置或过程为什么如此设计?如要达到此实验目的有否其他途径?在设备中完成指定的工艺要求, 最佳设计如何?对每个实验都应养成提出这些问题的习惯, 深化实验目的, 熟悉化工中物理量的测量等。第二, 化工原理实验不仅帮助同学养成用头脑思考的习惯, 而且还培养学生掌握实验技能来解决实际问题, 以下几个方面要特别注意!

(1) 认真理解实验目的, 学会根据实验目的设计装置来测量所需数据;

(2) 深入了解测量参量的物理意义, 包括定义、测量时的系统误差、精度和准确性;

(3) 养成仔细观察并记录真实实验数据的习惯, 并示以草图;

(4) 熟悉几种在化工生产中常用的基本设备、常用仪器和测量方法;

(5) 培养组织能力、责任心、创造性和合作精神;

(6) 培养撰写工程实验报告的能力, 仔细描写重要的及有意义的现象和结果。

以上两大方面, 就是培养达到科技工作者能力的实际过程。通过实验, 学生能够做到: (1) 加深学生对化工原理基本概念的认识, 验证有关的化工单元操作的理论, 培养学生理论联系实际、提高分析和解决实际问题的能力。 (2) 使学生学会常用的实验方法, 提高学生的实验操作技能和独立工作能力。 (3) 培养学生查阅手册、处理实验数据和撰写实验报告的能力。 (4) 培养学生自己动手改装设备的能力, 提高的学生的专业素质。

二、化工原理实验教学改革的思路

在实验教学过程中培养学生的实验技能和科学研究能力, 引导学生利用化工过程技术与设备、实验方法学、现代测控原理等理论知识, 分析和设计化工过程单元操作并独立完成实验, 掌握先进的测量手段和计算机控制技术及计算机在化工原理实验教学中的应用, 进而全面提高学生的创新能力和综合素质。

1. 实验教学的设计思想

由于工程实验是一项技术工作, 它本身就是一门重要的技术学科, 有其自己的特点和系统。为了切实加强实验教学环节, 将实验课单独设课, 教学内容包括实验理论、计算机仿真、实物教学和学生的实验内容。设置基本实验的目的是使学生巩固和加深对课堂教学内容的理解, 并得到化工实验技能的基本训练。基本实验项目包括雷诺实验、柏努利实验、阻力实验、离心泵实验、过滤实验、传热实验、精馏实验、吸收实验及干燥实验等。

2. 实验研究方法

工程实验不同于基础课程的实验, 后者采用的方法是理论的、严密的、处理的对象通常是简单的、基本的甚至是理想的, 而工程实验面对的是复杂的实际问题和工程问题。对象不同, 实验研究方法必不相同。工程实验的困难在于变量多, 涉及的物料千变万化, 设备大小悬殊, 困难可想而知。因此, 数学模型法和因次分析法指导下的实验研究方法是研究工程问题的两个基本方法, 这两种方法可以非常成功地使实验研究结果由小见大, 由此及彼地应用于大设备的生产设计上。例如, 因次论指导下的实验, 可不需要对过程的深入理解, 不需要采用真实的物料、真实流体或实际的设备尺寸, 只需借助模拟物料 (如空气、水、黄沙等) 在实验室规模的小设备中, 经一些预备性的实验或理性推断得出影响过程的因素, 从而加以归纳和概括成经验方程。数学模型方法是在对过程有充分认识的基础上, 将过程做高度概括, 得到简单而不失真的物理模型, 然后给予数学上的描述。这种研究方法同样可以具备以小见大、由此及彼的功能。

化工单元操作由许多单元过程和设备所组成, 学生应运用理论指导并能独立完成化工单元操作, 能在现有设备中完成指定的任务, 并预测某些参数的变化对过程的影响, 这是最基本的要求。在提高性的实验中, 学生将有机会按照一定的实验目的, 自行设计并搭建装置, 测取数据, 验证理论或者达到某一定的实验目的。

三、化工原理实验教学实践及具体改革方案

1. 实施分专业、分层次的实验教学模式

我校化工原理教学实行分专业教学模式。化工原理设化工原理I、化工原理I I及化工原理I I I三种课程体系。化学工程与工艺专业选用化工原理I, 化工原理实验开设为二周的综合性实验;应用化学、高分子材料、食品科学与工程、生物工程、环境工程等专业选用化工原理II, 化工原理实验学时数为20学时;生物技术、轻化等专业选用化工原理III, 化工原理实验学时数为10学时。

对不同教学体系, 化工原理实验又实行分层次教学。建立计算机仿真实验——基木实验——综合实验——设计性实验四层次教学体系。设计性实验主要用于因材施教和学生课外科技活动。

(1) 计算机仿真实验教学是当代非常重要的一种教学辅助手段, 它形象生动且快速灵活, 集知识掌握和能力培养于一体, 是提高实验教学效果的一项十分有力的措施。目前我们已开设:离心泵仿真实验、阻力仿真实验、过滤仿真试验、传热仿真实验、吸收仿真实验、干燥仿真实验、精馏仿真实验以及流体流动形态的观察和柏努利方程演示实验。

(2) 基木实验。以传统的验证性实验为主, 教学目标重在掌握典型单元操作过程的机理和规律, 以及完成实验操作、数据处理、仪器的使用等基本训练。

(3) 综合性实验。开展综合性实验, 可以提高学生科研能力。综合性实验的开发是提高学生素质, 增强学生科研能力的重要手段, 它可以使学生掌握基本的科学研究过程, 提高学生提出问题、解决问题的能力。化工原理综合实验设备多使用大型多功能性设备, 可以完成某项单元操作的多项实验任务。在完成基本的实验内容后, 利用较为先进的实验设备, 认真筛选, 确定一些可进行综合性实验的单元操作, 指导学生进行选题、理论分析、实验设计、数据处理、结论分析, 最后形成科技论文, 使学生所学的理论知识得以在实际中应用, 科研能力得到锻炼并有所提高。

(4) 设计型实验能让学生尽早接触工程或科研实际, 参加实验室建设, 培养或考察他们灵活运用所学知识解决实际问题的能力, 尤其是创新能力。实验装置可直接采用实验室己有装置, 或利用组合式实验装置进行搭建, 有时则需要自行设计, 每一环节都有许多具体工作要做, 可以很好地锻炼学生。

2. 理论教学 (预习) 、仿真实验、实验操作三位一体, 教学形式多样化

化工原理实验均安排理论教学 (预习) 、仿真实验、实验操作三个单元时间。由于化工原理实验工程性较强, 有许多问题需事先考虑、分析, 并做好必要的准备, 因此必须在实验操作前进行预习和仿真实验。

3. 改变考核方式

对于实验成绩的考评, 以往的模式是由平时的实验预习报告、实验操作、实验报告及最终的笔试综合评定, 其中实验操作必须附有指导教师签名的原始数据表。由于学生实验多以3~4人一组进行, 实验报告难免出现近似或抄袭现象, 实验的书面考核也多是填空、选择及简答等形式, 难以反映学生对实验技术的掌握程度与知识的综合应用能力。参照其他学校的教学改革, 将原有的4人一组共同进行实验、每人单独完成实验报告的教学模式, 改为2人合作完成实验并共同编写实验报告。共同完成实验报告, 可以使学生省出更多的时间去查阅文献资料、强化专业知识根基、深化对实验及相关过程的理解。同时, 以实验设计报告及大作业替代了原有的闭卷式书面考核, 在成绩评定中还增加了对实验技能的考评, 力求引导学生由单纯地追求高分, 逐步向加强实践能力、培养创新意识过渡。

4. 定期举办化工原理实验技能大赛

充分发挥实验技能大赛的激励与示范作用, 以竞赛的形式促进学生刻苦学习基本实验技能、培养学生动手能力、创新能力以及工程设计与开发的能力。竞赛可按初赛、复赛、决赛等形式进行。初赛为方案设计阶段, 选手们通过查阅资料, 相互交流, 设计出具体流程并确定了试验步骤, 确定最终方案, 达到了检验学生的专业基础知识和创新性及灵活性的目的。复赛是利用指定的实验装置现场进行实验方案设计后, 组织实验, 测取有关数据, 并将实验研究结果整理成完整的书面报告。达到了考察学生的实际动手能力、团队合作能力以及对实验中遇到的问题进行分析并解决的能力的目的。决赛要求参赛选手进一步完善实验方案, 优化实验操作环节, 并进行答辩。由专家和学生对参赛作品共同进行评审, 对优秀作品给予一定的奖励, 以资鼓励。

5. 尽快完善实验室开放制度

我校化工原理实验涉及我院8个专业, 涉及的学生也很多。但目前我校实验室开放教学还不理想。需尽快完善化工原理实验室开发制度, 开放化工原理实验室, 发挥学生自主学习的积极性, 培养科学、严谨的学习态度和工作作风, 培养创新能力, 独立思考能力和实践动手能力, 充分发挥教学资源功能和效益, 积极探索与培养高素质创新人才相适应的开放式实验教学模式, 努力提高实验教学质量。

四、结束语

经过几年的教学改革和实践, 化工原理课程已获得我院精品课程, 形成了由课堂理论教学、实验教学、课程设计几个环节构成课程体系, 已构建“基础——演示——实验——设计——综合”的教学模式。但是, 化工原理实验教学课题的研究, 不是一朝一夕就能完成的, 因为它受到教学学时、教学方法、实验室设备、实验室面积、教学人员、实验员等诸多因素的制约与影响。我们要立足现有的实验室设备条件, 配合理论教学, 边研究、边改革、边实践, 全面培养学生动手、动脑能力, 努力提高学生的创新意识、创新思维和创新能力。

参考文献

[1]曾明荣, 王维德, 赵鹏, 等.把握实验教学过程提高实验教学质量[J].化工高等教育, 2008, (100) 2:93～96

[2]朱志君.化工原理实验的特点及重要性[J].化学工程与装备, 2008, 2:123

[3]范明霞, 龙毅, 胡兵, 等.提高化工原理实验教学质量浅探[J].实验室科学, 2008, 6:44～45

高中物理教学中创新实验设计实践篇8

【关键词】高中物理教学实验

物理实验作为物理教学中较为关键的教学途径，在对学生的实验技能进行培养的同时，要进一步的培养以及启发高中学生的思维能力、创新精神以及创造能力等，由于物理学科是一门相对较难的学科，所以在进行学习的过程中，教师要善于采用创新式实验的实践教学，采用创新型的实验方法，开发学生的创新型思维，进而逐渐养成科学性的精神，进而强化科学素养教学。

一、现阶段高中物理实验中存在的问题

（一）对于实验设计不够重视

物理教材中的基本理论知识都是由物理实验得来的，但是目前我国仍然采用较为传统式的教学模式，教师以板书为教学重点，将自己对于教材的理解教授给学生，长期以来，这样的教学模式使得学生们逐渐觉得枯燥乏味，失去了对于物理学习的兴趣以及积极性。

与此相反，物理实验是一个较为生动直观的过程，进而可以逐渐营造一种愉悦的学习气氛，使学生能够逐渐融入到课堂的学习中去，体会到物理学习的乐趣，积极的参与课堂教学的整个过程，在进一步培养学生的思维能力以及实验操作能力的同时，还能有效的锻炼学生的创新能力。虽然教师能够设计实验教学的内容，但是在进行实验设计的过程中，毫无新意，只是单纯的按照课本进行教学，导致不能够实现实验的操作内容，完全的按照课本教材按部就班的实验，使得对于物理的授课不能起到任何的作用，进而无法提升教学的效率，完成不了教学目标。

（二）缺乏物理实验设计环节

物理实验的整个过程是充满趣味以及智慧的，设计性的实验教学能够有效的培养学生整体的创新能力。针对这部分的教学，教师可以鼓励学生进行自主性的思考，自己设计实验步骤以及实验方法，这是实验教学的主要目的。只有学生亲自参与到实验中，才能发现实验中的乐趣，得出实验结论，加深学生对于物理概念定理的理解以及运用。例如：教师想要加深学生对于物理理论知识的认识以及理解，在进行加速度这一板块教学时，教师可以通过设置小铁球的单摆实验进行探究，这个相对较为简单的实验能够将物理的原理以及实践操作相结合，调动学生参与其中的积极性，并且能够激起学生的发散性思维能力，有效的运用得出的数据结论进行设计其他的相关性实验，进一步渲染物理实验课堂的氛围，充分调动学生的学习积极性，有效的增强学生的学习效率。

二、优化高中物理教学实验设计的有效措施

（一）增强对于实验设计的重视

现阶段的高中教学中教学目的主要以提升自身的成绩以及高考录取率为基准，在进行物理教学的过程中，为了有效的节省教学实践，往往会采用教务传统的教学方法，创新式实验设计长期发展以来受到各方面的阻碍以及限制。高中学校的领导以及教师对于高中物理教学实验的认识不够重视，导致在进行实际教学的过程中，教师仍然采用讲授的教学方法，严重的阻碍了对学生的动手能力以及创新型能力的有效性培养。例如，按照传统的教学模式，上课后教师单纯的以讲述为主，会逐渐导致学生注意力不集中，在课堂上睡觉或者溜号的现象。因此，学校内的各领导以及教师都要逐渐加大对于实验创新设计的重视程度，着重于对于创新型实验的设计，进而提升物理教学的整体效率以及学习效果。

（二）营造课堂气氛，增强学生的积极性

教师要充分认识到在物理课堂教学中学生的主体地位，特别是在进行创新实验的设计过程中学生的主体性作用，通过教师在进行实验试剂的过程中对学生进行逐渐引导学生进行主动思考、分析实验以及归纳知识点，逐渐激发学生对于实验设计的积极性，以此来进一步提升教学质量。例如：在进行《探究碰撞中不变量》的物理实验时，教师要进一步的引导学生能够进行创造性的设计碰撞试验的实施方案，鼓励学生根据自己设计的有效方案进行实验操作，并且根据实验进而得出相应的结论。

（三）强化师资队伍建设，培养学生正确思考能力

教师在物理教学中发挥着重要的作用，在进行物理实验中应该进行正确的指导以及合理的配合。因此，教师要进一步的强化自身的职业素养以及实验教学能力，在对于学生的基础知识以及动手能力进行培养时，要逐渐的培养学生以正确的思维方式进行思考。教师要不断的鼓励学生能够在学习中发现问题，寻找解决问题的有效方法。

结束语：

综上所述，想要进一步的提升高中学生的物理成绩以及教学效果，最基本的方法就是要将教材知识与实践进行有效的结合。针对于高中物理实验教学中的创新实验的设计，主要是将高中教学体制改革与教学模式进行有效转变的基本组成。教师在进行高中物理实践教学中，物理实验的具体设计内容需要通过教学实践来进行相应的验证。教师要立足于学生的基本情况，综合考虑学生的理解能力以及对于课堂教学的接受能力等，协助学生完成实验。

【参考文献】

[1]柯璋.高中物理教学中创新实验的设计与实践[J].中国校外教育（中旬刊），2015（11）：141-141.

[2]孟全海.高中物理教学中创新实验的设计与实践[J].科学大众（科学教育），2016（2）：49-49.

【创新实践实验报告】推荐阅读：

物理教学如何培养创新意识和实践能力07-03