实验一 简单算法设计
算法与程序设计实验一实验报告.docx
实验一：C程序的运行环境和运行C程序的方法
（5）输入并编辑一个有错误的C程序。
a.输入教材第1章例1.2，故意漏打或打错几个字符。
b.进行编译，仔细分析编译信息窗口，可能显示有多个错误，进行修改，直到不出现错误。
最后请
与教材上的程序对照。
c.使程序运行，分析运行结果。
（6）输入并运行一个需要在运行时输入数据的程序。
a.输入下面的程序：
# include<stdio.h>
int max (int x, int y)
{ int z;
if (x>y) z=x;
else z=y;
）运行一个自己编写的程序。
题目是教材第1章的习题1.6。
即输入a、b、c 3个值，输出其中最大者。
1)输入自己编写的源程序；
检查程序有无错误（包括语法错误和逻辑错误），有则改之。
编译和连接，仔细分析编译信息，如有错误，应找出原因并改正之。
运行程序，输入数据，分析结果。
运算结果。
算法设计与分析实验报告
实验一排序算法设计一、实验内容冒泡排序二、实验问题分析该问题主要涉及到了指针和循环和相互比较的方法，是综合知识的应用。
三、数学模型根据题目要求，依次对每个数据进行比较，直至得出最后结果。
如果a>b则交换位置，如果a<b则不交换。
四、程序流程图五、源代码#include <stdio.h>void sort(int a[]){int temp;for(int i=0;i<9;i++){for(int j=0;j<10-i-1;j++){if(a[j]>a[j+1]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}printf("排序后的数据\n"); for(i=0;i<10;i++){if(i==5){printf("\n");}printf("%d ",a[i]);}printf("\n");}void main(){int a[10];for(int i=0;i<10;i++){scanf("%d",&a[i]);}printf("排序前的数据\n"); for(i=0;i<10;i++){if(i==5){printf("\n");}printf("%d ",a[i]);}printf("\n");sort(a);}六、测试结果实验二递归算法设计一、实验内容1.判断S字符是否为“回文”的递归函数，并编写程序测试。
二、实验问题分析递归是一个过程或函数在其定义或说明中又直接或间接调用自身的一种方法。
递归算法设计，就是把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题，在逐步求解小问题后，再返回（回溯）得到大问题的解。
《算法设计综合实验》教案（5篇）
《算法设计综合实验》教案（5篇）第一篇：《算法设计综合实验》教案《算法设计综合实验》教案统计与应用数学学院2012年5月11日制实验一数据类型、运算符和表达式实验目的：1、掌握C语言数据类型，熟悉如何定义一个整型、字符型和实型的变量，以及对它们赋值的方法；2、掌握不同的数据类型之间赋值的规律；3、学会使用C的有关算术运算符，以及包含这些运算符的表达式，特别是自加和自减运算符的使用；4、学会使用赋值运算符及复合赋值运算符；5、进一步熟悉C程序的编辑、编译、连接和运行的过程。
实验环境：Windows操作系统、Visual C++6.0实验学时：2学时；实验内容：1、整型变量实型变量、字符型变量的定义与输出，赋整型常量值时的情形，以及给整型变量赋字符常量值时的情形；2、各类数值型数据间的混合运算；3、要将“China”译成密码，密码规律是：用原来的字母后面第4各字母代替原来的字母。
例如，字母“A”后面第4个字母是“E”，用“E”代替“A”。
因此，“China”应译成“Glmre”。
请编一程序，用赋初值的方法使c1、c2、c3、c4、c5这5个变量的值分别为’C’、’h’、’i’、’n’、’a’，经过运算，使c1、c2、c3、c4、c5分别变为’G’、’l’、’m’、’r’、’e’，并输出。
实验二顺序结构程序设计实验目的：1、掌握C语言中赋值语句的使用方法；2、掌握各种类型数据的输入输出方法，能正确使用各种格式转换符；3、学习调试程序。
实验环境： Windows操作系统、Visual C++6.0 实验学时：2学时；实验内容：1、掌握各种格式转换符的正确使用方法；2、设圆半径r=1.5，圆柱高h=3，求圆周长、圆面积、圆球表面积、圆球体积、圆柱体积。
用scanf输入数据，输出计算结果。
输出时要有文字说明，取小数点后两位数字。
3、编程序：用getchar函数读入两个字符给c1、c2，然后分别用putchar函数和printf函数输出这两个字符。
算法设计实验报告
算法设计实验报告一、实验目的本次算法设计实验的主要目的是通过实际操作和分析，深入理解算法的原理和应用，提高解决实际问题的能力，培养创新思维和逻辑推理能力。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
同时，为了进行算法的性能分析和可视化，还使用了一些相关的库，如 time 用于计算时间开销，matplotlib 用于绘制图表。
三、实验内容（一）排序算法的实现与比较1、冒泡排序冒泡排序是一种简单的排序算法。
它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
以下是冒泡排序的 Python 代码实现：｀｀｀pythondef bubble_sort(arr)：n ＝ len(arr)for i in range(n)：for j in range(0, n i 1)：if arrj ＞ arrj ＋ 1 ：arrj, arrj ＋ 1 ＝ arrj ＋ 1, arrj｀｀｀2、快速排序快速排序是对冒泡排序的一种改进。
它采用了分治的策略，通过选择一个基准元素，将待排序的序列分割成两个子序列，其中一个子序列的所有元素都小于等于基准元素，另一个子序列的所有元素都大于等于基准元素，然后对这两个子序列分别进行快速排序。
以下是快速排序的 Python 代码实现：｀｀｀pythondef quick_sort(arr, low, high)：if low ＜ high:pi ＝ partition(arr, low, high)quick_sort(arr, low, pi 1)quick_sort(arr, pi ＋ 1, high)def partition(arr, low, high)：pivot ＝ arrhighi ＝（low 1)for j in range(low, high)：if arrj ＜＝ pivot:i ＝ i ＋ 1arri, arrj ＝ arrj, arriarri ＋ 1, arrhigh ＝ arrhigh, arri ＋ 1return （i ＋ 1)｀｀｀（二）搜索算法的实现与比较1、顺序搜索顺序搜索是一种最简单的搜索算法，它从数组的开头开始，依次比较每个元素，直到找到目标元素或者遍历完整个数组。
lab1_简单算法
lab1_简单算法实验⼀简单算法设计⼀.实验⽬的和要求1. 理解算法设计与分析的基本概念，理解解决问题的算法设计与实现过程；2. 掌握简单问题的算法设计与分析，能设计⽐较⾼效的算法；3. 熟悉C/C++语⾔等的集成开发环境，掌握简单程序设计与实现的能⼒；⼆.基本原理算法是有穷指令集合，它为某个特定类型问题提供了解决问题的运算序列。
衡量算法效率⾼低的重要标准是算法的计算复杂性，包括：算法的时间复杂性和空间复杂性。
算法的时间复杂性指算法执⾏过程中所需的时间，通常指算法中元运算的执⾏次数，其为问题规模的函数。
算法的时间复杂性分析⼀般是近似地估算问题规模充分⼤时的时间增长率，⽤O, Ω, Θ估计。
算法的空间复杂性指算法执⾏过程中所需的内存空间。
简单算法设计是培养解决简单的实际应⽤问题的算法设计和分析的实践能⼒，具备基本的程序设计与实现的能⼒。
三.该类算法设计与实现的要点算法时间复杂性通过以下⽅法来估计：（1）计算迭代（循环）次数（2）计算基本运算的频度（3）利⽤递推（递归）关系。
算法最坏情况和平均情况时间复杂性是算法时间复杂性的重要指标。
空间复杂性的分析类似于时间复杂性。
简单算法设计通过分析实际问题，构思⼏种解决问题的算法，分析算法的复杂性，从⽽寻找⽐较⾼效的算法，并实现。
四．实验内容(⼀)相等元素问题1.问题描述元素唯⼀性问题：给出⼀个整数集合，假定这些整数存储在数组A[1…n]中，确定它们中是否存在两个相等的元素。
请设计出⼀个有效算法来解决这个问题，你的算法的时间复杂性是多少？2.代码如下#include#define N 500int main(){int i,j,m,n,t,k=0;int a[N];printf("请输⼊测试的数的个数：\n");scanf("%d",&m);for(t=0;t{printf("请输⼊序列的长度：\n");scanf("%d",&n);printf("请输⼊序列的数字：\n");for(i=0;iscanf("%d",&a[i]);for(i=0;ifor(j=i+1;j{if(a[i]==a[j]){ k=1;printf("yes\n");break;}}if(k!=1) printf("no\n");}return 0;}(⼆) 整数集合分解1.问题描述设计算法把⼀个n个元素的整数集合（n为偶数）分成两个⼦集S1和S2，使得：每个新的集合中含有n/2个元素，且S1中的所有元素的和与S2中的所有元素的和的差最⼤。
算法设计与分析实验报告
实验一找最大和最小元素与归并分类算法实现（用分治法）一、实验目的1．掌握能用分治法求解的问题应满足的条件；2．加深对分治法算法设计方法的理解与应用；3．锻炼学生对程序跟踪调试能力；4．通过本次实验的练习培养学生应用所学知识解决实际问题的能力。
二、实验内容1、找最大和最小元素输入n 个数，找出最大和最小数的问题。
2、归并分类将一个含有n个元素的集合，按非降的次序分类（排序）。
三、实验要求（1）用分治法求解问题（2）上机实现所设计的算法；四、实验过程设计（算法设计过程）1、找最大和最小元素采用分治法，将数组不断划分，进行递归。
递归结束的条件为划分到最后若为一个元素则max和min都是这个元素，若为两个取大值赋给max，小值给min。
否则就继续进行划分，找到两个子问题的最大和最小值后，比较这两个最大值和最小值找到解。
2、归并分类使用分治的策略来将一个待排序的数组分成两个子数组，然后递归地对子数组进行排序，最后将排序好的子数组合并成一个有序的数组。
在合并过程中，比较两个子数组的首个元素，将较小的元素放入辅助数组，并指针向后移动，直到将所有元素都合并到辅助数组中。
五、源代码1、找最大和最小元素#include<iostream>using namespace std;void MAXMIN(int num[], int left, int right, int& fmax, int& fmin); int main() {int n;int left=0, right;int fmax, fmin;int num[100];cout<<"请输入数字个数：";cin >> n;right = n-1;cout << "输入数字:";for (int i = 0; i < n; i++) {cin >> num[i];}MAXMIN(num, left, right, fmax, fmin);cout << "最大值为：";cout << fmax << endl;cout << "最小值为：";cout << fmin << endl;return 0;}void MAXMIN(int num[], int left, int right, int& fmax, int& fmin) { int mid;int lmax, lmin;int rmax, rmin;if (left == right) {fmax = num[left];fmin = num[left];}else if (right - left == 1) {if (num[right] > num[left]) {fmax = num[right];fmin = num[left];}else {fmax = num[left];fmin = num[right];}}else {mid = left + (right - left) / 2;MAXMIN(num, left, mid, lmax, lmin);MAXMIN(num, mid+1, right, rmax, rmin);fmax = max(lmax, rmax);fmin = min(lmin, rmin);}}2、归并分类#include<iostream>using namespace std;int num[100];int n;void merge(int left, int mid, int right) { int a[100];int i, j,k,m;i = left;j = mid+1;k = left;while (i <= mid && j <= right) {if (num[i] < num[j]) {a[k] = num[i++];}else {a[k] = num[j++];}k++;}if (i <= mid) {for (m = i; m <= mid; m++) {a[k++] = num[i++];}}else {for (m = j; m <= right; m++) {a[k++] = num[j++];}}for (i = left; i <= right; i++) { num[i] = a[i];}}void mergesort(int left, int right) { int mid;if (left < right) {mid = left + (right - left) / 2;mergesort(left, mid);mergesort(mid + 1, right);merge(left, mid, right);}}int main() {int left=0,right;int i;cout << "请输入数字个数：";cin >> n;right = n - 1;cout << "输入数字:";for (i = 0; i < n; i++) {cin >> num[i];}mergesort(left,right);for (i = 0; i < n; i++) {cout<< num[i];}return 0;}六、运行结果和算法复杂度分析1、找最大和最小元素图1-1 找最大和最小元素结果算法复杂度为O(logn）2、归并分类图1-2 归并分类结果算法复杂度为O(nlogn）实验二背包问题和最小生成树算法实现（用贪心法）一、实验目的1．掌握能用贪心法求解的问题应满足的条件；2．加深对贪心法算法设计方法的理解与应用；3．锻炼学生对程序跟踪调试能力；4．通过本次实验的练习培养学生应用所学知识解决实际问题的能力。
常见算法设计实验报告(3篇)
第1篇一、实验目的通过本次实验，掌握常见算法的设计原理、实现方法以及性能分析。
通过实际编程，加深对算法的理解，提高编程能力，并学会运用算法解决实际问题。
二、实验内容本次实验选择了以下常见算法进行设计和实现：1. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。
2. 查找算法：顺序查找、二分查找。
3. 图算法：深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim算法、Kruskal算法）。
4. 动态规划算法：0-1背包问题。
三、实验原理1. 排序算法：排序算法的主要目的是将一组数据按照一定的顺序排列。
常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。
2. 查找算法：查找算法用于在数据集中查找特定的元素。
常见的查找算法包括顺序查找和二分查找。
3. 图算法：图算法用于处理图结构的数据。
常见的图算法包括深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树（Prim算法、Kruskal算法）等。
4. 动态规划算法：动态规划算法是一种将复杂问题分解为子问题，通过求解子问题来求解原问题的算法。
常见的动态规划算法包括0-1背包问题。
四、实验过程1. 排序算法（1）冒泡排序：通过比较相邻元素，如果顺序错误则交换，重复此过程，直到没有需要交换的元素。
（2）选择排序：每次从剩余元素中选取最小（或最大）的元素，放到已排序序列的末尾。
（3）插入排序：将未排序的数据插入到已排序序列中适当的位置。
（4）快速排序：选择一个枢纽元素，将序列分为两部分，使左侧不大于枢纽，右侧不小于枢纽，然后递归地对两部分进行快速排序。
（5）归并排序：将序列分为两半，分别对两半进行归并排序，然后将排序好的两半合并。
（6）堆排序：将序列构建成最大堆，然后重复取出堆顶元素，并调整剩余元素，使剩余元素仍满足最大堆的性质。
2. 查找算法（1）顺序查找：从序列的第一个元素开始，依次比较，直到找到目标元素或遍历完整个序列。
算法分析实验一报告
《算法设计与分析》实验报告目录一、实验内容描述和功能分析.二、算法过程设计.三、程序调试及结果（附截图）.四、源代码（附源代码）.一、实验内容描述和功能分析.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项的值。
算法分析与设计实验报告
算法分析与设计实验报告实验一分治策略排序一、实验目的1）以排序问题为例，掌握分治法的基本设计策略；2）熟练掌握合并排序算法的实现；3）熟练掌握快速排序算法的实现；4) 理解常见的算法经验分析方法。
二、算法思路1. 合并排序算法思想：分而治之(divide - conquer);每个递归过程涉及三个步骤第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素.第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作第三, 合并: 合并两个排好序的子序列,生成排序结果.最坏时间复杂度最好时间复杂度空间复杂度2.快速排序算法思想：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。
一躺快速排序的算法是：1）、设置两个变量I、J，排序开始的时候I：=1，J：=N；2）以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；3）、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；4）、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；5）、重复第3、4步，直到I=J；三、实验内容：1. 准备实验数据要求：编写一个函数data-generate，生成2000个在区间[1,10000]上的随机整数，并将这些数输出到外部文件data.txt中。
这些数作为本算法实验的输入数据。
2. 实现合并排序算法要求：实现mergesort算法。
输入：待排数据文件data.txt；输出：有序数据文件resultsMS.txt（注：建议将此排好序的数据作为实验二的算法输入）；程序运行时间TimeMS。
算法设计实验报告
算法设计实验报告算法设计实验报告引言在计算机科学领域中，算法设计是解决问题的关键步骤之一。
通过设计高效的算法，可以在有限的时间内解决复杂的计算问题。
本文将介绍一个算法设计实验，旨在探索并比较不同算法在解决同一问题时的性能差异。
实验目的本次实验的目的是设计一个有效的算法，用于解决一个常见的计算问题。
通过实验，我们将比较不同算法的运行时间、空间复杂度以及解决问题的准确性。
实验方法本次实验的问题是寻找一个无序整数数组中的最大值和最小值。
我们将设计和实现三种不同的算法来解决这个问题，并通过实验评估它们的性能。
算法一：遍历法首先，我们设计了一种简单的遍历法。
该算法通过遍历整个数组，找到其中的最大值和最小值。
具体步骤如下：1. 初始化最大值和最小值为数组的第一个元素。
2. 遍历数组的每个元素，如果当前元素大于最大值，则更新最大值；如果当前元素小于最小值，则更新最小值。
3. 返回最大值和最小值。
算法二：分治法其次，我们采用了一种更高效的分治法。
该算法将数组分为两个子数组，分别找到子数组的最大值和最小值，然后比较得出整个数组的最大值和最小值。
具体步骤如下：1. 如果数组长度为1，则最大值和最小值都为该元素。
2. 如果数组长度为2，则比较两个元素，较大的为最大值，较小的为最小值。
3. 如果数组长度大于2，则将数组分为两个子数组，分别递归地求解子数组的最大值和最小值。
4. 比较两个子数组的最大值和最小值，得出整个数组的最大值和最小值。
算法三：优化法最后，我们提出了一种基于优化的算法。
该算法通过减少不必要的比较次数来提高效率。
具体步骤如下：1. 初始化最大值和最小值为数组的第一个元素。
2. 遍历数组的每个元素，每次比较两个元素，找出较大的和较小的。
3. 如果当前元素比较大的值还大，则更新最大值；如果当前元素比较小的值还小，则更新最小值。
4. 返回最大值和最小值。
实验结果我们使用相同的无序整数数组对三种算法进行了测试，并记录了它们的运行时间。
算法分析与设计实验报告 完整版
《算法分析与设计》课程实验实验报告专业：计算机科学与技术班级：姓名：学号：完成时间：2009年6月15日实验一算法实现一一、实验目的与要求熟悉C/C++语言的集成开发环境；通过本实验加深对分治法、贪心算法的理解。
二、实验内容:掌握分治法、贪心算法的概念和基本思想，并结合具体的问题学习如何用相应策略进行求解的方法。
三、实验题1. 【伪造硬币问题】给你一个装有n个硬币的袋子。
n个硬币中有一个是伪造的。
你的任务是找出这个伪造的硬币。
为了帮助你完成这一任务，将提供一台可用来比较两组硬币重量的仪器，利用这台仪器，可以知道两组硬币的重量是否相同。
试用分治法的思想写出解决问题的算法，并计算其时间复杂度。
2.【找零钱问题】一个小孩买了价值为33美分的糖，并将1美元的钱交给售货员。
售货员希望用数目最少的硬币找给小孩。
假设提供了数目有限的面值为25美分、10美分、5美分、及1美分的硬币。
给出一种找零钱的贪心算法。
四、实验步骤理解算法思想和问题要求；编程实现题目要求；上机输入和调试自己所编的程序；验证分析实验结果；整理出实验报告。
五、实验程序1.伪造硬币问题源程序：//c语言实现#include<stdio.h>#include<stdlib.h>#include<math.h>#define N 100#define N1 12//只能判断是否相等的天平void solve(int coin[],int count,int first,int last) {if (count==2) {printf("无法判断\n");return;}if (first==last) {//只有一个硬币时候printf("假币的序号为%d, 假币的重量为%d\n", first, coin[first]);}else if(last-first==1){ //如果只剩下两个硬币（此时count不为）if (first > 0) { //不是最开始的硬币if (coin[first] == coin[0]) //如果第first和第个相等，说明first 位置不是伪币solve(coin,count,first+1,last);else//否则，说明first位置是伪币solve(coin,count,first,last-1);}else if(last<count-1){ //不是最后的硬币if (coin[first]==coin[count-1]) //如果第first和最后一个相等，说明last位置不是伪币solve(coin,count,first+1,last);else//否则，说明first位置是伪币solve(coin,count,first,last-1);}}else if (first<last){int temp=(last-first+1)/3; //将硬币分为三组int sum1=0, sum2=0;for(int i=0;i<temp;i++){sum1+=coin[first+i];sum2+=coin[last-i];}if (sum1==sum2){ //两边的总重相等,在中间，递归solve(coin,count,first+temp,last-temp);}else {//在两边,不在中间if (sum1==coin[first+temp]*temp){ //左边的和中间的相等,在右边，递归solve(coin,count,last-temp+1,last);}else {solve(coin,count,first,first+temp-1); //右边的和中间的相等,在左边，递归}}}}void main() {int i;int coin[N]; //定义数组coin用来存放硬币重量for(i=0;i<N;i++) //初始化数组coin[i]=0; //所用硬币初始值为coin[N1]=1; //第N1个设置为，即伪币int cnt = N;printf("硬币个数：%d\n",cnt);solve(coin,cnt,0,cnt-1);}2找零钱问题（1）零钱个数无限制的时候:源程序：//c语言实现#include<stdio.h>main(){int T[]={25,10,5,1};int a[5];int money,i,j;printf("输入钱数:\n");scanf("%d",&money);for(i=0;i<4;i++){a[i]=money/T[i];money=money%T[i];}printf("找钱结果:\n硬币:\t");for(i=0;i<=3;i++){printf("%d\t|\t",T[i]);}printf("\n个数:\t");for(i=0;i<=3;i++){printf("%d\t|\t",a[i]);}printf("\n");return(0);}（2）当零钱个数有个数限制的时候：源程序：//c语言实现#include<stdio.h>main(){int T[]={25,10,5,1}; //硬币的面值int a[5]; //用来记录找钱的个数int count[]={1,2,10,1000}; //各个面值硬币的个数int money,i;printf("输入钱数:\n");scanf("%d",&money);for(i=0;i<4;i++){if(money>T[i]*count[i]){ //当剩余钱数大于当前硬币总值a[i]=count[i]; //当前硬币个数取现有的最大值money=money-T[i]*count[i];}else{a[i]=money/T[i];money=money%T[i];}}printf("找钱结果:\n硬币:\t");for(i=0;i<=3;i++){printf("%d\t|\t",T[i]);}printf("\n\n个数:\t");for(i=0;i<=3;i++){printf("%d\t|\t",a[i]);}printf("\n");return(0);}六、实验结果1伪造硬币问题运行结果：硬币个数：100假币的序号为12, 假币的重量为1截图：2找零钱问题（1、硬币个数无限制）运行结果：输入钱数:67找钱结果:硬币: 25 | 10 | 5 | 1 |个数: 2 | 1 | 1 | 2 |截图：3找零钱问题（2、硬币个数有限制，其中硬币个数限制分别为1,2,10和1000。
算法设计实验报告一_
算法设计实验报告一、实验内容：题目：题目：11、 编程实现常见排序算法，如插入排序、归并排序、快速排序、随机化的快速排序等，并统计不同输入规模下（序等，并统计不同输入规模下（11组从小到大排序，组从小到大排序，11组从大到小排序，其余组从大到小排序，其余88组随机）的平均物理执行时间。
2、编程实现循环赛日程表设有设有n=2k n=2k n=2k个运动员要进行网球循环赛，先要设计一个满足一下要求的比赛日常表：个运动员要进行网球循环赛，先要设计一个满足一下要求的比赛日常表：（1）每个选手必须与其他）每个选手必须与其他n-1n-1n-1个选手各赛一次个选手各赛一次（2）每个选手一天只能赛一次（3）循环赛一共进行n-1天二、核心代码说明：1、 sort.htemplate <class type >struct SqList {type * key;int length;};template <class type >void CreateSqList(SqList <type > &> &sl sl )//type 为int{int n;cout<<cout<<""请输入顺序表的长度"<<endl;cin>>n;sl .length=n;sl .key=.key=newnew int [sl .length+1]; assert (sl.key);srand(time(0));for (int i=1;i<=sl .length;i++){sl .key[i]=rand();}}template <class type >void OutPut(SqList <type > &> &L L ){for (int j=1;j<=L .length;++j)cout<<cout<<LL .key[j]<<.key[j]<<"\t""\t"; cout<<endl;}//折半插入排序template <class type >void BInsertSort(SqList <type > &> &L L ){int high,low,m;for (int i=2;i<=L .length;i++){L .key[0]=.key[0]=L L .key[i];.key[i];////将L.key[i]暂存到L.key[0]low=1;high=i-1; while (low<=high)(low<=high)////在key[low]到key[high]中折半查找有序插入的位置{m=(low+high)/2;m=(low+high)/2;////折半if (L .key[0]<=.key[0]<=L L .key[m])high=m-1;high=m-1;////插入低半区else low=m+1;low=m+1;////插入高半区}for(int j=i-1;j>=high+1;--j).key[j+1]=L L.key[j]; //记录后移L.key[j+1]=.key[high+1]=L L.key[0]; //插入L.key[high+1]=}}//归并排序template<class type>TR,int i,int m,int n)void Merge(type * *SRSR,type * *TR{//将有序的SR[i...m]和SR[m+1...n]归并为有序的TR[i...n] int j,k;;k++)//&&j<=n n;k++)//将SR中的记录由大到小并入TR for(j=<=m m&&j<=(j=m m+1,k=+1,k=i i;i<={SR[j])]<=SRif(SR[i]<=SR[i++];[k]=SRTR[k]=elseSR[j++];[k]=SRTR[k]=}<=m m)//将剩余的SR[i...m]赋值到TRif(i<=a=i i;a<=;a<=m m;a++)for(int a=[k++]=SRSR[a];TR[k++]=(j<=n n)//将剩余的SR[j...n]复制到TRelse if(j<=for(int b=j;b<=n;b++)[k++]=SRSR[b];TR[k++]=}template<class type>TR1,int s,int t)void MSort(type * *SRSR,type * *TR1{type TR2[100000];//数组大小可以根据实际情况重新定义int m;//将SR[s...t]归并排序为TR[s...t]==t t)if(s==SR[s];]=SRTR1[s]=elsem=(m=(s s +t )/2;)/2;////将SR[s...t]平分为SR[s...m]和SR[m+1...t] MSort(MSort(SR SR ,TR2,,TR2,s s ,m);,m);////递归地将SR[s...m]归并为有序的TR2[s...m]MSort(MSort(SR SR ,TR2,m+1,,TR2,m+1,t t ););////递归地将SR[m+1...t]归并为TR2[m+1...t]Merge(TR2,Merge(TR2,TR1TR1,s ,m,,m,t t ););////将TR2[s...m]和TR2[m+1...t]归并到TR1[s...t]}}template <class type >void MergeSort(SqList <type > &L ){//对顺序表L 作归并排序MSort(MSort(LL .key,.key,L L .key,1,.key,1,L L .length); }//快速排序template <class type >int Partition(SqList <type >& >& L L ,int low ,int high ){//交换顺序表L 中子表key[low]--key[high]中的记录，枢轴记录到位，并返回其所在位置，//此时在它之前（后）的记录均不大（小）于它type pivotkey;L .key[0]=.key[0]=L L .key[.key[low low ];];////用子表的第一个记录作枢轴记录pivotkey=pivotkey=L L .key[.key[low low ];];////关键字while (low <high )//从表的两端交替向中间扫描{while (low <high &&&&L L .key[.key[high high ]>=pivotkey) --high ;L .key[.key[low low ]=]=L L .key[.key[high high ];];////将比枢轴小的记录移至低端while (low <high &&&&L L .key[.key[low low ]<=pivotkey) ++low ; L .key[.key[high high ]=]=L L .key[.key[low low ];];////将比枢轴大的记录移至高端L .key[.key[low low ]=]=L L .key[0];.key[0];////枢轴记录到位 return low ;//返回枢轴位置}template <class type >void QSort(SqList <type >& >& L L ,int low ,int high ){int mid;//接收枢轴位置if (low <high ){mid=Partition(mid=Partition(L L ,low ,high );QSort(QSort(L L ,low ,mid-1);,mid-1);////对低子表进行排序 QSort(QSort(L L ,mid+1,,mid+1,high high ););////对高子表进行排序}}template <class type >void QuitSort(SqList <type >& >& L L )//对顺序表进行快速排序 {QSort(QSort(LL ,1,,1,L L .length);}Sort.cppvoid main(){SqList <int > sl;LONGLONG start1,finish1,start2,finish2,start3,finish3; CreateSqList(sl);start1=GetTickCount();BInsertSort(sl);finish1=GetTickCount();delete sl.key;cout <<"插入排序平均物理执行时间为"<<finish1-start1<<<<finish1-start1<<"ms""ms"<<endl;CreateSqList(sl);start3=GetTickCount();QuitSort(sl);finish3=GetTickCount();delete sl.key;cout <<"快速排序平均物理执行时间为"ms"<<endl;<<finish3-start3<<"ms""<<finish3-start3<<CreateSqList(sl);start2=GetTickCount();MergeSort(sl);finish2=GetTickCount();delete sl.key;cout <<"归并排序平均物理执行时间为"ms"<<endl;"<<finish2-start2<<<<finish2-start2<<"ms"}2、richengbiao.cppint main(void){int k;cout << "输入k值，且运动员数为2^k：" << endl;cin >> k;int n = 1;int i = 1; i <= k; i++)(intfor (n *= 2;int players = n;int a[100][100];int i = 1; i <= n; i++)for ((int{a[1][i] = i;}int m = 1;int s = 1; s <= k; s++)for ((int{n /= 2;for (int t = 1; t <= n; t++)(intint i = m+1; i <= 2*m; i++)for ((intint j = m+1; j <= 2*m; j++)for ((int{a[i][j+(t-1)*m*2] = a[i-m][j+(t-1)*m*2-m];a[i][j+(t-1)*m*2-m] = a[i-m][j+(t-1)*m*2];}m *= 2;}int i = 1; i <= players; i++)(intfor ({int j = 1; j <= players; j++)for ((intcout << a[i][j] << " ";cout << endl;}return 0;}三、测试结果：1、题目一先把每个算法的排序时间得到：再做成表格：算法 1000 10000 50000 100000 算法插入排序 16ms 78ms 1797ms 7484ms 插入排序归并排序 0ms 0ms 20ms 56ms 归并排序快速排序 0ms 0ms 16ms 32ms 快速排序2、题目二四、心得与体会：。
算法设计的实验报告
算法设计的实验报告1. 引言算法设计是计算机科学与技术领域的核心内容之一。
通过设计有效的算法，可以解决各种实际问题，提高计算机程序的性能，并优化资源利用。
本实验旨在通过实际案例，展示算法设计的过程及其在实际应用中的重要性。
2. 实验背景在本实验中，我们以图搜索算法为例，着重介绍了深度优先搜索（DFS）和广度优先搜索（BFS）两种经典的图搜索算法。
图搜索算法是图论中的重要概念，应用广泛，例如路径规划、迷宫问题、图像分割等领域。
通过比较两种算法的性能和应用场景，我们可以更好地理解算法设计的意义。
3. 实验目的1. 了解深度优先搜索和广度优先搜索两种常见的图搜索算法；2. 分析两种算法的优缺点和适用场景；3. 通过实际案例，比较两种算法在不同情况下的性能。
4. 实验方法本实验采用Python语言实现DFS和BFS算法，并通过相同的测试用例对两种算法进行评估。
4.1 深度优先搜索算法（DFS）深度优先搜索算法是一种遍历图的方法，其基本思想是从起始节点出发，不断向下搜索，直到找到目标节点或无法继续下去为止。
具体实现过程如下：1. 将起始节点入栈；2. 判断栈是否为空，若为空则搜索结束；3. 弹出栈顶节点，判断是否为目标节点，若是，则搜索成功，返回结果；4. 若不是目标节点，则将该节点的未访问过的相邻节点入栈；5. 重复步骤2至步骤4，直到找到目标节点或栈为空。
4.2 广度优先搜索算法（BFS）广度优先搜索算法是一种逐层遍历图的方法，其基本思想是从起始节点开始，先访问其所有相邻节点，再逐层向外扩展。
具体实现过程如下：1. 将起始节点入队；2. 判断队列是否为空，若为空则搜索结束；3. 出队一个节点，判断是否为目标节点，若是，则搜索成功，返回结果；4. 若不是目标节点，则将该节点的未访问过的相邻节点入队；5. 重复步骤2至步骤4，直到找到目标节点或队列为空。
5. 实验结果与分析我们通过使用DFS和BFS算法解决迷宫问题进行测试，并比较了两种算法的性能。
算法基础实验报告
一、实验目的本次实验旨在帮助学生掌握算法的基本概念、设计方法和分析方法，通过实际操作加深对算法原理的理解，提高编程能力和问题解决能力。
二、实验内容1. 实验一：排序算法（1）实验目的：掌握常见的排序算法，如冒泡排序、选择排序、插入排序、快速排序等，并分析其时间复杂度和空间复杂度。
（2）实验内容：① 冒泡排序：通过相邻元素的比较和交换，将待排序序列变为有序序列。
② 选择排序：每次从待排序序列中选出最小（或最大）的元素，将其放到序列的起始位置。
③ 插入排序：将无序序列的元素逐个插入到已排序序列的合适位置。
④ 快速排序：通过一趟排序将待排序序列分为独立的两部分，其中一部分的所有元素均比另一部分的所有元素小。
（3）实验步骤：① 编写每个排序算法的代码；② 编写测试代码，验证排序算法的正确性；③ 分析每个排序算法的时间复杂度和空间复杂度。
2. 实验二：查找算法（1）实验目的：掌握常见的查找算法，如顺序查找、二分查找等，并分析其时间复杂度和空间复杂度。
（2）实验内容：① 顺序查找：从序列的起始位置逐个比较，找到待查找元素。
② 二分查找：对于有序序列，每次将待查找元素与序列中间的元素比较，缩小查找范围。
（3）实验步骤：① 编写每个查找算法的代码；② 编写测试代码，验证查找算法的正确性；③ 分析每个查找算法的时间复杂度和空间复杂度。
3. 实验三：图算法（1）实验目的：掌握常见的图算法，如深度优先搜索（DFS）、广度优先搜索（BFS）等，并分析其时间复杂度和空间复杂度。
（2）实验内容：① 深度优先搜索：从给定顶点开始，探索所有相邻顶点，直至所有可达顶点都被访问。
② 广度优先搜索：从给定顶点开始，按照顶点之间的距离顺序访问相邻顶点。
（3）实验步骤：① 编写每个图算法的代码；② 编写测试代码，验证图算法的正确性；③ 分析每个图算法的时间复杂度和空间复杂度。
三、实验结果与分析1. 实验一：排序算法（1）冒泡排序、选择排序、插入排序的时间复杂度均为O(n^2)，空间复杂度均为O(1)。
算法分析与设计实验一
算法分析与设计实验一实验内容分别针对随机生成的三组整数序列(规模为1000个数、10000个数、100000个数)进行排序，排序算法使用以下五种经典的方法，分别是：冒泡排序算法，选择排序算法，插入排序算法，归并排序算法和快速排序算法。
实验目的回顾并熟悉常用的排序算法。
通过实验体会算法设计对问题求解效率所产生的深刻影响。
算法设计的基本思路选择排序在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
直接插入排序在要排序的一组数中，假设前面(n-1)[n=2]个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
如此反复循环，直到全部排好顺序。
冒泡排序在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。
即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
归并排序算法合并排序(MERGE SORT)是又一类不同的排序方法，合并的含义就是将两个或两个以上的有序数据序列合并成一个新的有序数据序列，因此它又叫归并算法。
它的基本思想就是假设数组A有N个元素，那么可以看成数组A是又N个有序的子序列组成，每个子序列的长度为1，然后再两两合并，得到了一个N/2个长度为2或1的有序子序列，再两两合并，如此重复，直到得到一个长度为N的有序数据序列为止，这种排序方法称为2-路合并排序。
快速排序快速排序是对冒泡排序的一种本质改进。
它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。
在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。
快速排序通过一趟扫描，就能确保某个数(以它为基准点吧)的左边各数都比它小，右边各数都比它大。
然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。
算法实验
《算法设计与分析》实验一 用贪心方法解背包问题一: 实验目的掌握按贪心方法原理求背包问题最优解的方法二:问题描述背包问题描述如下: 已知背包容量M=120物品种类数n=10各种物品的总效益pi(i=1,2,………10) : 50,60,70,80,90,80,70,60,50,40 各种物品的总重量wi(i=1,2………10) : 17,30,25,41,80,70,64,56,47,38 求: 各种物品所取重量占其总重量的比例xi(i=1,2,…..10),满足0<=xi<=1, 且 且使得 达到最大值.三. 基本要求(1) 按三种不同的量度标准分别计算所得最大总效益,然后比较哪个最大1.按效益值由大到小取物品.2. 按重量值由小到大取物品3.按比值pi/wi 的值由大到小取物品 物品序号i 1 2 3 4 5 6 7 8 9 10 总效益(1) x1 0 0 0 0.976 1 0 0 0 0 0 168.05(2) x2 1 1 1 0.244 0 0 0 0 0 1 239.51(3) x3 1 1 1 1 0 0.1 0 0 0 0 268.00 结论:按(3) 的量度标准计算所得所取全部物品总效益之和最大四．重点和难点∑=<=n i MWixi1∑=n i pixi1（1）用贪心方法原理理解实际问题（2）函数之间的调用（3）排序算法实验二求图的任两结点间的距离一: 实验目的掌握按动态规划原理解决计算图的任两结点间的距离的Floyd算法二:问题描述设图G 的结点个数n=10,给定一个10*10矩阵作为图G 的成本矩阵.其中的元素99相当于无穷，表示相应的两个结点间没有边相连0 99 8 7 6 5 4 3 2 199 0 99 8 7 6 5 4 3 28 99 0 99 8 7 6 5 4 37 8 99 0 99 8 7 6 5 4C＝ 6 7 8 99 0 99 8 7 6 55 6 7 8 99 0 99 8 7 64 5 6 7 8 99 0 99 8 73 4 5 6 7 8 99 0 99 82 3 4 5 6 7 8 99 0 991 2 3 4 5 6 7 8 99 0三. 基本要求（1）用二维数组存放C ，C是原成本矩阵（2）算法采用三重循环（3）本题运行结果0 3 4 5 6 5 4 3 2 13 0 5 6 7 6 54 3 24 5 0 7 8 7 6 5 4 35 6 7 0 9 8 7 6 5 46 7 8 9 0 11 8 7 6 55 6 7 8 11 0 9 8 7 64 5 6 7 8 9 0 7 6 53 4 5 6 7 8 7 0 5 42 3 4 5 6 7 6 5 0 31 2 3 4 5 6 5 4 3 0四．重点和难点（1）掌握按动态规划原理（2）计算图的任两结点间的距离的Floyd算法实验三流水线调度问题一: 实验目的掌握按动态规划原理求解一类特定条件下的流水线调度问题具体做法.二:问题描述已知作业个数n=10各个作业第一道工序所须时间ai(I=1,2……,n)各个作业第二道工序所须时间bi(I=1,2……,n)作业序号: 1 2 3 4 5 6 7 8 9 10 a; 25 30 35 40 45 50 55 60 65 70 b; 21 31 41 51 61 39 49 59 69 79规定: (1)任一个作业必须先做完第一道工序才能做第二道工序(2) 任一个作业的任一道工序必须连续做完,才能中断而让别的作业做完.求: 一种最优调度方案,即使总的完成时间最短的调度方案,用长度为n的一维数组s表示，使s[i]为按先后次序排在第i位进行处理的作业的序号．三：要求：（１）用一个４＊２０的二维数组Ｍ，第１行存放按从小到大排序的20个所给出的ai和bi，第２行存放相应的作业序号，第３行存放１或２(１代表是来自ai，２代表是来自bi), 第4行存放0或１（０代表作业序号未进入最优调度方案；１代表作业序号已进入最优调度方案）（２）排序完后，按课本所述方法求一种最优调度方案，存放在S中。
算法设计_实验报告
通过本次实验，加深对算法设计方法的理解，掌握常用算法的原理和实现方法，提高编程能力。
二、实验内容1. 矩阵链乘问题2. 投资问题3. 完全背包问题4. 数字三角形问题5. 最小生成树问题三、实验原理1. 矩阵链乘问题矩阵链乘问题是指给定一系列矩阵，求这些矩阵连乘的乘积的最小计算代价。
动态规划方法可以有效地解决这个问题。
2. 投资问题投资问题是指给定一组投资方案和初始资金，求在有限的时间内，如何选择投资方案使得最终收益最大。
动态规划方法可以解决这个问题。
3. 完全背包问题完全背包问题是指给定一组物品和背包的容量，求在不超过背包容量的前提下，如何选择物品使得背包中物品的总价值最大。
动态规划方法可以解决这个问题。
4. 数字三角形问题数字三角形问题是指给定一个数字三角形，从顶部到底部求出一条路径，使得路径上的数字之和最大。
动态规划方法可以解决这个问题。
5. 最小生成树问题最小生成树问题是指给定一个加权无向图，求一个包含图中所有顶点的最小生成树。
Prim算法和Kruskal算法是解决此问题的常用算法。
1. 矩阵链乘问题（1）定义一个二维数组dp，dp[i][j]表示从矩阵A[i]到矩阵A[j]的最小计算代价。
（2）初始化dp[i][i]为0，表示单个矩阵的计算代价为0。
（3）对于长度为2的矩阵链，dp[i][i+1]等于矩阵A[i]和A[i+1]的乘积。
（4）对于长度大于2的矩阵链，通过遍历所有可能的分割点，计算dp[i][j]的最小值。
2. 投资问题（1）定义一个二维数组dp，dp[i][j]表示在前i个投资方案中，使用j元资金所能获得的最大收益。
（2）初始化dp[0][0]为0，表示不投资时收益为0。
（3）对于第i个投资方案，遍历所有可能的资金使用情况，更新dp[i][j]的值。
3. 完全背包问题（1）定义一个二维数组dp，dp[i][j]表示在前i个物品中，使用容量为j的背包所能获得的最大价值。
（2）初始化dp[0][0]为0，表示不放入任何物品时价值为0。
算法实验报告
算法实验报告算法实验报告引言：算法是计算机科学的核心内容之一，它是解决问题的方法和步骤的描述。
算法的设计和分析是计算机科学与工程中的重要研究方向之一。
本实验旨在通过对算法的实际应用和实验验证，深入理解算法的性能和效果。
实验一：排序算法的比较在本实验中，我们将比较三种常见的排序算法：冒泡排序、插入排序和快速排序。
我们将通过对不同规模的随机数组进行排序，并记录每种算法所需的时间和比较次数，以评估它们的性能。
实验结果显示，快速排序是最快的排序算法，其时间复杂度为O(nlogn)，比较次数也相对较少。
插入排序的时间复杂度为O(n^2)，比较次数较多，但对于小规模的数组排序效果较好。
而冒泡排序的时间复杂度也为O(n^2)，但比较次数更多，效率相对较低。
实验二：图的最短路径算法在图的最短路径问题中，我们将比较Dijkstra算法和Floyd-Warshall算法的效率和准确性。
我们将使用一个带权有向图，并计算从一个顶点到其他所有顶点的最短路径。
实验结果表明，Dijkstra算法适用于单源最短路径问题，其时间复杂度为O(V^2)，其中V为顶点数。
而Floyd-Warshall算法适用于多源最短路径问题，其时间复杂度为O(V^3)。
两种算法在准确性上没有明显差异，但在处理大规模图时，Floyd-Warshall算法的效率较低。
实验三：动态规划算法动态规划是一种通过将问题分解成子问题并记录子问题的解来解决复杂问题的方法。
在本实验中，我们将比较两种动态规划算法：0-1背包问题和最长公共子序列问题。
实验结果显示，0-1背包问题的动态规划算法可以有效地找到最优解，其时间复杂度为O(nW)，其中n为物品个数，W为背包容量。
最长公共子序列问题的动态规划算法可以找到两个序列的最长公共子序列，其时间复杂度为O(mn)，其中m和n分别为两个序列的长度。
结论：通过本次实验，我们对不同算法的性能和效果有了更深入的了解。
排序算法中，快速排序是最快且效率最高的；在图的最短路径问题中，Dijkstra算法和Floyd-Warshall算法分别适用于不同的场景；动态规划算法可以解决复杂的问题，并找到最优解。
计算机基础算法实验报告
计算机基础算法实验报告班级：学号：姓名：指导教师：完成日期：实验一实现两个整数相加1.实验任务实现两个长整数相加：要求用链表（单链表或双向链表）实现任意位数的整数相加。
2.设计思想用单链表实现两个任意位整型相加，建立三个动态链表，两个分别用来存入两个加数，第三个链表用来存入和。
考虑到进位以及算术加法习惯，采用逆序插入节点，先存高位再存低位数，头指针指向最后插入的节点。
进行相加后存入第三个链表，最后将结果输出。
3．主要变量说明data 链表结点的数据域*next 链表结点的指针node单链表类型*list 单链表类型指针head 指向链表的头指针l3 指向第三个链表的头指针j 进位标志4.算法描述首先定义单链表的结构体类型，然后输入两个数，调用创建链表函数创建两个单链表将输入的数分别依次逆序存入，高位存入第一个结点，低位存入之后的结点，最后的结点存个位，并不断循环始终使头指针指向新插入的结点。
然后调用相加函数，并动态创建第三个链表将结果仍逆序存入第三个链表中。
最后调用输出函数将结果输出。
5.程序结构List creat()操作结果：构造一个动态链表list add(list l1,list l2)初始条件：链表l1,l2已存在操作结果：将两个链表的数据依次对应相加，并将结果倒叙存入链表l3void out(list l)初始条件：链表已存在操作结果：依次输出链表中的数据主函数：void main(){list l1,l2,l3;printf("请输入第一个整数，末尾输入-1表结束: ");l1=creat();out(l1);printf("请输入第二个整数，末尾输入-1表结束: ");l2=creat();out(l2);printf（”相加结果为: ”）;l3=add(l1,l2);out(l3);}6.运行结果请输入第一个整数，末尾输入-1表结束：1 2 3 4 -14321请输入第二个整数，末尾输入-1表结束：7 8 9 -1987相加结果为：20237.心得体会通过本次编写程序，我对单链表有了更深的理解，由于没有使用双向链表，就采取了逆向插入结点，这使我对逆向插入有更深的理解。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一简单算法设计
一.实验目的和要求
1. 理解算法设计与分析的基本概念，理解解决问题的算法设计与实现过程；
2. 掌握简单问题的算法设计与分析，能设计比较高效的算法；
3. 熟悉C/C++语言等的集成开发环境，掌握简单程序设计与实现的能力；
二．实验内容
(一)相等元素问题
1.问题描述先排序函数，再查找函数。
#define size 100
Typedef strat
{
Int Array[size]
Int listlength
}List
List a;
Main()
{
1、输入
2、排序
3、查找
4、输出
}
元素唯一性问题：给出一个整数集合，假定这些整数存储在数组A[1…n]中，确定它们中是否存在两个相等的元素。
请设计出一个有效算法来解决这个问题，你的算法的时间复杂性是多少？
2. 测试数据
输入：
9 71 25 64 38 52 5 31 19 45
26 35 17 92 53 24 6 57 21 12 34 2 17 86 75 33
15 87 32 7 84 35 26 45 78 96 52 22 37 65 9 43 21 3 33 91
输出：No
Yes
No
3. 设计与实现的提示
算法最坏情况和平均情况的时间复杂性是衡量算法优劣的重要指标，算法设计要求尽可能设计比较高效的算法。
(二) 整数集合分解（选做）
1.问题描述
设计算法把一个n个元素的整数集合（n为偶数）分成两个子集S1和S2，使得：每个新的集合中含有n/2个元素，且S1中的所有元素的和与S2中的所有元素的和的差最大。
2. 测试数据
输入：
68 25 34 16 2 37 3 95 76 57 21 13 4 78 29 6 17 39 51 20 43 12
28 3 48 59 14 32 47 51 42 61 9 24 52 78 65 2 37 78 51 73 29 7 26 95 37 2
输出：
2 3 4 6 12 13 16 17 20 21 25
29 34 37 39 43 51 57 68 76 78 95
2 2
3 7 9 1
4 24 26 28 29 32 37 37
42 47 48 51 51 52 59 61 62 65 73 78 95
3. 设计与实现的提示
本题可以有多种方法。
算法时间复杂性是选取算法的重要依据。
输出的两个新整数集合要求按照从小到大排序后输出。
该排序步骤对算法时间复杂性的影响在此不计。