武汉理工大学算法分析实验报告
实验报告算法分析
实验报告算法分析实验报告：算法分析引言在计算机科学领域中，算法是解决问题的一种方法或步骤的描述。
通过对算法的分析，我们可以评估其效率和性能，从而选择最优的算法来解决特定的问题。
本实验报告旨在介绍算法分析的基本概念和方法，并通过实例来说明其应用。
一、算法分析的背景算法分析是计算机科学中的重要研究领域，它关注如何评估算法的效率和性能。
在实际应用中，我们经常面临着需要在有限的时间内解决大规模问题的挑战。
因此，选择一个高效的算法是至关重要的。
算法分析的目标是通过定量分析算法的时间复杂度和空间复杂度，为选择最佳算法提供依据。
二、算法分析的方法1. 时间复杂度分析时间复杂度是衡量算法执行时间的一种指标。
通常使用大O表示法来表示时间复杂度。
通过计算算法执行所需的基本操作次数，可以得到算法的时间复杂度。
常见的时间复杂度有O(1)、O(log n)、O(n)、O(n log n)和O(n^2)等。
时间复杂度越低，算法执行所需的时间越短。
2. 空间复杂度分析空间复杂度是衡量算法内存使用的一种指标。
通过计算算法执行所需的额外空间大小，可以得到算法的空间复杂度。
常见的空间复杂度有O(1)、O(n)和O(n^2)等。
空间复杂度越低，算法所需的内存空间越小。
三、算法分析的应用算法分析在计算机科学的各个领域都有广泛的应用。
以下是几个常见的应用示例：1. 排序算法排序算法是计算机科学中的经典问题之一。
通过对不同排序算法的时间复杂度进行分析，可以选择最适合特定需求的排序算法。
例如，快速排序算法的平均时间复杂度为O(n log n)，在大规模数据排序中表现出色。
2. 图算法图算法是解决图结构相关问题的一种方法。
通过对图算法的时间复杂度和空间复杂度进行分析，可以选择最适合解决特定图问题的算法。
例如，广度优先搜索算法的时间复杂度为O(V+E)，其中V和E分别表示图的顶点数和边数。
3. 动态规划算法动态规划算法是解决具有重叠子问题性质的问题的一种方法。
算法设计与分析的实验报告
实验一递归与分治策略一、实验目的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>。
武汉理工大学算法分析实验报告
学生实验报告书实验课程名称算法设计与分析开课学院计算机科学与技术学院指导教师姓名李晓红学生姓名学生专业班级软件工程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.矩阵连乘问题内容描述：给定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)插入排序是一种稳定的排序算法，其时间复杂度与冒泡排序和选择排序相同，适用于小规模数据排序。
武汉理工大学计算机学院数值分析实验报告
武汉理工大学计算机学院数值分析实验报告武汉理工大学计算机学院数值分析实验报告篇一：数值分析实验报告学生实验报告书实验课程名称开课学院指导教师姓名学生姓名学生专业班级数值分析计算机科学与技术学院熊盛武 201X—— 201X学年第二学期实验课程名称：数值分析篇二：数值分析实验报告武汉理工大学学生实验报告书实验课程名称：数值分析开课名学生姓名：201X1—— 201X学年第二学期第一次试验（1）二分法计算流程图：简单迭代法算法流程图：（2）（3）牛顿迭代法流程图：（4）弦截法算法程序流程图：篇三：数值分析实验报告湖北民族学院理学院《数值分析》课程实验报告（一）湖北民族学院理学院《数值分析》课程实验报告（二） xn?)篇四：数值分析实验报告数值分析实验报告姓名：学号：学院：老师： XXX XXXX实验一一、实验内容用雅克比迭代法和高斯塞德尔迭代法求解课本例3.1，设置精度为10-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) xxx x一初始向量代入迭代公式，求出，再以代入同一迭代公式，求出，1、雅克比迭代法 ?(k)?(k) {x}{x}收敛时，如此反复进行，得到向量序列。
当其极限即为原方程组的解。
2、高斯塞德尔迭代法：在雅可比（Jacbi）迭代法中，如果当新的分量求出后，马上用它来代替旧的分量，则可能会更快地接近方程组的准确解。
基于这种设想构造的迭代公式称为高斯-塞德尔(Ga uss-Seidel)迭代法。
武汉理工大学操作系统实践报告
实践课设计报告课程名称计算机操作系统模拟设计存储管理的分配与题目回收学院计算机科学与技术学院专业计算机科学与技术班级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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学生学号实验课成绩学生实验报告书实验课程名称算法设计与分析开课学院计算机科学与技术学院指导教师姓名晓红学生姓名学生专业班级软件工程zy1302班2015 -- 2016 学年第一学期实验课程名称：算法设计与分析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];while (i <= gt){int cmp = a[i].compareTo(pivot);if (cmp > 0)exch(a, i, gt--);else if (cmp < 0)第二部分：实验调试与结果分析一、调试过程（包括调试法描述、实验数据记录，实验现象记录，实验过程发现的问题等）1、调试法描述：对程序入口进行断点，随着程序的运行，一步一步的调试，得到运行轨迹；2、实验数据："R", "B", "W", "W", "R", "W", "B", "R", "R", "W", "B", "R"；3、实验现象：4、实验过程中发现的问题：（1）边界问题：在设计快速排序的代码时要非常小心，因为其中包含非常关键的边界问题，例如：什么时候跳出while循环，递归什么时候结束，是对指针的左半部分还是右半部分排序等等；（2）程序的调试跳转：在调试过程中要时刻记住程序是对那一部分进行排序，当完成了这部分的排序后，会跳到哪里又去对另外的那一部分进行排序，这些都是要了然于心的，这样才能准确的定位程序。
二、实验结果分析（包括结果描述、实验现象分析、影响因素讨论、综合分析和结论等）1、实验结果：2、时间复杂度：介于N和NlogN之间；3、空间复杂度：lgN；4、算法总结：三项切分的快速排序不是稳定的排序，是原地排序，它的运行效率由概率保证，同时取决于输入元素的分布情况，对于包含大量重复元素的数组，它奖排序时间从线性对数级降低到了线性级别，这非常的了不起。
三、小结、建议及体会本次实验完成了三向切分的快速排序，其中不仅利用了分治法和递归，还对快速排序进行了优化，使得对于存在大量重复元素的数组，能够表现更高的效率。
在实验过程中，我遇到了不少的困难，但通过自己在网上大量的浏览文献和资料，独立解决了所有问题，收获了不少。
在下次的实验中，我也会继续努力的！实验课程名称：算法设计与分析第二部分：实验调试与结果分析一、调试过程（包括调试法描述、实验数据记录，实验现象记录，实验过程发现的问题等）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、算法总结：动态规划的基本思想：将一个问题分解为子问题递归求解，且将中间结果保存以避免重复计算。
通常用来求最优解，且最优解的局部也是最优的。
求解过程产生多个决策序列，下一步总是依赖上一步的结果，自底向上的求解。
三、小结、建议及体会源代码：实验一：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 .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);}}。