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

合集下载

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

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

实验一递归与分治策略一、实验目的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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

【实验原理】一、动态规划法解最长公共子序列设序列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) 编写一段程序,实现快速排序。

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

学生实验报告书实验课程名称算法设计与分析开课学院计算机科学与技术学院指导教师姓名李晓红学生姓名学生专业班级软件工程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、实验结果:实验课程名称:算法设计与分析第二部分:实验调试与结果分析一、调试过程(包括调试方法描述、实验数据记录,实验现象记录,实验过程发现的问题等)1、调试方法:直接在方法入口断点调试,一步一步跟踪程序,弄明白程序的运行轨迹;2、实验数据:int m = 10;int n = 3;int[] w = {3, 4, 5};int[] p = {4, 5, 6};3、实验中遇到问题:(1)刚开始对动态规划算法不熟悉,编码时出现很多的错误,花费了很多的时间;(2)没有深度理解此处为什么要使用动态规划算法,导致对问题的理解不深刻。

二、实验结果分析(包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等)1、实验结果:2、时间复杂度:nm;3、空间复杂度:nm(可优化至m);4、算法总结:动态规划的基本思想:将一个问题分解为子问题递归求解,且将中间结果保存以避免重复计算。

通常用来求最优解,且最优解的局部也是最优的。

求解过程产生多个决策序列,下一步总是依赖上一步的结果,自底向上的求解。

三、小结、建议及体会本次实验解决了0/1背包问题,掌握动态规划算法求解问题的一般特征和步骤。

在实验过程中,我遇到了很多不懂的问题,但通过老师和同学们的帮助,和自己的努力,最终解决了所有问题,收获颇丰。

在今后的算法设计中,我会迎难而上!源代码:实验一:import java.util.Arrays;public class Quick3way{public static void sort(Comparable[] a){sort(a, 0, a.length - 1);}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];while (true){int cmp = a[i].compareTo(pivot);if (cmp > 0)exch(a, i, gt--);else if (cmp < 0)exch(a, i++, lt++);elsei++;if (i > gt)break;}sort(a, lo, lt - 1);sort(a, gt + 1, hi);}private static void exch(Comparable[] a, int i, int j) {Comparable temp = a[i];a[i] = a[j];a[j] = temp;}public static void show(Comparable[] a){System.out.println(Arrays.toString(a));}public static void main(String[] args){String[] a = {"R", "B", "W", "W", "R", "W", "B", "R", "R", "W", "B", "R"};System.out.println("排序前:\t");show(a);sort(a); // 对数组a进行排序System.out.println("排序后:\t");show(a);}}实验二:package com.shawn;public class Package01{public int[][] pack(int m, int n, int w[], int p[]){//c[i][v]表示前i件物品恰放入一个重量为m的背包可以获得的最大价值int c[][] = new int[n + 1][m + 1];for (int i = 0; i < n + 1; i++)c[i][0] = 0;for (int j = 0; j < m + 1; j++)c[0][j] = 0;for (int i = 1; i < n + 1; i++){for (int j = 1; j < m + 1; j++){//当物品为i件重量为j时,如果第i件的重量(w[i-1])小于重量j时,c[i][j]为下列两种情况之一://(1)物品i不放入背包中,所以c[i][j]为c[i-1][j]的值//(2)物品i放入背包中,则背包剩余重量为j-w[i-1],所以c[i][j]为c[i-1][j-w[i-1]]的值加上当前物品i的价值if (w[i - 1] <= j){if (c[i - 1][j] < (c[i - 1][j - w[i - 1]] + p[i - 1])) c[i][j] = c[i - 1][j - w[i - 1]] + p[i - 1];elsec[i][j] = c[i - 1][j];}elsec[i][j] = c[i - 1][j];}}return c;}// 逆推法求出最优解public int[] printPack(int c[][], int w[], int m, int n){int x[] = new int[n];//从最后一个状态记录c[n][m]开始逆推for (int i = n; i > 0; i--){//如果c[i][m]大于c[i-1][m],说明c[i][m]这个最优值中包含了w[i-1](注意这里是i-1,因为c数组长度是n+1)if (c[i][m] > c[i - 1][m]){x[i - 1] = 1;m -= w[i - 1];}}for (int j = 0; j < n; j++)System.out.println("第" + j + "号背包:" + x[j]);return x;}public static void main(String args[]){int m = 10; // 背包容量int n = 3; // 物品数量int w[] = {3, 4, 5}; // 物品重量int p[] = {4, 5, 6}; // 物品价值Package01 pack = new Package01();int c[][] = pack.pack(m, n, w, p);pack.printPack(c, w, m, n);}}。

相关文档
最新文档