算法设计与分析课程设计报告

合集下载

最小生成树问题的算法实现及复杂度分析—天津大学计算机科学与技术学院(算法设计与分析)

最小生成树问题的算法实现及复杂度分析—天津大学计算机科学与技术学院(算法设计与分析)

算法设计与分析课程设计报告学院计算机科学与技术专业计算机科学与技术年级2011姓名XXX学号2013年5 月19 日题目:最小生成树问题的算法实现及复杂度分析摘要:该程序操作简单,具有一定的应用性。

数据结构是计算机科学的算法理论基础和软件设计的技术基础,在计算机领域中有着举足轻重的作用,是计算机学科的核心课程。

而最小生成树算法是算法设计与分析中的重要算法,最小生成树也是最短路径算法。

最短路径的问题在现实生活中应用非常广泛,如邮递员送信、公路造价等问题。

本设计以Visual Studio 2010作为开发平台,C/C++语言作为编程语言,以邻接矩阵作为存储结构,编程实现了最小生成树算法。

构造最小生成树有很多算法,本文主要介绍了图的概念、图的遍历,并分析了PRIM 经典算法的算法思想,最后用这种经典算法实现了最小生成树的生成。

引言:假设要在n个城市之间建立通信联络网,则连接n个城市只需要n-1条线路。

这时,自然会考虑这样一个问题,如何在节省费用的前提下建立这个通信网?自然在每两个城市之间都可以设置一条线路,而这相应的就要付出较高的经济代价。

n个城市之间最多可以设置n(n-1)/2条线路,那么如何在这些可能的线路中选择n-1 条使总的代价最小呢?可以用连通网来表示n 个城市以及n个城市之间可能设置的通信线路,其中网的顶点表示城市,边表示两个城市之间的线路,赋予边的权值表示相应的代价。

对于n个顶点的连通网可以建立许多不同的生成树,每一个生成树都可以是一个通信网。

现在要选择这样一棵生成树,也就是使总的代价最小。

这个问题便是构造连通网的最小代价生成树(简称最小生成树)的问题。

最小生成树是指在所有生成树中,边上权值之和最小的生成树,另外最小生成树也可能是多个,他们之间的权值之和相等。

一棵生成树的代价就是树上各边的代价之和。

而实现这个运算的经典算法就是普利姆算法。

正文普里姆(Prim)算法思想普里姆算法则从另一个角度构造连通网的最小生成树。

算法与分析报告课程设计—独立钻石跳棋问题

算法与分析报告课程设计—独立钻石跳棋问题

算法与分析课程设计报告题目:专业:班级:学号:姓名:年月日一、算法问题描述独立钻石跳棋问题。

在33个方格顶点摆放着32枚棋子,仅中间的顶点空着未摆放着棋子。

下棋的规则是任意棋子可以沿着水平或着垂直方向跳过与其相邻的棋子,进入空着的顶点并吃掉被跳过的棋子。

试设计一个算法并找出一种下棋的方法,使得棋盘上最终只剩下一个棋子在棋盘的正中央。

二、算法问题形式化表示在33个方格顶点摆放着32枚棋子,仅中间的顶点空着未摆放着棋子。

算法解决了在32个棋子摆放在有33格的盘上(只有中心格空着)在规定当一个棋子跳过邻近的一个棋子到空格时,就将这张邻近的棋子从盘上拿掉,使除了最后留在中心格一个棋子外其余的棋子均被拿掉的问题!三、期望输入与输出期望输入:显示一个棋盘,在33个方格顶点摆放着32枚棋子,仅中间的顶点空着未摆放着棋子。

期望输出:使得棋盘上最终只剩下一个棋子在棋盘的正中央四、算法分析与步骤描述总体一个回溯的思想,如果两个子字间能跳,那么我们就跳了之后记录其新的位置,因为跳的前后都是一个问题,所以我们能用递归分治,跳了一次之后棋子数减1,并把被跳过的棋子和编号最后的棋子交换,这样就达到了把棋子去掉的目的。

并把最优解保存。

如果temp当前走的次数已经大于最优解,那么我们就不用算了。

五、问题实例及算法运算步骤此次问题主要用回溯算法,基本思想是:从一条路往前走,能进则进,不能进则退回来,换一条路再试。

在包含问题的所有解的解空间树中,按照深度优先的策略,从根结点出发搜索解空间树。

算法搜索至解空间树的任一结点时,总是先判断该结点是否肯定不包含问题的解。

如果肯定不包含,则跳过对以该结点为根的子树的系统搜索,逐层向其祖先结点回溯。

否则,进入该子树,继续按深度优先的策略进行搜索。

回溯法在用来求问题的所有解时,要回溯到根,且根结点的所有子树都已被搜索遍才结束。

而回溯法在用来求问题的任一解时,只要搜索到问题的一个解就可以结束。

六、算法运行截图开始时:结束后:七、附录代码(java)package sfdesign;import java.awt.Color;import java.awt.GridLayout;import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;public class DC extends JFrame {//-----move时候用的变量们public static int oldx = 0;public static int oldy = 0;public static int newx = 0;public static int newy = 0;public static boolean movingflag = false;//-----layeroutprivate GridLayout gamepanellayer = new GridLayout(1, 2); private GridLayout optionlayer = new GridLayout(2, 1); private GridLayout chessboardlayer = new GridLayout(9, 9); //-----左右布局的jpanelprivate JPanel leftpanel = new JPanel();private JPanel rightpanel = new JPanel();//-----public static int restcount = 32;public static int steps = 0;public static JLabel jl1 = new JLabel("剩余子数:" + restcount); public static JLabel jl2 = new JLabel("当前步数:0" + steps); //-----board点阵public static boolean[][] chessboard = {{false, false, false, false, false, false, false, false, false}, {false, false, false, true, true, true, false, false, false}, {false, false, false, true, true, true, false, false, false}, {false, true, true, true, true, true, true, true, false}, {false, true, true, true, true, true, true, true, false}, {false, true, true, true, true, true, true, true, false}, {false, false, false, true, true, true, false, false, false}, {false, false, false, true, true, true, false, false, false}, {false, false, false, false, false, false, false, false, false} };//-----chess点阵public static boolean[][] chessdot = {{false, false, false, false, false, false, false, false, false}, {false, false, false, true, true, true, false, false, false}, {false, false, false, true, true, true, false, false, false}, {false, true, true, true, true, true, true, true, false}, {false, true, true, true, false, true, true, true, false}, {false, true, true, true, true, true, true, true, false}, {false, false, false, true, true, true, false, false, false}, {false, false, false, true, true, true, false, false, false}, {false, false, false, false, false, false, false, false, false} };//-----chess引用点阵public static OneChess[][] chessArmy = new OneChess[9][9]; //-----初始化public DC(int w, int h) {this.setBounds(300, 300, 2 * w, h);this.setTitle("◇独立钻石◇eggno8");this.getContentPane().setLayout(gamepanellayer);this.getContentPane().add(this.leftpanel);this.leftpanel.setLayout(this.optionlayer);this.leftpanel.add(jl1);this.leftpanel.add(jl2);this.getContentPane().add(this.rightpanel);this.rightpanel.setLayout(chessboardlayer);for (int row = 0; row < 9; row++) {for (int col = 0; col < 9; col++) {boolean flag = chessdot[col][row];OneChess oc = new OneChess(flag, col, row);if (!chessboard[col][row]) {oc.setBoard();}this.chessArmy[col][row] = oc;this.rightpanel.add(oc);}}this.setVisible(true);}public static boolean canMove() {boolean f = false;if (oldx == newx && (oldy == newy + 2 || newy == oldy + 2)) { if (chessArmy[oldx][ (newy + oldy) / 2].getLife()) {f = true;} else {f = false;}}if (oldy == newy && (oldx == newx + 2 || newx == oldx + 2)) { if (chessArmy[ (newx + oldx) / 2][oldy].getLife()) {f = true;} else {f = false;}}return f;}public static void doMove() {if (oldx == newx) {chessArmy[oldx][ (newy + oldy) / 2].setLife(false);if (oldy == newy) {chessArmy[ (newx + oldx) / 2][oldy].setLife(false);}chessArmy[oldx][oldy].setLife(false);chessArmy[newx][newy].setLife(true);}public static void main(String[] _s) {DC dc = new DC(360, 360);}}class OneChess extends JButton implements MouseListener { private boolean life;private boolean isout;public int xp;public int yp;public OneChess(boolean sl, int x, int y) {setLife(sl);xp = x;yp = y;this.addMouseListener(this);}public void setLife(boolean l) {life = l;if (l) {setBackground(Color.YELLOW);} else {setBackground(Color.GRAY);}}public void setMoving() {this.setBackground(Color.orange);}public void setBoard() {isout = true;setBackground(Color.WHITE);}public boolean getLife() {return life;}public void mouseClicked(MouseEvent e) {}public void mousePressed(MouseEvent e) {if (isout) {return;//-----movingflag判断moving的两个边沿if (!DC.movingflag) { //选中单个子if (DC.chessboard[xp][yp] && getLife()) {DC.oldx = xp;DC.oldy = yp;DC.movingflag = true;setMoving();}} else { //成功移动1个子if (xp == DC.oldx && yp == DC.oldy) { //放弃1个子,计数1步setLife(true);DC.movingflag = false;DC.steps++;DC.jl2.setText("当前步数:0" + DC.steps);} else if (DC.chessboard[xp][yp] && getLife()) { //点到其他子身上,切换选中的子DC.chessArmy[DC.oldx][DC.oldy].setLife(true);DC.oldx = xp;DC.oldy = yp;DC.steps++;DC.jl2.setText("当前步数:0" + DC.steps);setMoving();}if (DC.chessboard[xp][yp] && !getLife()) {DC.newx = xp;DC.newy = yp;if (DC.canMove()) {DC.doMove();DC.restcount--;DC.jl1.setText("剩余子数" + DC.restcount);DC.oldx = xp;DC.oldy = yp;setMoving();}}}return;}public void mouseReleased(MouseEvent e) {}public void mouseEntered(MouseEvent e) {}public void mouseExited(MouseEvent e) {}//actionPerformed()}。

《算法分析与设计》说课

《算法分析与设计》说课

8
8
8
10
S4
贪心算法
6
6
S5
回溯法
6
8
S6
分支限界
6
8
S7
随机化算法 总学时数
4 40
6 48
说课程教学大纲
5、课外学习内容 分支 限界 算法 设计 分治 分治 最强大脑—数独 阶乘 递归 兔子问题 会场安排问题 国王分财产
银行最优服务次序
回溯 法 贪心 贪心 算法 算法
矩阵连乘 租用游艇 排序问题
•难点模块
分治策略
动态规划 贪心算法
•难点内容
分治策略的应用
分解最优解结构 构造递归关系
回溯法
分支限界法
判断是否满足贪心性质
回溯法--剪枝函数 解空间树
说课导航
说课程教学大纲
说教学资源 说教学方法与手段 说学情与学法指导 说教学过程设计
说考核评价
说教学资源
1、教材选用原则
国家级规划教材 原则
具有先进性、适用性、时效性
汽车加油行驶 网球循环赛比赛日程
动态 规划
充分体现案例驱动、实践导向的设计思想
说课程教学大纲
6、课程重点
•重点模块
递归与分治策略
动态规划算法 贪心算法
•重点内容
二分搜索与排序
矩阵连乘 最长公共子序列
回溯法
分支限界法
最大字段和
0-
说课程教学大纲
7、课程难点
经典教材
说教学资源
王晓东教授编著的 《计算机算法设计与分析》 (C++描述)
说教学资源
2、网络资源
课外学习网站:
/JudgeOnline/problemtypelist.php

算法课设实验报告(3篇)

算法课设实验报告(3篇)

第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。

为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。

二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。

1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。

(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。

- 对每种算法进行时间复杂度和空间复杂度的分析。

- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。

(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。

- 编写三种排序算法的代码。

- 分析代码的时间复杂度和空间复杂度。

- 编写测试程序,生成随机测试数据,测试三种算法的性能。

- 比较三种算法的运行时间和内存占用。

2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。

(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。

- 分析贪心算法的正确性,并证明其最优性。

(3)实验步骤:- 分析活动选择问题的贪心策略。

- 编写贪心算法的代码。

- 分析贪心算法的正确性,并证明其最优性。

- 编写测试程序,验证贪心算法的正确性。

3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。

(2)实验内容:- 实现一个动态规划算法问题,如背包问题。

- 分析动态规划算法的正确性,并证明其最优性。

(3)实验步骤:- 分析背包问题的动态规划策略。

- 编写动态规划算法的代码。

- 分析动态规划算法的正确性,并证明其最优性。

- 编写测试程序,验证动态规划算法的正确性。

三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。

计算机算法设计与分析第三版华中科技大学课程设计

计算机算法设计与分析第三版华中科技大学课程设计

计算机算法设计与分析第三版华中科技大学课程设计简介计算机算法设计与分析是一门重要的计算机科学基础课程,旨在帮助学生掌握算法设计与分析的基本方法和技巧,以及能力和素养。

本文档主要介绍华中科技大学计算机学院关于计算机算法设计与分析第三版的课程设计。

设计目的与意义在计算机科学与技术领域中,算法设计与分析是必不可少的技能。

本次课程设计旨在帮助学生更好地掌握这一技能,培养其解决实际问题的能力和创新思维。

具体来说,本课程设计的目的和意义包括:1.培养学生掌握算法设计和分析的基本方法和原理。

2.帮助学生掌握基本数据结构和算法的实现。

3.促进学生通过实践掌握各种算法的实际应用。

4.加强学生的团队合作能力和创新意识。

设计内容本次课程设计的主要内容是设计和实现一个算法,要求学生通过小组协作完成。

具体要求如下:1.组成1-3人的小组;2.自主设计一个算法,注意必须是创新性的,并要求主体思路清晰、关键步骤明确、正确性可靠;3.在算法设计的过程中体会算法分析的重要性,在实现过程中体现时间与空间复杂度的控制;4.设计并实现一个可以泛用的软件程序,用于演示各种数据集的实现过程和结果输出等;5.材料、可以的软件程序都可以参考课堂提供的学习资料,但需要体现出数学计算、算法分析的过程和结论,要求学生在合理使用资料的前提下,自主思考和解决问题。

设计流程设计流程如下:第一阶段:确定算法在本阶段,学生应该自主思考和讨论,确定一个合适的算法,并撰写算法设计文档。

可以参考课堂上相关的算法设计和分析内容,同时根据自己的思考和理解,结合实际应用场景,设计一种创新性的算法。

第二阶段:算法实现在本阶段,学生应该根据算法设计文档,完成软件程序的实现。

需要注意的是,在实现过程中,要注重时间复杂度和空间复杂度的控制,并进行相应的测试和优化。

第三阶段:数据测试在本阶段,学生应该使用不同的数据集对已实现的算法进行测试,并进行相应的测试结果分析和总结。

同时,要考虑对应不同场景的应用性能和效果。

算法设计和分析课程论文

算法设计和分析课程论文

湖南理工学院课程论文论文题目贪心法的应用课程名称算法设计与分析姓名学号专业计算机科学与技术年级学院计算机日期(2014年4月10日)课程论文评价标准贪心法的应用摘要:在解决问题的过程中,通过逐步获得最优解从而获得整体最优解的策略就是贪心策略,在已经学会在解的范围可以确定的情况下,可以采用枚举或递归策略,一一比较它们最后找到最优解;但当解的范围非常大时,枚举和递归的效率会非常低。

这时就可以考虑用贪心策略。

贪心算法没有固定的框架,算法设计的关键是贪心策略的选择,贪心策略要具有无后向性,即某阶段状态一旦确定以后,不受这个状态以后的策略的影响。

当一个问题有好几种解决方法时,贪心法应该是最好的选择之一。

本文讲述了贪心算法的含义、基本思路以及贪心算法在实例中的应用。

关键词:贪心算法;删数问题;最小生成树一、引言在平时解决问题的过程中,当一个问题就有无后向性和贪心选择性质时,贪心算法通常会给出一个简单、直观和高效的解法。

贪心算法通过一系列的选择来得到一个问题的解。

它所做的每一个选择都是当前状态下就有某种意义的最好选择,即贪心选择;并且每次贪心选择都能将问题化解为一个更小的与原问题具有相同形式的子问题。

尽管贪心算法对于很多问题不能总是产生整体最优解,但对于最短路径、最小生成树问题,以及删数问题等却可以获得整体最优解,而且所给出的算法一般比动态规划算法更为简单、直观和高效。

二、贪心算法的含义和特点(一)贪心算法的含义贪心算法是通过一系列的选择来得到问题解的过程。

贪心算法是一种能够得到某种度量意义下的最优解的分级处理方法,它总是做出在当前看来是最有的选择,也就是说贪心策略并不是从整体上加以考虑,它所做出的选择只是在某种意义上的局部最优解算法。

(二)贪心算法的特点1、从全局来看,运用贪心策略解决的问题在程序运行过程中无回溯过程,后面的每一步都是当前看似最佳的选择,这种选择依赖已作出的选择,但并不依赖未作出的选择。

2、不能保证最后求出的解是最佳的。

算法设计与分析——输油管道问题实验报告

算法设计与分析——输油管道问题实验报告

题目: 输油管道问题学号0091313000913133学生姓名张一楠朱玉婷专业(班级)09计本1班设计题目输油管道问题设计技术参数系统平台:windows 7开发工具:Microsoft Visual C++ 6.0设计要求1.掌握问题分析的方法与步骤,选择合适的方法解决问题。

2.选择合适的算法编写程序。

工作计划1:熟悉题目并理解,及找寻相关资料。

2:根据题目设计并分析算法。

3:使用Visual C++实现。

4:完成设计报告参考资料吕国英.《算法设计与分析》.北京:清华大学出版社,2009摘要本实验,我们通过综合应用算法解决了实际生活中的输油管道问题,通过比较各种算法的时间复杂度以及解决效率,采用了算法中以分治法为基础的随机划分来解决问题,利用随机选择方法找到各个油井的中位数,通过讨论论证了中位数即最优管道位置。

信息奥赛中一个问题有多个算法解决,通过比较不同算法解决问题的效率,选择最高效的一个。

在输油管道问题这个实验中得到运用。

关键词:算法设计,分治法,随机划分,随机选择,中位数目录1 需求分析.............................................................................. 错误!未定义书签。

1.1 实验内容.................................................................... 错误!未定义书签。

1.2 系统的基本逻辑模型 ....................................................... 错误!未定义书签。

1.3 确定目标系统的功能 (5)2 总体设计............................................................................. 错误!未定义书签。

《计算机算法设计与分析》课程设计

《计算机算法设计与分析》课程设计

《计算机算法设计与分析》课程设计用分治法解决快速排序问题及用动态规划法解决最优二叉搜索树问题及用回溯法解决图的着色问题一、课程设计目的:《计算机算法设计与分析》这门课程是一门实践性非常强的课程,要求我们能够将所学的算法应用到实际中,灵活解决实际问题。

通过这次课程设计,能够培养我们独立思考、综合分析与动手的能力,并能加深对课堂所学理论和概念的理解,可以训练我们算法设计的思维和培养算法的分析能力。

二、课程设计内容:1、分治法:(2)快速排序;2、动态规划:(4)最优二叉搜索树;3、回溯法:(2)图的着色。

三、概要设计:分治法—快速排序:分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题,这些子问题互相独立且与原问题相同。

递归地解这些子问题,然后将各个子问题的解合并得到原问题的解。

分治法的条件:(1) 该问题的规模缩小到一定的程度就可以容易地解决;(2) 该问题可以分解为若干个规模较小的相同问题,即该问题具有最优子结构性质;(3) 利用该问题分解出的子问题的解可以合并为该问题的解;(4) 该问题所分解出的各个子问题是相互独立的,即子问题之间不包含公共的子子问题。

抽象的讲,分治法有两个重要步骤:(1)将问题拆开;(2)将答案合并;动态规划—最优二叉搜索树:动态规划的基本思想是将问题分解为若干个小问题,解子问题,然后从子问题得到原问题的解。

设计动态规划法的步骤:(1)找出最优解的性质,并刻画其结构特征;(2)递归地定义最优值(写出动态规划方程);(3)以自底向上的方式计算出最优值;(4)根据计算最优值时得到的信息,构造一个最优解。

●回溯法—图的着色回溯法的基本思想是确定了解空间的组织结构后,回溯法就是从开始节点(根结点)出发,以深度优先的方式搜索整个解空间。

这个开始节点就成为一个活结点,同时也成为当前的扩展结点。

在当前的扩展结点处,搜索向纵深方向移至一个新结点。

这个新结点就成为一个新的或节点,并成为当前扩展结点。

算法设计与分析课程设计报告(五子棋).doc

算法设计与分析课程设计报告(五子棋).doc

算法设计与分析课程设计报告(五子棋)西安工业大学计算机科学与工程学院算法设计与分析课程设计题目五子棋班级050606 人数13人成员陈玮高谦侯夕杰马涛宋文彬王伟周仁文邵文清赵瑞红李盈超尉建明陈建军张祥雄学号050606102 050606105 050606108 050606114 050606117 050606120 050606126 050606129 050606132 040609111 040606123 050606101 040610127 时间2008年元月16日班级050606 学号题目五子棋完成时间1月16日指导教师杨国梁、陈芳小组排名邵文清,赵瑞红,李盈超,尉建明,周仁文,侯夕杰,陈建军,张祥雄陈玮,宋文彬,高谦,马涛,王伟小组成绩个人得分第1名邵文清赵瑞红贡献细节设计,完成void draw_box;void change;void judgekey的设计并完成实验报告第2名李盈超尉建明贡献主要负责程序的整体规划,完成主函数的设及相关变量的定义,完成void attentoin的设计第3名周仁文侯夕杰贡献完成void judgewhoint x,int y的设计第4名陈建军张祥雄贡献完成void draw_cicleint x,int y,int color的设计第5名陈玮宋文彬贡献完成int judgeresultint x,int y的设计第6名高谦,马涛王伟贡献调试并运行程序备注考核标准1. 个人文档资料40 2. 软件验收40 3. 考勤20 目录1课程设计报告-------------------31.1问题描述----------------------3 1.2需求分析---------------------------3 1.3概要设计-----------------------3 1.4详细设计-----------------------5 1.5调试分析---------------------6 2源程序---------------------6 3程序的说明文件-------------------13 4课设总结-----------------------13 1. 课程设计报告1.1问题描述连珠五子棋是有两个人在一盘棋上进行对抗的竞技运动。

结合OJ及竞赛的算法设计与分析课程教学实践

结合OJ及竞赛的算法设计与分析课程教学实践

计算机教学与教育信息化本栏目责任编辑:王力结合OJ 及竞赛的算法设计与分析课程教学实践时慧琨(淮南师范学院计算机学院,安徽淮南232038)摘要:针对算法设计与分析课程教学中教学以讲授为主、学生缺乏实践机会及实践脱离应用实际的问题,从在线测试(OJ )系统建设、实践团队组织、教学活动开展和竞赛组织参与等方面,详细阐述了在教学过程中结合OJ 以及竞赛开展课程教学的实践模式,激发学生学习主动性,引导培养学生分析问题,解决问题能力及团队合作能力,提高教学效果。

关键词:算法设计与分析;OJ ;教学实践中图分类号:G642文献标识码:A文章编号:1009-3044(2021)10-0149-03开放科学(资源服务)标识码(OSID ):Teaching Practices of Algorithm Design and Analysis Combined with OJ and Competitions SHI Hui-kun(School of Computer Science,Huainan Normal University,Huainan 232038,China)Abstract:In the teaching of algorithm design and analysis course,there are some problems such as too many theoretical teaching,lack of practical opportunities and practice divorced from real application,etc.This paper elaborates on the practical mode of com⁃bining online judge(OJ)system and competitions in the teaching process from several aspects include OJ system construction,prac⁃tice team organization,teaching activities development and competition organization participation.Practices proved these measures can stimulate students'learning initiative,guide and cultivate students'ability of analyzing,problem solving and team working,so as to improve the teaching effect.Keywords:AlgorithmDesignandAnalysis;OJ;teaching practice1算法设计与分析课程算法设计与分析课程是高校计算机专业学生的一门专业必修课,该课程主要学习算法设计和算法分析的基本理论及方法。

算法分析与设计课设

算法分析与设计课设

成绩评定表课程设计任务书摘要为了满足人们对大数据量信息处理的渴望,为解决各种实际问题,计算机算法学得到了飞速的发展,线性规划、动态规划、贪心策略等一系列运筹学模型纷纷运用到计算机算法学中,产生了解决各种现实问题的有效算法。

虽然设计一个好的求解算法更像是一门艺术而不像是技术 ,但仍然存在一些行之有效的、能够用于解决许多问题的算法设计方法 ,你可以使用这些方法来设计算法 ,并观察这些算法是如何工作的。

一般情况下,为了获得较好的性能,必须对算法进行细致的调整。

但是在某些情况下,算法经过调整之后性能仍无法达到要求,这时就必须寻求另外的方法来求解该问题。

动态规划的基本思想与分治法类似,也是将待求解的问题分解成若干份的子问题,先分别解决好子问题,然后从子问题中得到最终解。

但动态规划中的子问题往往不是相互独立的,而是彼此之间有影响,因为有些子问题可能要重复计算多次,所以利用动态规划使这些子问题只计算一次。

回溯法在用来求问题的所有解时,要回溯到根,且根结点的所有可行的子树都已被搜索遍才结束。

而回溯法在用来求问题的任一解时,只要搜索到问题的一个解就可以结束。

这就是以深度优先的方式系统地搜索问题解的回溯算法,它适用于解决一些类似n皇后问题等求解方案问题,也可以解决一些最优化问题。

在做题时,有时会遇到这样一类题目,它的问题可以分解,但是又不能得出明确的动态规划或是递归解法,此时可以考虑用回溯法解决此类问题。

回溯法的优点在于其程序结构明确,可读性强,易于理解,而且通过对问题的分析可以大大提高运行效率。

关键词:算法;动态规划;回溯法;目录一、问题描述 (1)1.1k乘积问题 (1)1.2最小重量机器问题 (1)二、算法设计 (1)三、设计原理 (2)3.1动态规划 (2)3.2回溯法 (2)四、问题分析与设计 (3)4.1k乘积问题 (3)4.2最小重量机器设计问题 (4)五、算法实现 (4)5.1k乘积问题 (4)5.2最小重量机器问题 (7)六、结果分析 (10)总结 (11)参考文献 (12)一、问题描述1.1k乘积问题设I是一个n位十进制整数。

算法设计技巧与分析英文版课程设计 (2)

算法设计技巧与分析英文版课程设计 (2)

Algorithm Design Techniques and Analysis Course Design(English Version)IntroductionAlgorithm design is an essential component of computer science. Whether you are designing a new application ortrying to optimize an existing one, the ability to develop efficient algorithms can significantly impact performance, scalability, and user experience. The Algorithm Design Techniques and Analysis course is designed to provide insight into the core principles and methods of algorithm design, as well as the techniques and tools necessary for algorithm analysis.Course ObjectivesThe primary objective of this course is to enhance students’ ability to develop and analyze algorithms effectively. By the end of this course, students should be able to:•Understand the importance of algorithm design and analysis in computer science;•Employ a systematic approach to the design and analysis of algorithms;•Analyze algorithms for their time and space complexity;•Understand the difference between worst-case and average-case analysis;•Apply various algorithm design techniques to solve common problems, such as searching, sorting, and graph traversal;•Develop efficient implementations of algorithms using programming languages;•Apply the principles of algorithm design and analysis to real-world problems.Course OutlineWeek 1: Introduction to Algorithm Design and Analysis •Importance of algorithm design and analysis in computer science;•The role of algorithms in modern computing;•Overview of algorithm design techniques and analysis.Week 2: Algorithm Analysis•The basics of algorithm analysis;•Time and space complexity;•Worst-case and average-case analysis;•Asymptotic notation (Big O, Big Omega, Big Theta).Week 3: Algorithm Design Techniques - Searching and Sorting•Sequential search;•Binary search;•Bubble sort;•Selection sort;•Insertion sort;•Quick sort;•Merge sort.Week 4: Algorithm Design Techniques - Graph Traversal •Breadth-First Search (BFS);•Depth-First Search (DFS);•Shortest path algorithms (Dijkstra’s and Floyd-Warshall);•Minimum spanning tree algorithms (Prim’s and Kruskal’s).Week 5: Dynamic Programming•Principles of dynamic programming;•Top-down and bottom-up approaches;•Knapsack problem;•Longest Common Subsequence (LCS);•Longest Increasing Subsequence (LIS);•Matrix Chn Multiplication.Week 6: Greedy Algorithms•Principles of greedy algorithms;•Huffman coding;•Activity selection problem;•Kruskal’s algorithm for Minimum Spanning Trees;•Dijkstra’s algorithm for Shortest Paths.Week 7: Divide and Conquer•Principles of divide and conquer;•Binary search;•Merge sort;•Quicksort;•Maximum Subarray problem.Week 8: Final Projects•Apply the principles of algorithm design and analysis to real-world problems;•Develop efficient algorithms to solve the problem;•Analyze and optimize the performance of the algorithms.Course FormatThis course will consist of eight weeks of online lectures, discussion forums, and assignments. Each week, students will be provided with multimedia lectures, reading materials, and programming assignments. Students will be expected to engagein discussion forums and submit weekly assignments to demonstrate comprehension of the material. In the final week, students will be required to complete a final project, which will be graded based on the design and efficiency of their algorithm, as well as their ability to analyze and optimizeits performance.ConclusionThe Algorithm Design Techniques and Analysis course is intended to provide students with the fundamental principles and techniques of algorithm design and analysis. With this knowledge, students will be better equipped to developefficient algorithms for solving real-world problems. By the end of this course, students should have a solid foundationin algorithm design and analysis, enabling them to understand and develop optimized algorithms for a variety of applications.。

算法设计与分析课程设计教学大纲

算法设计与分析课程设计教学大纲

算法设计与分析课程设计教学大纲课程编码:090151145 周/学分:2周/4学分一、大纲使用说明本大纲根据信息与计算科学专业2017—2020版教学计划制订(一)适用专业信息与计算科学专业(二)课程设计性质必修课(三)主要先修课程和后续课程1.先修课程:C语言程序设计2.后续课程:大数据算法二、课程设计目的及基本要求本课程设计是信息与计算科学专业的重要实践性课程,隶属于《算法设计与分析》课程的一个重要部分,是课程结束后进行的一次全面的综合练习。

设计一个高效的程序不仅需要编程小技巧,更需要合理的数据结构和清晰高效的算法,这正是计算机科学领域数据结构与算法设计所研究的主要内容。

算法设计与分析正是一门面向设计,且处于计算机学科核心地位的教育课程。

通过对计算机算法系统的学习与研究,掌握算法设计的主要方法,培养对算法的计算复杂性正确分析的能力,为独立设计算法和对算法进行复杂性分析奠定坚实的理论基础,对每一位从事计算机系统结构、系统软件和应用软件研究与开发的科技工作者都是非常重要和必不可少的。

设计目的如下:1.加深对常用算法以及计算复杂性的基本概念、基本原理和方法的理解。

2. 加强对分治法、动态规划、贪心法、回溯法、分支限界法设计策略的理解和实际运用能力的培养,能理论与实际相结合。

3. 能运用已有的算法分析的方法较准确地对算法进行分析,具有一定的分析能力;增强学生的科学实验素质。

要求学生具有理论联系实际和实事求是的科学作风、严肃认真的工作态度。

4. 能运用已有的算法设计技术来设计实际问题的有效算法,具有较强的设计能力和一定的创新能力。

注重创新实践、突出个性发展,努力培养面向软件行业的高素质应用型人才。

为了使学生从课程设计中尽可能取得比较大的收获,对课程设计题目分成二类,一类为基础训练题目,学生从中学习到程序设计的常用算法。

另一类为综合题目,学生从这两类型题目中各选择部分完成。

基本要求:要求学生做好预习,掌握设计过程中涉及到的算法,按设计流程编程,上机调试通过,验证结果并进行分析、完成论文。

算法设计与分析做课程设计选题

算法设计与分析做课程设计选题

算法设计与分析做课程设计选题一、课程目标知识目标:1. 理解算法设计的基本概念,掌握常见的算法设计方法;2. 了解算法分析的基本原则,掌握时间复杂度和空间复杂度的分析方法;3. 掌握至少两种算法设计选题,并能够运用所学知识对其进行分析和优化。

技能目标:1. 能够运用所学算法设计方法,独立完成中等难度的算法设计题目;2. 能够分析给定算法的时间复杂度和空间复杂度,并提出优化方案;3. 能够运用所学的算法知识,解决实际生活中的问题,提高问题解决能力。

情感态度价值观目标:1. 培养学生对算法设计和分析的热爱,激发学习兴趣;2. 培养学生的逻辑思维能力,提高分析问题和解决问题的能力;3. 培养学生的团队协作精神,学会在团队中共同探讨和解决问题;4. 培养学生具备良好的编程习惯,遵循学术道德,尊重他人成果。

课程性质:本课程为信息技术学科选修课程,旨在提高学生的算法设计和分析能力。

学生特点:学生具备一定的编程基础,对算法有一定了解,但对算法设计和分析的系统学习尚有不足。

教学要求:结合学生特点,注重理论与实践相结合,通过案例分析、讨论和实践操作,使学生掌握算法设计与分析的方法,提高实际应用能力。

将课程目标分解为具体的学习成果,便于教学设计和评估。

二、教学内容1. 算法设计基本概念:介绍算法的定义、特性及分类,结合教材相关章节,让学生了解算法设计的基本框架。

- 教材章节:第一章 算法概述2. 算法设计方法:讲解常见的算法设计方法,如递归、分治、动态规划、贪心等,并通过实例分析,使学生掌握这些方法在实际问题中的应用。

- 教材章节:第二章 算法设计方法3. 算法分析:阐述时间复杂度和空间复杂度的概念,介绍分析方法,如迭代法、主定理等,结合实际案例,让学生学会评估算法性能。

- 教材章节:第三章 算法分析4. 算法设计选题:选取中等难度的算法设计题目,涵盖排序、查找、图论等领域,指导学生进行实际操作,提高问题解决能力。

《算法设计与分析》课程实验报告 (分治法(三))

《算法设计与分析》课程实验报告 (分治法(三))

《算法设计与分析》课程实验报告实验序号:04实验项目名称:实验4 分治法(三)一、实验题目1.邮局选址问题问题描述:在一个按照东西和南北方向划分成规整街区的城市里,n个居民点散乱地分布在不同的街区中。

用x 坐标表示东西向,用y坐标表示南北向。

各居民点的位置可以由坐标(x,y)表示。

街区中任意2 点(x1,y1)和(x2,y2)之间的距离可以用数值∣x1−x2∣+∣y1−y2∣度量。

居民们希望在城市中选择建立邮局的最佳位置,使n个居民点到邮局的距离总和最小。

编程任务:给定n 个居民点的位置,编程计算邮局的最佳位置。

2.最大子数组问题问题描述:对给定数组A,寻找A的和最大的非空连续子数组。

3.寻找近似中值问题描述:设A是n个数的序列,如果A中的元素x满足以下条件:小于x的数的个数≥n/4,且大于x的数的个数≥n/4 ,则称x为A的近似中值。

设计算法求出A的一个近似中值。

如果A中不存在近似中值,输出false,否则输出找到的一个近似中值4.循环赛日程表问题描述:设有n=2^k个运动员要进行网球循环赛。

现要设计一个满足以下要求的比赛日程表:每个选手必须与其他n-1个选手各赛一次,每个选手一天只能赛一次,循环赛一共进行n-1天。

二、实验目的(1)进一步理解分治法解决问题的思想及步骤(2)体会分治法解决问题时递归及迭代两种不同程序实现的应用情况之差异(3)熟练掌握分治法的自底向上填表实现(4)将分治法灵活于具体实际问题的解决过程中,重点体会大问题如何分解为子问题及每一个大问题涉及哪些子问题及子问题的表示。

三、实验要求(1)写清算法的设计思想。

(2)用递归或者迭代方法实现你的算法,并分析两种实现的优缺点。

(3)根据你的数据结构设计测试数据,并记录实验结果。

(4)请给出你所设计算法的时间复杂度的分析,如果是递归算法,请写清楚算法执行时间的递推式。

四、实验过程(算法设计思想、源码)1.邮局选址问题(1)算法设计思想根据题目要求,街区中任意2 点(x1,y1)和(x2,y2)之间的距离可以用数值∣x1−x2∣+∣y1−y2∣度量。

《算法设计与分析》实验目的

《算法设计与分析》实验目的

《算法设计与分析》实验指导书曹严元计算机与信息科学学院2007年5月目录实验一递归算法与非递归算法 (2)实验二分治算法 ................................................... 错误!未定义书签。

实验三贪心算法 (3)实验四动态规划 (2)实验五回溯法 (3)实验六分枝—限界算法 (4)实验七课程设计 (4)实验一递归与分治算法实验目的1.了解并掌握递归的概念,掌握递归算法的基本思想;2.掌握分治法的基本思想方法;3.了解适用于用递归与分治求解的问题类型,并能设计相应递归与分治算法;4.掌握递归与分治算法复杂性分析方法,比较同一个问题的递归算法与循环迭代算法的效率。

实验二动态规划实验目的1.掌握动态规划的基本思想方法;2.了解适用于用动态规划方法求解的问题类型,并能设计相应动态规划算法;3.掌握动态规划算法复杂性分析方法。

实验三贪心算法实验目的1.掌握贪心法的基本思想方法;2.了解适用于用贪心法求解的问题类型,并能设计相应贪心法算法;3.掌握贪心算法复杂性分析方法分析问题复杂性。

实验五回溯法实验目的1.掌握回溯法的基本思想方法;2.了解适用于用回溯法求解的问题类型,并能设计相应回溯法算法;3.掌握回溯法算法复杂性分析方法,分析问题复杂性。

实验六 分枝—限界算法实验目的1. 掌握分枝—限界的基本思想方法;2. 了解适用于用分枝—限界方法求解的问题类型,并能设计相应动态规划算法;3. 掌握分枝—限界算法复杂性分析方法,分析问题复杂性。

实验七 课程设计实验目的1. 在已学的算法基本设计方法的基础上,理解算法设计的基本思想方法;2. 掌握对写出的算法的复杂性分析的方法,理解算法效率的重要性;3. 能运用所学的基本算法设计方法对问题设计相应算法,分析其效率,并建立对算法进行改进,提高效率的思想意识。

预习与实验要求1. 预习实验指导书及教材的有关内容,回顾所学过的算法的基本思想;2. 严格按照实验内容进行实验,培养良好的算法设计和编程的习惯;3. 认真听讲,服从安排,独立思考并完成实验。

算法设计与分析课程设计(完整版)

算法设计与分析课程设计(完整版)

HUNAN CITY UNIVERSITY 算法设计与分析课程设计题目:求最大值与最小值问题专业:学号:姓名:指导教师:成绩:二0年月日一、问题描述输入一列整数,求出该列整数中的最大值与最小值。

二、课程设计目的通过课程设计,提高用计算机解决实际问题的能力,提高独立实践的能力,将课本上的理论知识和实际有机的结合起来,锻炼分析解决实际问题的能力。

提高适应实际,实践编程的能力。

在实际的编程和调试综合试题的基础上,把高级语言程序设计的思想、编程巧和解题思路进行总结与概括,通过比较系统地练习达到真正比较熟练地掌握计算机编程的基本功,为后续的学习打下基础。

了解一般程序设计的基本思路与方法。

三、问题分析看到这个题目我们最容易想到的算法是直接比较算法:将数组的第 1 个元素分别赋给两个临时变量:fmax:=A[1]; fmin:=A[1]; 然后从数组的第 2 个元素 A[2]开始直到第 n个元素逐个与 fmax 和 fmin 比较,在每次比较中,如果A[i] > fmax,则用 A[i]的值替换 fmax 的值;如果 A[i] < fmin,则用 A[i]的值替换 fmin 的值;否则保持 fmax(fmin)的值不变。

这样在程序结束时的fmax、fmin 的值就分别是数组的最大值和最小值。

这个算法在最好、最坏情况下,元素的比较次数都是 2(n-1),而平均比较次数也为 2(n-1)。

如果将上面的比较过程修改为:从数组的第 2 个元素 A[2]开始直到第 n 个元素,每个 A[i]都是首先与 fmax 比较,如果 A[i]>fmax,则用 A[i]的值替换 fmax 的值;否则才将 A[i]与 fmin 比较,如果 A[i] < fmin,则用 A[i]的值替换 fmin 的值。

这样的算法在最好、最坏情况下使用的比较次数分别是 n-1 和 2(n-1),而平均比较次数是 3(n-1)/2,因为在比较过程中,将有一半的几率出现 A[i]>fmax 情况。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

压缩软件课程设计书一、问题描述:建立一个文本文件,统计该文件中各字符频率,对各字符进行Huffman编码,将该文件至翻译成Huffman编码文件,再将Huffman编码文件翻译成原文件。

二、算法分析及思路:对于该问题,我们做如下分析:(1)首先得构造出哈弗曼树,我们用函数HuffmanTree(int w[],int s[],int n)设计;(2)在构建哈弗曼树的基础上,进一步实现哈弗曼编码问题,我们用函数Huffmancode(char wen[])设计;(3)实现哈弗曼编码后再进一步实现哈弗曼译码问题,我们用函数Huffmandecode()设计;(4)其中编码问题中,得进一步统计出各个字符在文件中的频率,并进行一些必要的标记,我们用函数runhuffman(char wen[])设计;(5)在译码过程中,还有必要的一步是比较原文件与译码后的文件是否相同,我们用函数compare(char wen[])设计;(6)其中的文件输入我们用到类”fstream.h”中的输入输出流,并在运行的文件夹中建立一个文件名为逍遥游的文本文件,且在逍遥游文件中输入需要编码的数据。

三、主要解决的设计问题:1.写一个对txt文件压缩和解压的程序,使用动态编码。

2.使用Huffman编码压缩和解压时,Huffman树的存储可以直接存储树结构,也可以存储所有字符的频度或权值,然后读取时建立Huffman树;3.使用Huffman编码压缩和解压时,注意定义压缩码的结束标记,可以使用一个特殊的字符作为结束标记,也可以在压缩码之前存储其比特长度;如果使用一个特殊字符作为结束标记,则其频度为1,需要在建立Huffman树时把它看作一个独立的字符进行建树。

4.使用Huffman编码压缩和解压时,在一个缓冲区里面收集压缩码比特流,每当收集的比特数满8时,可以把这8比特通过位操作合并成一个字节写入文件(当然也可以收集满一定数目的字节后再写入文件)。

写入文件的最小信息单位为字节。

四、程序设计的流程图:五、输入和输出说明:1、数据输入:由文件input.txt提供输入需要压缩的内容;2、结果输出:将压缩好的文件内容输出到《编码后的文件.txt》中,再由《编码后的文件.txt》解压到《译码后的文件.txt》中。

六、程序及其注解:1、数据结构设计(即类的设计,包括类的数据成员、函数成员)类的设计用HuffmanTree.h保存如下:#include<iostream>#include<fstream>using namespace std;const int MaxSize=512;//--------------------------------------------------------------struct element //哈夫曼树的结点{int str; //记录字符在数组中的位置int weight; //字符出现频率(权值)int lchild,rchild,parent; //哈夫曼树各个指针变量char bits[30]; //存储哈夫曼编码的数组};//--------------------------------------------------------------class HuffmanTree{element hufftree[MaxSize]; //存放哈夫曼树结点的数组int num; //结点数public:HuffmanTree(int w[],int s[],int n);void Select(int n,int &s1,int &s2);void Huffmancode(char wen[]); //哈夫曼编码void Huffmandecode(); //哈夫曼译码};//--------------------------------------------------------------class Run{public:void huffman(char wen[]); //将编码后的文件译成原文件void runhuffman(char wen[]); //统计各字符频率void compare(char wen[]); //比较逍遥游文件和译码后的文件};//--------------------------------------------------------------2、算法设计(类的函数成员的具体设计)(1)算法一设计用HuffmanTree.cpp保存如下:#include<iostream>#include"HuffmanTree.h"using namespace std;//-------------------------------------------------------------------void HuffmanTree::Select(int n,int &s1,int &s2){s1=-1;s2=-1;for(int i=0;i<=n;i++){if(hufftree[i].parent==-1){if(s1==-1) {s1=i;continue;}if(s2==-1) {s2=i;continue;}if(hufftree[i].weight<hufftree[s1].weight)s1=i;else if(hufftree[i].weight<hufftree[s2].weight)s2=i;}}}//-------------------------------------------------------------------HuffmanTree::HuffmanTree(int w[],int s[],int n){num=n;int i1,i2;i1=i2=0;for(int i=0;i<2*num-1;i++)//外部叶子结点数为num个时,内部结点数为n-1,整个哈夫曼树的需要的结点数为2*num-1.{hufftree[i].parent=-1;hufftree[i].lchild=-1;hufftree[i].rchild=-1;}for(int j=0;j<num;j++){hufftree[j].weight=w[j];hufftree[j].str=s[j];}for(int k=num;k<2*num-1;k++) //构建哈夫曼树{Select(k-1,i1,i2); //在hufftree中找权值最小的两个结点i1和i2hufftree[i1].parent=k;hufftree[i2].parent=k;hufftree[k].weight=hufftree[i1].weight+hufftree[i2].weight;hufftree[k].lchild=i1;hufftree[k].rchild=i2;}}//-------------------------------------------------------------------void HuffmanTree::Huffmancode(char wen[]){ifstream in(wen);ofstream out("编码后的文件.txt");int start=MaxSize-1;int cha=0;char cd[MaxSize]; //存放一个编码cd[MaxSize-1]='\0';for(int i=0;i<num;i++){start=MaxSize-1;int c,f;for(c=i,f=hufftree[i].parent;f!=-1;c=f,f=hufftree[f].parent){if(hufftree[f].lchild==c) //置左分支编码0cd[--start]='0';else cd[--start]='1'; //置右分支编码1}strcpy(hufftree[i].bits,&cd[start]);//将编码存放在相应结点存储哈夫曼编码的数组中}cout<<"字符在数组中的下标及其编码如下:"; //输出字符在数组中的位置及其编码for(int k=0;k<num;k++){if(k%3==0) cout<<endl;cout<<hufftree[k].str<<":"<<hufftree[k].bits<<'\t';}cout<<endl<<endl;for(char ch;in.get(ch);) //将逍遥游文件中各个字符转变成相应的编码,写入编码后的文件中{if((int)ch<0) cha=(int)ch+256;else cha=(int)ch;for(int j=0;j<num;j++)if(hufftree[j].str==cha)out<<hufftree[j].bits;}cout<<"编码成功!"<<endl;}//-------------------------------------------------------------------void HuffmanTree::Huffmandecode(){ifstream in("编码后的文件.txt");ofstream out("译码后的文件.txt");int i=2*num-2;for(char b;in>>b;){if(b=='0')i=hufftree[i].lchild;else i=hufftree[i].rchild;if(hufftree[i].lchild==-1){out<<(char)hufftree[i].str;i=2*num-2;}}cout<<"译码成功!"<<endl;}//-------------------------------------------------------------------(2)算法二设计用HuffmanRun.cpp保存如下:#include<iostream>#include"HuffmanTree.h"using namespace std;//---------------------------------------------------------void Run::runhuffman(char wen[]){ifstream in(wen);int w[MaxSize];int weight[MaxSize]; //存放各个字符的频率int str[MaxSize]; //存放逍遥游文件中各个字符在数组w中的位置(下标)int i=0;int n=0;int cha=0;for(int j=0;j<MaxSize;j++)w[j]=0;/*从文件逍遥游中依次读入字符,根据字符的ASCII码值将字符存入str[]数组的相应位置而weight[]数组的相应位置则记录该字符出现的频率*/for(char ch;in.get(ch);){if((int)ch<0) cha=(int)ch+256; //中文的ASCII码值为负数,加上256使其可以存放在数组中else cha=(int)ch;w[cha]++;}for(int k=0;k<MaxSize;k++)if(w[k]!=0){str[n]=k;weight[n]=w[k];n++;}cout<<"字符在数组中的下标及其权值如下:"; //输出字符在数组中的位置及其权值for(int p=0;p<n;p++){if(p%6==0)cout<<endl;cout<<str[p]<<":"<<weight[p]<<'\t';}cout<<endl<<endl;HuffmanTree h(weight,str,n); //构造哈夫曼树h.Huffmancode(wen); //利用哈夫曼树进行编码及译码h.Huffmandecode();}//---------------------------------------------------------void Run::huffman(char wen[]){ifstream in(wen);int weight[MaxSize]; //存放各个字符的频率int str[MaxSize]; //存放逍遥游文件中各个字符在数组w中的位置(下标)int n=0;HuffmanTree h(weight,str,n); //构造哈夫曼树h.Huffmandecode();}void Run::compare(char wen[]){ifstream ina(wen);ifstream inc("译码后的文件.txt");char stringa[100000];int i=0;int flag=0;char stringc[100000];int j=0;for(char cha;ina>>cha;) //将文件逍遥游的内容读入数组stringa[]{stringa[i]=cha;i++;}stringa[i]='\0';for(char chc;inc>>chc;) //将译码后的文件内容读入数组stringc[]{stringc[j]=chc;j++;}stringc[j]='\0';/*比较文件逍遥游和译码后的文件内容,若相同则说明编码正确,若不同,则说明编码错误*/for(int k=0;stringa[k]!='\0'&&stringc[k]!='\0';k++)if(stringa[k]!=stringc[k]) flag=0;if(stringa[k]=='\0'&&stringc[k]=='\0') flag=1;else flag=0;if(flag==0)cout<<"逍遥游文件与译码后的文件不相同,编码错误!"<<endl;elsecout<<"逍遥游文件与译码后的文件相同,编码正确!"<<endl;}//---------------------------------------------------------(3)实现算法设计的主程序用HaffmanMain.cpp保存如下:#include<iostream>#include"HuffmanTree.h"using namespace std;void main(){char wenjian[20];int t=1;while(1){if(t==1){cout<<"请输入要编码的文件名:";cin>>wenjian;Run manager;manager.runhuffman(wenjian);pare(wenjian);}else{cout<<"请输入要译码的文件名:";cin>>wenjian;Run manager;manager.huffman(wenjian);}cout<<"请继续选择需要执行的功能:"<<endl;cout<<"请问您是需要编码文件还是译码文件?"<<endl;cout<<"如果是要编码文件,那么请输入1;"<<endl;cout<<"如果是要译码文件,那么请输入0。

相关文档
最新文档