武汉理工大学算法分析实验报告

合集下载

算法设计与分析的实验报告

实验一递归与分治策略一、实验目的1．加深学生对分治法算法设计方法的基本思想、基本步骤、基本方法的理解与掌握；2．提高学生利用课堂所学知识解决实际问题的能力；3．提高学生综合应用所学知识解决实际问题的能力。

二、实验内容1、①设a[0:n-1]是已排好序的数组。

请写二分搜索算法，使得当搜索元素x不在数组中时，返回小于x的最大元素位置i和大于x的最小元素位置j。

当搜索元素在数组中时，i和j相同，均为x在数组中的位置。

②写出三分搜索法的程序。

三、实验要求（1）用分治法求解上面两个问题；（2）再选择自己熟悉的其它方法求解本问题；（3）上机实现所设计的所有算法；四、实验过程设计（算法设计过程）1、已知a[0:n-1]是一个已排好序的数组，可以采用折半查找（二分查找）算法。

如果搜索元素在数组中，则直接返回下表即可；否则比较搜索元素x与通过二分查找所得最终元素的大小，注意边界条件，从而计算出小于x的最大元素的位置i和大于x的最小元素位置j。

2、将n个元素分成大致相同的三部分，取在数组a的左三分之一部分中继续搜索x。

如果x>a[2(n-1)/3]，则只需在数组a的右三分之一部分中继续搜索x。

上述两种情况不成立时，则在数组中间的三分之一部分中继续搜索x。

五、实验结果分析二分搜索法：三分搜索法：时间复杂性：二分搜索每次把搜索区域砍掉一半，很明显时间复杂度为O(log n)。

（n代表集合中元素的个数）三分搜索法：O（3log3n）空间复杂度：O（1）。

六、实验体会本次试验解决了二分查找和三分查找的问题，加深了对分治法的理解，收获很大，同时我也理解到学习算法是一个渐进的过程，算法可能一开始不是很好理解，但是只要多看几遍，只看是不够的还要动手分析一下，这样才能学好算法。

七、附录：（源代码）二分搜索法：#include<iostream.h>#include<stdio.h>int binarySearch(int a[],int x,int n){int left=0;int right=n-1;int i,j;while(left<=right){int middle=(left+right)/2;if(x==a[middle]){i=j=middle;return 1;}if(x>a[middle])left=middle+1;else right=middle-1;}i=right;j=left;return 0;}int main(){ int a[10]={0,1,2,3,4,5,6,7,8,9};int n=10;int x=9;if(binarySearch(a,x,n))cout<<"找到"<<endl;elsecout<<"找不到"<<endl;return 0;}实验二动态规划——求解最优问题一、实验目的1．加深学生对动态规划算法设计方法的基本思想、基本步骤、基本方法的理解与掌握；2．提高学生利用课堂所学知识解决实际问题的能力；3．提高学生综合应用所学知识解决实际问题的能力。

算法设计与分析实验报告_3

实验一全排列、快速排序【实验目的】1.掌握全排列的递归算法。

2.了解快速排序的分治算法思想。

【实验原理】一、全排列全排列的生成算法就是对于给定的字符集, 用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。

任何n个字符集的排列都可以与1～n的n个数字的排列一一对应, 因此在此就以n个数字的排列为例说明排列的生成法。

n个字符的全体排列之间存在一个确定的线性顺序关系。

所有的排列中除最后一个排列外, 都有一个后继；除第一个排列外, 都有一个前驱。

每个排列的后继都可以从它的前驱经过最少的变化而得到, 全排列的生成算法就是从第一个排列开始逐个生成所有的排列的方法。

二、快速排序快速排序（Quicksort）是对冒泡排序的一种改进。

它的基本思想是: 通过一趟排序将要排序的数据分割成独立的两部分, 其中一部分的所有数据都比另外一部分的所有数据都要小, 然后再按此方法对这两部分数据分别进行快速排序, 整个排序过程可以递归进行, 以此达到整个数据变成有序序列。

【实验内容】１.全排列递归算法的实现。

２.快速排序分治算法的实现。

【实验结果】１.全排列：快速排序:实验二最长公共子序列、活动安排问题【实验目的】了解动态规划算法设计思想, 运用动态规划算法实现最长公共子序列问题。

了解贪心算法思想, 运用贪心算法设计思想实现活动安排问题。

【实验原理】一、动态规划法解最长公共子序列设序列X=<x1, x2, …, xm>和Y=<y1, y2, …, yn>的一个最长公共子序列Z=<z1, z2, …, zk>, 则:..i.若xm=yn, 则zk=xm=yn且Zk-1是Xm-1和Yn-1的最长公共子序列...ii.若xm≠yn且zk≠x., 则Z是Xm-1和Y的最长公共子序列...iii.若xm≠yn且zk≠y.，则Z是X和Yn-1的最长公共子序列.其中Xm-1=<x1, x2, …, xm-1>, Yn-1=<y1, y2, …, yn-1>, Zk-1=<z1, z2, …, zk-1>。

算法分析实验三报告

《算法设计与分析》实验报告目录一、实验内容描述和功能分析.二、算法过程设计.三、程序调试及结果（附截图）.四、源代码（附源代码）.一、实验内容描述和功能分析.1.矩阵连乘问题内容描述：给定n个矩阵｛A1,A2,…,An｝，其中Ai与Ai+1是可乘的，i=1,2 ,…,n-1。

如何确定计算矩阵连乘积的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少。

功能分析：输入包含多组测试数据。

第一行为一个整数C，表示有C 组测试数据，接下来有2*C行数据，每组测试数据占2行，每组测试数据第一行是1个整数n，表示有n个矩阵连乘,接下来一行有n+1个数,表示是n个矩阵的行及第n个矩阵的列,它们之间用空格隔开。

输出应该有C行，即每组测试数据的输出占一行，它是计算出的矩阵最少连乘积次数。

例如：输入：1输出：7500310 100 5 502.Pebble Merging内容描述：在一个圆形操场的四周摆放着n 堆石子。

现要将石子有次序地合并成一堆。

规定每次只能选相邻的2 堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的得分。

试设计一个算法，计算出将n堆石子合并成一堆的最小得分和最大得分。

编程任务：对于给定n堆石子,编程计算合并成一堆的最小得分和最大得分。

功能分析：输入由多组测试数据组成。

每组测试数据输入的第1 行是正整数n，1≤n≤100，表示有n堆石子。

第二行有n个数，分别表示每堆石子的个数。

对应每组输入，输出的第1 行中的数是最小得分；第2 行中的数是最大得分。

例如：输入：4 输出：434 45 9 54二、算法过程设计.1.矩阵连乘问题矩阵连乘问题是通过设置数组，利用数组的横竖坐标来进行矩阵对应行与列的计算。

2.Pebble Merging这个问题也是跟数组相关，通过寻找数组中的最大和最小值来进行计算。

三、程序调试及结果（附截图）.1.矩阵连乘问题2.Pebble Merging四、源代码（附源代码）.1.矩阵连乘问题#include <stdio.h>int main(){ int a[ 50 ] , b[ 50 ][ 50 ] , c[ 50 ][50 ] , z , n;int i , r , j , k , t;scanf("%d",&z);while (z --){ scanf("%d",&n);for (i = 0 ; i <= n ; ++ i) scanf("%d",& a[ i ]);for (i = 1 ; i <= n ; ++ i) b[ i ][ i ] = 0;for (r = 2 ; r <= n ; ++ r)for (i = 1 ; i <= n - r + 1 ; ++ i){ j = i + r - 1;b[ i ][ j ] = b[i + 1][ j ] + a[i - 1] * a[ i ] * a[ j ];c[ i ][ j ] = i;for (k = i + 1 ; k < j ; ++ k){ t = b[ i ][ k ] + b[k + 1][ j ] + a[i - 1] * a[ k ] * a[ j ];if (t < b[ i ][ j ])b[ i ][ j ] = t , c[ i ][ j ] = k;}}printf ("%d\n" , b[ 1 ][ n ]);}return 0;}2.Pebble Merging#include <stdio.h>int main(){ int dpmin[ 200 ][ 200 ] , min[ 200 ][ 200 ] , mins;int dpmax[ 200 ][ 200 ] , max[ 200 ][ 200 ] , maxs;int a[ 200 ] , i , n , j , k , temp , l;while (scanf ("%d" , & n) != EOF){ for (i = 1 ; i <= n ; ++ i) scanf ("%d" , & a[ i ]);for (i = 1 ; i < n ; ++ i) a[i + n] = a[ i ];for (i = 1 ; i < 2 * n ; ++ i){ min[ i ][ i ] = max[ i ][ i ] = 0;dpmax[ i ][ i ] = dpmin[ i ][ i ] = a[ i ];dpmax[ i ][i + 1] = dpmin[ i ][i + 1] = a[ i ] + a[i + 1];min[ i ][i + 1] = max[ i ][i + 1] = a[ i ] + a[i + 1];}for (i = 1 ; i < n - 1; ++ i)for (l = 1 , j = 2 + i ; j < 2 * n ; ++ j , ++ l){ for (k = l + 1 ; k <= j ; ++ k){ if (k == l + 1){ dpmin[ l ][ j ] = dpmin[ l ][k - 1] + dpmin[ k ][ j ] + min[ l ][k - 1] + min[ k ][ j ];if ( l == k - 1 && k != j)min[ l ][ j ] = a[ l ] + min[ k ][ j ];elseif (l != k - 1 && k == j)min[ l ][ j ] = min[ l ][k - 1] + a[ k ];elsemin[ l ][ j ] = min[ l ][k - 1] + min[ k ][ j ]; dpmax[ l ][ j ] = dpmax[ l ][k - 1] + dpmax[ k ][ j ] + max[ l ][k - 1] + max[ k ][ j ];if ( l == k - 1 && k != j)max[ l ][ j ] = a[ l ] + max[ k ][ j ];elseif (l != k - 1 && k == j)max[ l ][ j ] = max[ l ][k - 1] + a[ k ];elsemax[ l ][ j ] = max[ l ][k - 1] + max[ k ][ j ];continue ;}temp = dpmin[ l ][k - 1] + dpmin[ k ][ j ] + min[ l ][k - 1] + min[ k ][ j ];if (temp < dpmin[ l ][ j ]){ dpmin[ l ][ j ] = temp;if ( l == k - 1 && k != j)min[ l ][ j ] = a[ l ] + min[ k ][ j ];elseif (l != k - 1 && k == j)min[ l ][ j ] = min[ l ][k - 1] + a[ k ];elsemin[ l ][ j ] = min[ l ][k - 1] + min[ k ][ j ];}temp = dpmax[ l ][k - 1] + dpmax[ k ][ j ] + max[ l ][k - 1] + max[ k ][ j ];if (temp > dpmax[ l ][ j ]){ dpmax[ l ][ j ] = temp;if ( l == k - 1 && k != j)max[ l ][ j ] = a[ l ] + max[ k ][ j ];elseif (l != k - 1 && k == j)max[ l ][ j ] = max[ l ][k - 1] + a[ k ];elsemax[ l ][ j ] = max[ l ][k - 1] + max[ k ][ j ];} } }mins = dpmin[ 1 ][ n ]; maxs = dpmax[ 1 ][ n ];for (i = 2 ; i <= n ; ++ i){ if (mins > dpmin[ i ][i + n - 1])mins = dpmin[ i ][i + n - 1];if (maxs < dpmax[ i ][i + n - 1])maxs = dpmax[ i ][i + n - 1];}printf ("%d\n%d\n" , mins , maxs);}return 23;}。

算法分析_实验报告

一、实验目的1. 理解算法分析的基本概念和方法。

2. 掌握时间复杂度和空间复杂度的计算方法。

3. 比较不同算法的效率，分析算法的适用场景。

4. 提高编程能力，培养算法思维。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容本次实验主要分析了以下几种算法：1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 编写各种排序算法的Python实现代码。

2. 分别对长度为10、100、1000、10000的随机数组进行排序。

3. 记录每种排序算法的运行时间。

4. 分析算法的时间复杂度和空间复杂度。

5. 比较不同算法的效率。

五、实验结果与分析1. 冒泡排序```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]```时间复杂度：O(n^2)空间复杂度：O(1)冒泡排序是一种简单的排序算法，其时间复杂度较高，适用于小规模数据排序。

2. 选择排序```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]```时间复杂度：O(n^2)空间复杂度：O(1)选择排序也是一种简单的排序算法，其时间复杂度与冒泡排序相同，同样适用于小规模数据排序。

3. 插入排序```pythondef insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = key```时间复杂度：O(n^2)空间复杂度：O(1)插入排序是一种稳定的排序算法，其时间复杂度与冒泡排序和选择排序相同，适用于小规模数据排序。

武汉理工大学操作系统实践报告

实践课设计报告课程名称计算机操作系统模拟设计存储管理的分配与题目回收学院计算机科学与技术学院专业计算机科学与技术班级xxxx姓名xxx指导教师xxx2016 年12 月29 日目录1需求分析 (2)1.1页式管理的基本原理 (2)1.2实验要求 (2)2功能设计 (2)2.1算法分析 (2)2.2数据结构 (4)2.3模块说明 (4)2.3.1主函数 (4)2.3.2各个功能函数 (4)2.3.3打印函数 (4)参考文献 (9)源代码： (10)1需求分析1.1页式管理的基本原理页式管理是一种内存空间存储管理的技术，页式管理分为静态页式管理和动态页式管理。

基本原理是将各进程的虚拟空间划分成若干个长度相等的页(page)，页式管理把内存空间按页的大小划分成片或者页面（page frame），然后把页式虚拟地址与内存地址建立一一对应页表，并用相应的硬件地址变换机构，来解决离散地址变换问题。

页式管理采用请求调页或预调页技术实现了内外存存储器的统一管理。

图1 页的划分1.2实验要求⑴能够输入给定的内存页面数，页面大小，进程的个数及每个进程的页数。

⑵当某进程提出申请空间的大小后，显示能否满足申请，以及为该进程分配资源后内存空间的使用情况（被进程占用的页面，空闲的页面）。

⑶当某进程撤消时，显示内存回收后内存空间的使用情况。

2功能设计2.1算法分析模拟页式管理中置换算法中的先进先出算法（FIFO），FIFO算法总是选择在内存驻留时间最长的一页将其淘汰。

图2算法流程图2.2数据结构（1）定义整型变量length来保存进程的页面数，定义数组order[30]来存储进程页面的逻辑地址，数组ad[100]存放逻辑页的页内位移。

（2）定义变量num_page存储物理块的数目，定义变量wlsize存储物理块的大小，物理块的大小一般为2的n次方，定义数组a[10]存放物理块中的存储的逻辑页。

（3）定义数组result[20][30]存储记录结果，定义数组result1[30]记录是否缺页。

算法与分析实验报告

算法与分析实验报告一、引言算法是现代计算机科学中的核心概念，通过合理设计的算法可以解决复杂的问题，并提高计算机程序的执行效率。

本次实验旨在通过实际操作和数据统计，对比分析不同算法的执行效率，探究不同算法对于解决特定问题的适用性和优劣之处。

二、实验内容本次实验涉及两个经典的算法问题：排序和搜索。

具体实验内容如下：1. 排序算法- 冒泡排序- 插入排序- 快速排序2. 搜索算法- 顺序搜索- 二分搜索为了对比不同算法的执行效率，我们需要设计合适的测试用例并记录程序执行时间进行比较。

实验中，我们将使用随机生成的整数数组作为排序和搜索的测试数据，并统计执行时间。

三、实验步骤1. 算法实现与优化- 实现冒泡排序、插入排序和快速排序算法，并对算法进行优化，提高执行效率。

- 实现顺序搜索和二分搜索算法。

2. 数据生成- 设计随机整数数组生成函数，生成不同大小的测试数据。

3. 实验设计- 设计实验方案，包括测试数据的规模、重复次数等。

4. 实验执行与数据收集- 使用不同算法对随机整数数组进行排序和搜索操作，记录执行时间。

- 多次重复同样的操作，取平均值以减小误差。

5. 数据分析与结果展示- 将实验收集到的数据进行分析，并展示在数据表格或图表中。

四、实验结果根据实验数据的收集与分析，我们得到以下结果：1. 排序算法的比较- 冒泡排序：平均执行时间较长，不适用于大规模数据排序。

- 插入排序：执行效率一般，在中等规模数据排序中表现良好。

- 快速排序：执行效率最高，适用于大规模数据排序。

2. 搜索算法的比较- 顺序搜索：执行时间与数据规模成线性关系，适用于小规模数据搜索。

- 二分搜索：执行时间与数据规模呈对数关系，适用于大规模有序数据搜索。

实验结果表明，不同算法适用于不同规模和类型的问题。

正确选择和使用算法可以显著提高程序的执行效率和性能。

五、实验总结通过本次实验，我们深入了解了不同算法的原理和特点，并通过实际操作和数据分析对算法进行了比较和评估。

算法设计与分析实验报告

算法设计与分析实验报告算法设计与分析实验报告引言：算法设计与分析是计算机科学中的重要课程，它旨在培养学生解决实际问题的能力。

本次实验旨在通过设计和分析不同类型的算法，加深对算法的理解，并探索其在实际应用中的效果。

一、实验背景算法是解决问题的步骤和方法的描述，是计算机程序的核心。

在本次实验中，我们将重点研究几种经典的算法，包括贪心算法、动态规划算法和分治算法。

通过对这些算法的设计和分析，我们可以更好地理解它们的原理和应用场景。

二、贪心算法贪心算法是一种基于局部最优选择的算法，它每一步都选择当前状态下的最优解，最终得到全局最优解。

在实验中，我们以背包问题为例，通过贪心算法求解背包能够装下的最大价值物品。

我们首先将物品按照单位重量的价值从大到小排序，然后依次将能够装入背包的物品放入，直到背包无法再装下物品为止。

三、动态规划算法动态规划算法是一种通过将问题分解为子问题，并记录子问题的解来求解整体问题的算法。

在实验中，我们以斐波那契数列为例，通过动态规划算法计算斐波那契数列的第n项。

我们定义一个数组来保存已经计算过的斐波那契数列的值，然后通过递推公式将前两项的值相加得到后一项的值，最终得到第n项的值。

四、分治算法分治算法是一种将问题分解为更小的子问题，并通过递归求解子问题的算法。

在实验中，我们以归并排序为例，通过分治算法对一个无序数组进行排序。

我们首先将数组分成两个子数组，然后对子数组进行递归排序，最后将两个有序的子数组合并成一个有序的数组。

五、实验结果与分析通过对以上三种算法的设计和分析，我们得到了以下实验结果。

在贪心算法中，我们发现该算法能够在有限的时间内得到一个近似最优解，但并不能保证一定得到全局最优解。

在动态规划算法中，我们发现该算法能够通过记忆化搜索的方式得到准确的结果，但在问题规模较大时，其时间复杂度较高。

在分治算法中，我们发现该算法能够将问题分解为更小的子问题，并通过递归求解子问题，最终得到整体问题的解。

算法分析实验报告

《算法设计与分析》实验报告分治策略一、试验名称：分治策略( 1) 写出源程序，并编译运行( 2) 详细记录程序调试及运行结果二、实验目的(1) 了解分治策略算法思想(2) 掌握快速排序、归并排序算法(3) 了解其他分治问题典型算法三、实验内容(1) 编写一个简单的程序，实现归并排序。

(2) 编写一段程序，实现快速排序。

(3) 编写程序实现循环赛日程表。

设有n=2k 个运动员要进行网球循环赛。

现要设计一个满足以下要求的比赛日程表： (1)每个选手必须与其它n-1 个选手各赛一次( 2)每个选手一天只能赛一场( 3)循环赛进行n-1 天四、算法思想分析(1) 编写一个简单的程序，实现归并排序。

将待排序元素分成大小大致相同的 2 个子集合，分别对 2 个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。

(2) 编写一段程序，实现快速排序。

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

(3) 编写程序实现循环日赛表。

按分治策略，将所有的选手分为两组，n 个选手的比赛日程表就可以通过为n/2 个选手设计的比赛日程表来决定。

递归地用对选手进行分割，直到只剩下 2 个选手时，比赛日程表的制定就变得很简单。

这时只要让这 2 个选手进行比赛就可以了。

五、算法源代码及用户程序(1) 编写一个简单的程序，实现归并排序。

#include<iostream>#include<>#define MAX 10using namespace std;void merge(int array[],int p,int q,int r){int i,k;int begin1,end1,begin2,end2;int* temp = new int[r-p+1];begin1 = p;end1 = q;begin2 = q+1;end2 = r;k = 0;while((begin1 <= end1)&&(begin2 <= end2)){if(array[begin1] < array[begin2]){temp[k] = array[begin1];begin1++;}else{temp[k] = array[begin2];begin2++;}k++;}while(begin1 <= end1) {temp[k++] = array[begin1++];while(begin2 <= end2){temp[k++] = array[begin2++];}for(i = 0;i < (r-p+1);i++){array[p+i] = temp[i];}delete[](temp);}void merge_sort(int data[],int left,int right){if(left < right){int mid = (left + right)/2;merge_sort(data,left,mid);merge_sort(data,mid + 1,right); merge(data,left,mid,right);}}void main(){int number[MAX] = {0};srand(time(NULL));printf(" 排序前：");for(int i = 0; i < MAX; i++) {number[i] = rand() % 100; printf("%d ", number[i]);}cout<<endl;merge_sort(number,0,9);printf(" 排序后：");for(int j = 0; j < MAX; j++) { printf("%d ", number[j]);}(2) 编写一段程序，实现快速排序。

武汉理工大学数据结构与算法综合实验哈夫曼树

..
v
.. .
..
.
typedef char * pBuffer ; //其大小视原文件压缩后的大小
2.核心算法设计
(1)生成 Huffman 树和 Huffman 编码的算法 void Select(HTNode huffTree[],int m) {
int min,min2,i; min=min2=1000; for(i=0;i<m;i++)
b=b<<1; if(pBinStr[i]=='1') {
b=b|0x01; } } return b; } bool InitHead(const char *pFilename,HEAD &sHead) { char ch;
..
v
.. . .. .
..
.
.. .
//初始化文件 strcpy(sHead.type,"HUF"); sHead.length=0; for(int i=0;i<256;i++) {
..
v
.. .
..
.
.. .
二叉树的存储结构。使用结构体存储节点，使用数组存储树的节点，使用静态二叉链表方式存储二叉树。
Huffman编码存储结构 struct HTNode
{ int weight;//权值 int parent; int lchild; int rchild; char zifu; string bianma;
..
.
.. .
学生学号
Xxx
实验课成绩
学生实验报告书
实验课程名称开课学院
指导教师姓名学生姓名

武汉理工大学专业实践报告书

专业基础实践任务书学生姓名专业班级:指导教师:工作单位: 信息工程学院题目: 专业基础实践第套综合题初始条件:（）提供实验室机房及其以上版本软件；（）《教程》学习。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求):（）选择一本《教程》，认真学习该教程的全部内容，包括基本使用方法、数组运算、矩阵运算、数学运算、程序设计、符号计算、图形绘制、设计等内容；（）对该套综合题的道题，进行理论分析，针对具体设计部分的原理分析、建模、必要的推导和可行性分析，画出程序设计框图，编写程序代码（含注释），上机调试运行程序，记录实验结果（含计算结果和图表）。

（）对实验结果进行分析和总结；（）要求阅读相关参考文献不少于篇；（）根据课程设计有关规范，按时、独立完成专业基础实践说明书。

时间安排:（）布置课程设计任务,查阅资料,学习《教程》天；（）进行编程设计天；（）完成专业基础实践报告书天；（）答辩天；指导教师签名: 年月日系主任(或责任教师)签名: 年月日目录摘要 (Ⅰ)第1章关于的简介的功能的典型应用第2章设计题目第3章设计内容题一题二题三题四题五题六题七题八题九题十第4章心得体会参考文献摘要（矩阵实验室）是的缩写，是一款由美国公司出品的商业数学软件。

是一种用于算法开发、数据可视化、数据分析以及数值计算的高级技术计算语言和交互式环境。

除了矩阵运算、绘制函数数据图像等常用功能外，还可以用来创建用户界面及与调用其它语言（包括，和）编写的程序。

尽管主要用于数值运算，但利用为数众多的附加工具箱（）它也适合不同领域的应用，例如控制系统设计与分析、图像处理、信号处理与通讯、金融建模和分析等。

另外还有一个配套软件包，提供了一个可视化开发环境，常用于系统模拟、动态嵌入式系统开发等方面。

是一个包含大量计算算法的集合。

其拥有多个工程中要用到的数学运算函数，可以方便的实现用户所需的各种计算功能。

函数中所使用的算法都是科研和工程计算中的最新研究成果，而前经过了各种优化和容错处理。

武汉理工大学计算机学院数值分析实验报告

武汉理工大学计算机学‎院数值分析实验报告‎武汉理工大学计算机学‎院数值分析实验报告‎‎篇一：数‎值分析实验报告学‎生实验报告‎书实验课程名称开‎课学院指导教‎师姓名学生姓‎名学生专业班级数‎值分析计算机科学与‎技术学院熊盛武 2‎01X—— 201X‎学年第二学期‎实验课程名称：‎数值分析‎篇‎二：数值分‎析实验报告武汉理工‎大学学生实验‎报告书实验课‎程名称：数‎值分析开课‎名学生姓名‎：201X‎1—— 201X学年‎第二学期第一‎次试验（1）‎二分法计算流程图：‎简单迭代法算‎法流程图：（‎2）（3）牛‎顿迭代法流程图：‎（4）弦截法算法‎程序流程图：‎‎篇三：‎数值分析实验报告湖‎北民族学院理学院《数‎值分析》课程实验报告‎（一）湖北民‎族学院理学院《数值分‎析》课程实验报告‎（二） xn?)篇‎四：数值分析‎实验报告数值分析实‎验报告姓名：‎学号：学院‎：老师：‎ XXX XXX‎X实验一一‎、实验内容用雅克比‎迭代法和高斯塞德尔迭‎代法求解课本例‎3.1，设置精度为1‎0-6。

?8-32‎??x1??20??‎?411?‎1??x233‎??6312??x?‎?36? ??3‎??二、实验‎公式 ?? 雅克‎比迭代法的基本思想：‎设方程组Ax‎?b的系数矩阵的对角‎线元素 ??aii?‎0(i?1,2,..‎.,n)，根据方程组‎A x?b推导出一个迭‎代公式，然后将任意选‎取的?(0)?‎(1)?(1)‎?(2) xx‎x x一初始向量代入迭‎代公式，求出，再以代‎入同一迭代公式，求出‎，1、雅克比‎迭代法 ?(k)?(‎k) {x}{x}收‎敛时，如此反复进行，‎得到向量序列。

当其极‎限即为原方程组的解。

‎2、高斯塞德‎尔迭代法：‎在雅可比（Jacbi‎）迭代法中，如果当新‎的分量求出后，马上用‎它来代替旧的分量，‎则可能会更快地接近方‎程组的准确解。

基于这‎种设想构造的迭代公式‎称为高斯-塞德尔(G‎a uss-Seide‎l)迭代法。

武汉理工大学算法分析报告实验报告材料

学生实验报告书实验课程名称算法设计与分析开课学院计算机科学与技术学院指导教师姓名李晓红学生姓名学生专业班级软件工程zy1302班2015-- 2016学年第一学期实验课程名称：算法设计与分析同组者实验日期2015年10月20日第一部分：实验分析与设计一．实验内容描述（问题域描述）1、利用分治法，写一个快速排序的递归算法，并利用任何一种语言，在计算机上实现，同时进行时间复杂性分析；2、要求用递归的方法实现。

二.实验基本原理与设计（包括实验方案设计，实验手段的确定，试验步骤等，用硬件逻辑或者算法描述）本次的解法使用的是“三向切分的快速排序”，它是快速排序的一种优化版本。

不仅利用了分治法和递归实现，而且对于存在大量重复元素的数组，它的效率比快速排序基本版高得多。

它从左到右遍历数组一次，维护一个指针lt使得a[lo..lt-1]中的元素都小于v，一个指针gt 使得a[gt+1..hi]中的元素都大于v，一个指针i使得a[lt..i-1]中的元素都等于v，a[i..gt]中的元素都还未确定，如下图所示：public class Quick3way{public static void sort(Comparable[] a, int lo, int hi){if (lo >= hi)return;int lt = lo, i = lo + 1, gt = hi;Comparable pivot = a[lo];第二部分：实验调试与结果分析一、调试过程（包括调试方法描述、实验数据记录，实验现象记录，实验过程发现的问题等）1、调试方法描述：对程序入口进行断点，随着程序的运行，一步一步的调试，得到运行轨迹；2、实验数据："R", "B", "W", "W", "R", "W", "B", "R", "R", "W", "B", "R"；3、实验现象：4、实验过程中发现的问题：（1）边界问题：在设计快速排序的代码时要非常小心，因为其中包含非常关键的边界问题，例如：什么时候跳出while循环，递归什么时候结束，是对指针的左半部分还是右半部分排序等等；（2）程序的调试跳转：在调试过程中要时刻记住程序是对那一部分进行排序，当完成了这部分的排序后，会跳到哪里又去对另外的那一部分进行排序，这些都是要了然于心的，这样才能准确的定位程序。

算法分析实验一报告

《算法设计与分析》实验报告目录一、实验内容描述和功能分析.二、算法过程设计.三、程序调试及结果（附截图）.四、源代码（附源代码）.一、实验内容描述和功能分析.1.彼岸内容描述：突破蝙蝠的包围，yifenfei来到一处悬崖面前，悬崖彼岸就是前进的方向，好在现在的yifenfei已经学过御剑术，可御剑轻松飞过悬崖。

现在的问题是：悬崖中间飞着很多红，黄，蓝三种颜色的珠子，假设我们把悬崖看成一条长度为n的线段，线段上的每一单位长度空间都可能飞过红，黄，蓝三种珠子，而yifenfei 必定会在该空间上碰到一种颜色的珠子。

如果在连续3段单位空间碰到的珠子颜色都不一样，则yifenfei就会坠落。

比如经过长度为3的悬崖，碰到的珠子先后为“红黄蓝”，或者“蓝红黄”等类似情况就会坠落，而如果是“红黄红”或者“红黄黄”等情况则可以安全到达。

现在请问：yifenfei安然抵达彼岸的方法有多少种？输入：输入数据首先给出一个整数C，表示测试组数。

然后是C组数据，每组包含一个正整数n (n<40)。

输出：对应每组输入数据，请输出一个整数，表示yifenfei安然抵达彼岸的方法数。

每组输出占一行。

例如：输入：2 输出：92 2132.统计问题内容描述：在一无限大的二维平面中，我们做如下假设：1、每次只能移动一格；2、不能向后走（假设你的目的地是“向上”，那么你可以向左走，可以向右走，也可以向上走，但是不可以向下走）；3、走过的格子立即塌陷无法再走第二次；求走n步不同的方案数（2种走法只要有一步不一样，即被认为是不同的方案）。

输入：首先给出一个正整数C，表示有C组测试数据接下来的C行，每行包含一个整数n (n<=20)，表示要走n步。

输出：请编程输出走n步的不同方案总数；每组的输出占一行。

例如：输入：2 输出：31 723.Message Decowing内容描述：The cows are thrilled because they've just learned about encrypting messages. Theythink they will be able to use secret messages to plot meetings with cows on other farms.Cows are not known for their intelligence. Their encryption method is nothing like DES or BlowFish or any of those really good secret coding methods. No, they are using a simple substitution cipher.The cows have a decryption key and a secret message. Help them decode it. The key looks like this:yrwhsoujgcxqbativndfezmlpkWhich means that an 'a' in the secret message really means 'y'; a 'b' in the secret message really means 'r'; a 'c' decrypts to 'w'; and so on. Blanks are not encrypted; they are simply kept in place. Input text is in upper or lower case, both decrypt using the same decryption key, keeping the appropriate case, of course.输入：* Line 1: 26 lower case characters representing the decryption key* Line 2: As many as 80 characters that are the message to be decoded输出：* Line 1: A single line that is the decoded message. It should have the same length as the second line of input.例如：输入：eydbkmiqugjxlvtzpnwohracsfKifq oua zarxa suar bti yaagrj fa xtfgrj输出：Jump the fence when you seeing me coming二、算法过程设计.第一题是一个典型的递归问题，通过对开始的几项附初始值，通过循环利用通项公式依次递归调用公式便可以得到第n项的值。

武汉理工大学数据结构与算法综合实验连连看【范本模板】

学生学号Xxx实验课成绩学生实验报告书实验课程名称数据结构与算法综合实验开课学院计算机科学与技术学院指导教师姓名xx学生姓名xx学生专业班级xxxx2015-- 2016学年第 2 学期实验课程名称: 数据结构与算法综合实验①判断（行数＊列数%花色数）是否为0。

如果不为0，则进行异常处理。

②判断每一种花色的重复数能否被2整除，如果不能被二整除，则进行异常处理。

3)按从左到右,从上到下，将花色数填入游戏地图.实现代码如下：int nRepeatNum = nRows * nCols / nPicNums;int count = 0;for (int i = 0； i<nPicNums； i++）｛for（int j = 0； j <nRepeatNum； j++)｛m_Map［count / nCols］[count%nCols］ = i;count++;}}4)由于生成的地图是规则的，因此，需要将地图中的花色打乱。

实现思路是：随机选择两个元素,将其值对调，重复若干次。

●消子判断的流程1)获得选中的两张图片的行号和列号。

2)判断选中的图片是否同色，不同色，则不能相消.判断选中的图片是否为同一个图片，如果为不为同一个图片,则不能相消。

3)判断连通性，如以下三种情况均不满足，则结束.①首先判断能否一条直线连通.②如果不能一条直线连通，则判断能否两条直线连通。

③如果不能两条直线连通，则判断能否三条直线连通.4)获得连通路径,绘制连线。

5)消除图片●一条直线消子算法①判断两个顶点,行是否相同，若相同，则判断两个顶点在X方向是否连通。

在CGameLogic类定义RowLink（）函数事项X方向的连通判断。

依次判断在X方向两个顶点间每一个顶点，是否都为空，全为空表示可以连通，否则不能连通.实现代码如下：bool CGameLogic::RowLink（int m_Map［10][15］，Vertex v1，Vertex v2）｛//将两个点的列进行调整,使nCol1的值小于nCol2的值int row=v1.row；int col1=v1.col；int col2=v2.col；if（col1>col2）｛int temp=col1;col1=col2；col2=temp;}//判断两个顶点间是否有不为空的图片for(int i=col1+1；i<=col2；i++）｛if(i==col2）｛return true；}if(m_Map［row]［i］！=BLANK）{break;｝}return false;②判断两个顶点，列是否相同，若相同,则判断两个顶点在Y方向是否连通。

算法分析实验报告总结

一、实验背景随着计算机技术的飞速发展，算法在计算机科学领域扮演着越来越重要的角色。

为了提高算法的效率，减少算法的时间复杂度和空间复杂度，算法分析成为计算机科学的重要研究方向之一。

本次实验旨在通过实际操作，分析几种常见算法的时间复杂度和空间复杂度，从而加深对算法性能的理解。

二、实验目的1. 理解算法的时间复杂度和空间复杂度的概念；2. 掌握常见算法的时间复杂度和空间复杂度分析方法；3. 分析不同算法的性能差异，为实际应用提供参考。

三、实验内容1. 算法选择本次实验选择了以下几种常见算法进行分析：（1）冒泡排序（Bubble Sort）（2）选择排序（Selection Sort）（3）插入排序（Insertion Sort）（4）快速排序（Quick Sort）（5）归并排序（Merge Sort）2. 实验方法（1）数据准备：随机生成不同规模的测试数据，如1000、2000、3000、4000、5000个元素；（2）算法实现：分别用C++语言实现上述五种算法；（3）性能测试：对每种算法进行性能测试，记录每种算法在不同数据规模下的执行时间；（4）结果分析：根据测试结果，分析每种算法的时间复杂度和空间复杂度。

四、实验结果与分析1. 冒泡排序冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

在实验中，随着数据规模的增加，冒泡排序的执行时间急剧增加。

当数据规模达到5000时，执行时间已超过30秒。

2. 选择排序选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

实验结果表明，选择排序的执行时间与冒泡排序相似，当数据规模达到5000时，执行时间也超过30秒。

3. 插入排序插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

实验结果显示，插入排序的执行时间与冒泡排序和选择排序相似，当数据规模达到5000时，执行时间超过30秒。

4. 快速排序快速排序的平均时间复杂度为O(nlogn)，空间复杂度为O(logn)。

算法设计与分析实验报告三篇

算法设计与分析实验报告一实验名称统计数字问题评分实验日期2014 年11 月15 日指导教师姓名专业班级学号一.实验要求1、掌握算法的计算复杂性概念。

2、掌握算法渐近复杂性的数学表述。

3、掌握用C++语言描述算法的方法。

4．实现具体的编程与上机实验，验证算法的时间复杂性函数。

二.实验内容统计数字问题1、问题描述一本书的页码从自然数1 开始顺序编码直到自然数n。

书的页码按照通常的习惯编排，每个页码都不含多余的前导数字0。

例如，第6 页用数字6 表示，而不是06 或006 等。

数字计数问题要求对给定书的总页码n，计算出书的全部页码中分别用到多少次数字0，1，2， (9)2、编程任务给定表示书的总页码的10 进制整数n (1≤n≤109) 。

编程计算书的全部页码中分别用到多少次数字0，1，2， (9)三.程序算法将页码数除以10，得到一个整数商和余数，商就代表页码数减余数外有多少个1—9作为个位数，余数代表有1—余数本身这么多个数作为剩余的个位数，此外，商还代表1—商本身这些数出现了10次，余数还代表剩余的没有计算的商的大小的数的个数。

把这些结果统计起来即可。

四.程序代码#include<iostream.h>int s[10]; //记录0~9出现的次数int a[10]; //a[i]记录n位数的规律void sum(int n,int l,int m){ if(m==1){int zero=1;for(int i=0;i<=l;i++) //去除前缀0{ s[0]-=zero;zero*=10;} }if(n<10){for(int i=0;i<=n;i++){ s[i]+=1; }return;}//位数为1位时,出现次数加1//位数大于1时的出现次数for(int t=1;t<=l;t++)//计算规律f(n)=n*10^(n-1){m=1;int i;for(i=1;i<t;i++)m=m*10;a[t]=t*m;}int zero=1;for(int i=0;i<l;i++){ zero*= 10;} //求出输入数为10的n次方int yushu=n%zero; //求出最高位以后的数int zuigao=n/zero; //求出最高位zuigaofor(i=0;i<zuigao;i++){ s[i]+=zero;} //求出0~zuigao-1位的数的出现次数for(i=0;i<10;i++){ s[i]+=zuigao*a[l];} //求出与余数位数相同的0~zuigao-1位中0~9出现的次数//如果余数是0,则程序可结束,不为0则补上所缺的0数,和最高位对应所缺的数if(yushu==0) //补上所缺的0数,并且最高位加1{ s[zuigao]++;s[0]+=l; }else{ i=0;while((zero/=10)>yushu){ i++; }s[0]+=i*(yushu+1);//补回因作模操作丢失的0s[zuigao]+=(yushu+1);//补回最高位丢失的数目sum(yushu,l-i-1,m+1);//处理余位数}}void main(){ int i,m,n,N,l;cout<<"输入数字要查询的数字:";cin>>N;cout<<'\n';n = N;for(i=0;n>=10;i++){ n/=10; } //求出N的位数n-1l=i;sum(N,l,1);for(i=0; i<10;i++){ cout<< "数字"<<i<<"出现了:"<<s[i]<<"次"<<'\n'; }} 五.程序调试中的问题调试过程，页码出现报错。