算法实验报告--实验2-2众数问题

合集下载

求众数问题实验报告

求众数问题实验报告

一、实验目的1. 理解众数的概念及求众数算法。

2. 掌握不同求众数算法的原理及实现方法。

3. 分析比较不同算法的优缺点,提高算法选择能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 软件环境:PyCharm三、实验内容1. 理解众数的概念:众数是指一组数据中出现次数最多的数值。

在统计学中,众数是一种重要的描述数据集中趋势的指标。

2. 求众数算法:(1)直接遍历法:通过遍历整个数据集,记录每个数值出现的次数,找出出现次数最多的数值。

(2)哈希表法:利用哈希表存储每个数值及其出现次数,遍历数据集更新哈希表,最后找出出现次数最多的数值。

(3)排序法:先将数据集进行排序,然后遍历排序后的数据集,记录当前数值及其连续出现次数,找出出现次数最多的数值。

四、实验步骤1. 创建一个包含多个数值的数据集。

2. 实现直接遍历法求众数。

3. 实现哈希表法求众数。

4. 实现排序法求众数。

5. 分析比较三种算法的优缺点。

五、实验结果与分析1. 直接遍历法求众数代码实现如下:```pythondef majority_element(nums):max_count = 0candidate = Nonefor num in nums:count = nums.count(num)if count > max_count:max_count = countcandidate = numreturn candidate# 测试数据集nums = [1, 2, 3, 2, 2, 2, 5, 4, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3] print("直接遍历法求众数:", majority_element(nums))```实验结果:直接遍历法求众数为2。

2. 哈希表法求众数代码实现如下:```pythondef majority_element_hash(nums):counts = {}for num in nums:if num in counts:counts[num] += 1else:counts[num] = 1max_count = 0candidate = Nonefor num, count in counts.items():if count > max_count:max_count = countcandidate = numreturn candidate# 测试数据集nums = [1, 2, 3, 2, 2, 2, 5, 4, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3] print("哈希表法求众数:", majority_element_hash(nums))```实验结果:哈希表法求众数为2。

众数问题实验报告

众数问题实验报告

算法分析2-1 众数问题一、实验截图1.项目图例2.输入文件3.实验输出文件二、实验代码1.#include <bits/stdc++.h>ing namespace std;3.4.int Random(int l, int r);5.void Swap(int &a, int &j);6.int Partition(int *a, int l, int r);7.int RandomizedPartition(int *a, int l, int r);8.//快速排序9.void RandomizedQuickSort(int *a, int l, int r);10.11.int main()12.{13. string inputFile = "input.txt",14. outputFile = "output.txt";15. ifstream fin(inputFile, ios::in);16. ofstream fout(outputFile, ios::out);17.int n;18. fin >> n;19.int *a = new int[n];20.for (int i = 0; i < n; ++i)21. fin >> a[i];22. RandomizedQuickSort(a, 0, n - 1);23.int count = 1,24. maxCount = 1;25.int value = a[0],26. maxValue = a[0];27.for (int i = 1; i < n; ++i)28. {29.if (a[i] == value)30. {31. ++count;32.if (count > maxCount)33. {34. maxValue = value;35. maxCount = count;36. }37. }38.else39. {40. value = a[i];41. count = 1;42. }43. }44. fout << maxValue << endl << maxCount;45.//system("pause");46.}47.int Random(int l, int r)48.{49.int i = rand() % (r - l + 1);50.return i + l;51.}52.void Swap(int &a, int &b)53.{54.int temp = a;55. a = b;56. b = temp;57.}58.int Partition(int *a, int l, int r)59.{60.int i = l,61. j = r + 1;62.int temp = a[l];63.while (true)64. {65.while (a[++i] < temp && i <= r);66.while (a[--j] > temp);67.if (i > j) break;68. Swap(a[i], a[j]);69. }70. a[l] = a[j];71. a[j] = temp;72.return j;73.}74.int RandomizedPartition(int *a, int l, int r)75.{76.int i = Random(l, r);77. Swap(a[l], a[i]);78.return Partition(a, l, r);79.}80.void RandomizedQuickSort(int *a, int l, int r)81.{82.if (l < r)83. {84.int i = RandomizedPartition(a, l, r);85. RandomizedQuickSort(a, l, i - 1);86. RandomizedQuickSort(a, i + 1, r);87. }88.}。

算法分析实验二报告

算法分析实验二报告

《算法设计与分析》实验报告目录一、实验内容描述和功能分析.二、算法过程设计.三、程序调试及结果(附截图).四、源代码(附源代码).一、实验内容描述和功能分析.1.整数因子分解问题内容描述:大于1 的正整数n可以分解为:n=x1*x2*…*xm。

例如,当n=12 时,共有8 种不同的分解式:12=12;12=6*2;12=4*3;12=3*4;12=3*2*2;12=2*6;12=2*3*2;12=2*2*3。

对于给定的正整数n,编程计算n共有多少种不同的分解式。

功能分析:输入一行对应1 个正整数n (1≤n≤2000000000),输出对应的n的不同分解式。

例如:输入:12,输出:82.邮局选址问题内容描述:在一个按照东西和南北方向划分成规整街区的城市里,n个居民点散乱地分布在不同的街区中。

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

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

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

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

编程任务:给定n 个居民点的位置,编程计算n 个居民点到邮局的距离总和的最小值。

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

每组测试数据输入的第1 行是居民点数n,1≤n≤10000。

接下来n 行是居民点的位置,每行2 个整数x 和y,-10000≤x,y≤10000。

对应每组输入,输出的第1 行中的数是n 个居民点到邮局的距离总和的最小值。

例如:输入:5 输出:101 22 21 33 -23 3二、算法过程设计.1.整数因子分解问题通过函数的定义和相关变量的定义,根据数学上整数因子的分解算法,来对程序进行设计。

2.邮局选址问题通过题目给定的意思,可以知道其数学算法,通过调用库函数来实现程序的设计和结果的实现。

三、程序调试及结果(附截图).1.整数因子分解问题2.邮局选址问题四、源代码(附源代码).1.整数因子分解问题#include<stdio.h>#include<math.h>struct DP{ int num;int sum;} d[50000]={0};int max=0;void qsort(int low,int high,struct DP key[]){ int i=low,j=high;struct DP tag=key[i];if(i<j){ do{ while(tag.num<key[j].num && i<j) j--;if(i<j){ key[i]=key[j];i++;while(tag.num>=key[i].num && i<j) i++;if(i<j){ key[j]=key[i];j--;}}}while(i<j);key[i]=tag;qsort(low,j-1,key);qsort(i+1,high,key);}}int dfs(int left){ int i,p;int l,r,m;int count=0;l=0; r=max;while(l<=r){ m=(l+r)>>1;if(d[m].num<left) l=m+1; else r=m-1;}p=l; if(d[p].sum) return d[p].sum;for(i=1;i<=d[i].num;i++){ if(left%d[i].num==0) count+=dfs(left/d[i].num); }d[p].sum=count;return count;}int main(void){ int i,j,tmp;int n;scanf("%d",&n); tmp=sqrt(n);for(i=1;i<=tmp;i++){ if(n%i==0){ d[max].num=i; max++;d[max].num=n/i; max++;}} max--;qsort(0,max,d);d[0].sum=1;printf("%d\n",dfs(n));return 0;}2.邮局选址问题#include<stdio.h>#include<stdlib.h>#include<math.h>int cmp( const void *a , const void *b ) { return *(int *)a - *(int *)b; } int main(){ int i,a[10005],b[10005],n,y,x;int sum;while(scanf("%d",&n)==1){ for(i=0;i<n;i++)scanf("%d%d",&a[i],&b[i]);qsort(b,n,sizeof(b[0]),cmp);qsort(a,n,sizeof(a[0]),cmp);y=b[(n-1)/2];x=a[(n-1)/2];sum=0;for(i=0;i<n;i++){ sum=sum+fabs(b[i]-y);sum=sum+fabs(a[i]-x);}printf("%d\n",sum);}return 0;}。

众数问题

众数问题

众数问题一、实验目的1.掌握分治算法的基本思想(分-治-合)、技巧和效率分析方法。

2.熟练掌握用递归设计分治算法的基本步骤(基准与递归方程)。

3.学会利用分治算法解决实际问题。

二、问题描述给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重数集S中的重数最大的元素称为众数。

例如,S={1,2,2,2,3,5}。

多重集S得众数是2,其重数为3。

对于给定的由n个自然数组成多重数集S,计算S的众数及其重数。

三.算法设计数据结构与核心算法的设计描述:void split(int s[], int n, int &l, int &r) //以中间的数字为界限,确定左右起始和终止界限{int mid = n/2;for(l=0; l<n; ++l){if (s[l] == s[mid])break;}for(r=l+1; r<n; ++r){if (s[r] != s[mid])break;}}// num 众数,maxCnt 重数void getMaxCnt(int &mid, int &maxCnt, int s[], int n){int l, r;split(s, n, l, r); // 进行切割int num = n/2;int cnt = r-l;// updateif (cnt > maxCnt){maxCnt = cnt;mid = s[num];}// l 表示左边的个数,左边的个数必须大于maxCnt 才有必要搜寻if (l+1 > maxCnt){getMaxCnt(mid, maxCnt, s, l+1);}// 右边搜寻, 右边数组的起始地址要变更if (n-r > maxCnt){getMaxCnt(mid, maxCnt, s+r, n-r);}}算法设计:以中间为界限,先计算围绕中间这个数字的众数情况,然后左右分开递归计算结果,取最值即可。

实验教案:用数据实际计算众数与中位数

实验教案:用数据实际计算众数与中位数

实验教案:用数据实际计算众数与中位数教学目标:1. 理解众数和中位数的定义;2. 学会如何从一组数据中计算出众数和中位数;3. 掌握众数和中位数在数据分析中的应用。

教学准备:1. 准备一组数据,包括数值和类别数据;2. 准备计算工具,如纸笔或计算器;3. 准备展示平台,如黑板或白板。

教学步骤:第一章:众数的概念和计算方法1.1 引入众数的概念,通过具体例子解释众数的含义;1.2 引导学生观察一组数据,找出出现次数最多的数值;1.3 演示如何从一组数据中计算出众数,并解释计算方法;1.4 让学生尝试计算给定一组数据的众数,并进行解答。

第二章:中位数的概念和计算方法2.1 引入中位数的概念,通过具体例子解释中位数的含义;2.2 引导学生将一组数据按照大小顺序排列;2.3 演示如何从一组数据中计算出中位数,并解释计算方法;2.4 让学生尝试计算给定一组数据的中位数,并进行解答。

第三章:众数和中位数的应用3.1 引导学生理解众数和中位数在数据分析中的作用;3.2 给出具体例子,让学生应用众数和中位数分析数据,得出结论;3.3 让学生分组讨论,提出自己的例子,并应用众数和中位数进行分析;3.4 邀请学生分享自己的分析和结论。

第四章:众数和中位数的比较4.1 引导学生思考众数和中位数之间的关系;4.2 给出具体例子,让学生比较众数和中位数的差异;4.3 让学生尝试解释众数和中位数在不同的数据集中的作用;4.4 邀请学生分享自己的观点和理解。

第五章:综合练习5.1 给出一组数据,要求学生计算出众数和中位数;5.2 让学生解释众数和中位数在这组数据中的意义;5.3 邀请学生分享自己的解答和观点;5.4 总结本节课的学习内容,强调众数和中位数在数据分析中的重要性。

教学评价:1. 观察学生在计算众数和中位数时的准确性;2. 评估学生在应用众数和中位数分析数据时的理解程度;3. 收集学生的练习解答和观点分享,评估学生的参与程度。

众数问题算法实验报告

众数问题算法实验报告

一、实验背景众数(Mode)是一组数据中出现次数最多的数值,它是描述数据集中趋势的一个重要指标。

在统计学、数据分析等领域,众数问题具有广泛的应用。

本实验旨在通过编程实现求解众数问题的算法,并对不同算法的效率进行比较。

二、实验目的1. 掌握求解众数问题的基本算法;2. 比较不同算法的效率;3. 提高编程能力。

三、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm四、实验内容1. 算法设计(1)排序法首先对数据进行排序,然后遍历排序后的数组,找出出现次数最多的数值。

(2)哈希表法使用哈希表(字典)记录每个数值的出现次数,然后遍历字典找出出现次数最多的数值。

(3)Boyer-Moore Voting Algorithm(投票算法)对于非空数组,假设有一个众数,那么它出现的次数至少与数组长度的一半相等。

遍历数组,维护一个候选众数和一个计数器,如果计数器为0,则将当前元素设为候选众数,并将计数器设为1;如果当前元素与候选众数相等,则计数器加1;如果当前元素与候选众数不相等,则计数器减1。

遍历结束后,候选众数即为众数。

2. 实验数据(1)随机生成一组数据,包含1000个整数,范围在1到10000之间;(2)随机生成一组数据,包含1000个浮点数,范围在1.0到100.0之间。

3. 实验步骤(1)编写排序法、哈希表法和投票算法的Python代码;(2)对随机生成的一组整数和浮点数数据分别使用三种算法进行求解;(3)比较三种算法的执行时间。

五、实验结果与分析1. 实验数据(1)整数数据:[5, 2, 3, 8, 9, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 10000, 9999, 9998, 9997, 9996, 9995, 9994, 9993, 9992, 9991, 9990, 9989, 9988, 9987, 9986, 9985, 9984, 9983, 9982, 9981, 9980, 9979, 9978, 9977, 9976, 9975, 9974, 9973, 9972, 9971, 9970, 9969, 9968, 9967, 9966, 9965, 9964, 9963, 9962, 9961, 9960, 9959, 9958, 9957, 9956, 9955, 9954, 9953, 9952, 9951, 9950, 9949, 9948, 9947, 9946, 9945, 9944, 9943, 9942, 9941, 9940, 9939, 9938, 9937, 9936, 9935, 9934, 9933, 9932, 9931, 9930, 9929, 9928, 9927, 9926, 9925, 9924, 9923, 9922, 9921, 9920, 9919, 9918, 9917, 9916, 9915, 9914, 9913, 9912, 9911, 9910, 9909, 9908, 9907, 9906, 9905, 9904, 9903, 9902, 9901, 9900, 9899, 9898, 9897, 9896, 9895, 9894, 9893, 9892, 9891, 9890, 9889, 9888, 9887, 9886, 9885, 9884, 9883, 9882, 9881, 9880, 9879, 9878, 9877, 9876, 9875, 9874, 9873, 9872, 9871, 9870, 9869, 9868, 9867, 9866, 9865, 9864, 9863, 9862, 9861, 9860, 9859, 9858, 9857, 9856, 9855, 9854, 9853, 9852, 9851, 9850, 9849, 9848, 9847, 9846, 9845, 9844, 9843, 9842, 9841, 9840, 9839, 9838, 9837, 9836, 9835, 9834, 9833, 9832, 9831, 9830, 9829, 9828, 9827, 9826, 9825, 9824, 9823, 9822, 9821, 9820, 9819, 9818, 9817, 9816, 9815, 9814, 9813, 9812, 9811, 9810, 9809, 9808, 9807, 9806, 9805,9804, 9803, 9802, 9801, 9800, 9799, 9798, 9797, 9796, 9795, 9794, 9793, 9792, 9791, 9790, 9789, 9788, 9787, 9786, 9785, 9784, 9783, 9782, 9781, 9780, 9779, 9778, 9777, 9776, 9775, 9774, 9773, 9772, 9771, 9770, 9769, 9768, 9767, 9766, 9765, 9764, 9763, 9762, 9761, 9760, 9759, 9758, 9757, 9756, 9755, 9754, 9753, 9752, 9751, 9750, 9749, 9748, 9747, 9746, 9745, 9744, 9743, 9742, 9741, 9740, 9739, 9738, 9737, 9736, 9735, 9734, 9733, 9732, 9731, 9730, 9729, 9728, 9727, 9726, 9725, 9724, 9723, 9722, 9721, 9720, 9719, 9718, 9717, 9716, 9715, 9714, 9713, 9712, 9711, 9710, 9709, 9708, 9707, 9706, 9705, 9704, 9703, 9702, 9701, 9700, 9699, 9698, 9697, 9696, 9695, 9694, 9693, 9692, 9691, 9690, 9689, 9688, 9687, 9686, 9685, 9684, 9683, 9682, 9681, 9680, 9679, 9678, 9677, 9676, 9675, 9674, 9673, 9672, 9671, 9670, 9669, 9668, 9667, 9666, 9665, 9664, 9663, 9662, 9661, 9660, 9659, 9658, 9657, 9656, 9655, 9654, 9653, 9652, 9651, 9650, 9649, 9648, 9647, 9646, 9645, 9644, 9643, 9642, 9641, 9640, 9639, 9638, 9637, 9636, 9635, 9634, 9633, 9632, 9631, 9630, 9629, 9628, 9627, 9626, 9625, 9624, 9623, 9622, 9621, 9620, 9619, 9618, 9617, 9616, 9615, 9614, 9613, 9612, 9611, 9610, 9609, 9608, 9607, 9606, 9605, 9604, 9603, 9602, 9601, 9600, 9599, 9598, 9597, 9596, 9595, 9594, 9593, 9592, 9591, 9590, 9589, 9588, 9587, 9586, 9585, 9584, 9583, 9582, 9581, 9580, 9579, 9578, 9577, 9576, 9575, 9574, 9573, 9572, 9571, 9570, 9569, 9568, 9567, 9566, 9565, 9564, 9563, 9562, 9561, 9560, 9559, 9558, 9557, 9556, 9555, 9554, 9553, 9552, 9551, 9550, 9549, 9548, 9547, 9546, 9545, 9544, 9543, 9542, 9541, 9540, 9539, 9538, 9537, 9536, 9535, 9534, 9533, 9532, 9531, 9530, 9529, 9528, 9527, 9526, 9525, 9524, 9523, 9522, 9521, 9520, 9519, 9518, 9517, 9516, 9515, 9514, 9513, 9512, 9511, 9510, 9509, 9508, 9507, 9506, 9505, 9504, 9503, 9502, 9501, 9500, 9499, 9498, 9497, 9496, 9495, 9494, 9493, 9492, 9491, 9490, 9489, 9488, 9487, 9486, 9485, 9484, 9483, 9482, 9481, 9480, 9479, 9478, 9477, 9476, 9475, 9474, 9473, 9472, 9471, 9470, 9469, 9468, 9467, 9466, 9465, 9464, 9463, 9462, 9461, 9460, 9459, 9458, 9457, 9456, 9455, 9454, 9453, 9452, 9451, 9450, 9449, 9448, 9447, 9446, 9445, 9444, 9443, 9442, 9441, 9440, 9439, 9438, 9437, 9436, 9435, 9434, 9433, 9432, 9431, 9430, 9429, 9428, 9427, 9426, 9425, 9424, 9423, 9422, 9421, 9420, 9419, 9418, 9417, 9416, 9415, 9414, 9413, 9412, 9411, 9410, 9409, 9408, 9407, 9406, 9405, 9404, 9403, 9402, 9401, 9400, 9399, 9398, 9397, 9396, 9395, 9394, 9393, 9392, 9391, 9390, 9389, 9388, 9387, 9386, 9385, 9384, 9383, 9382, 9381, 9380, 9379, 9378, 9377, 9376, 9375, 9374, 9373,9372, 9371, 9370, 9369, 9368, 9367, 9366, 9365, 9364, 9363, 9362, 9361, 9360, 9359, 9358, 9357, 9356, 9355, 9354, 9353, 9352, 9351, 9350, 9349, 9348, 9347, 9346, 9345, 9344, 9343, 9342, 9341, 9340, 9339, 9338, 9337, 9336, 9335, 9334, 9333, 9332, 9331, 9330, 9329, 9。

关于算法的实验报告(3篇)

关于算法的实验报告(3篇)

第1篇一、实验目的1. 理解快速排序算法的基本原理和实现方法。

2. 掌握快速排序算法的时间复杂度和空间复杂度分析。

3. 通过实验验证快速排序算法的效率。

4. 提高编程能力和算法设计能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验原理快速排序算法是一种分而治之的排序算法,其基本思想是:选取一个基准元素,将待排序序列分为两个子序列,其中一个子序列的所有元素均小于基准元素,另一个子序列的所有元素均大于基准元素,然后递归地对这两个子序列进行快速排序。

快速排序算法的时间复杂度主要取决于基准元素的选取和划分过程。

在平均情况下,快速排序的时间复杂度为O(nlogn),但在最坏情况下,时间复杂度会退化到O(n^2)。

四、实验内容1. 快速排序算法的代码实现2. 快速排序算法的时间复杂度分析3. 快速排序算法的效率验证五、实验步骤1. 设计快速排序算法的C++代码实现,包括以下功能:- 选取基准元素- 划分序列- 递归排序2. 编写主函数,用于生成随机数组和测试快速排序算法。

3. 分析快速排序算法的时间复杂度。

4. 对不同规模的数据集进行测试,验证快速排序算法的效率。

六、实验结果与分析1. 快速排序算法的代码实现```cppinclude <iostream>include <vector>include <cstdlib>include <ctime>using namespace std;// 生成随机数组void generateRandomArray(vector<int>& arr, int n) {srand((unsigned)time(0));for (int i = 0; i < n; ++i) {arr.push_back(rand() % 1000);}}// 快速排序void quickSort(vector<int>& arr, int left, int right) { if (left >= right) {return;}int i = left;int j = right;int pivot = arr[(left + right) / 2]; // 选取中间元素作为基准 while (i <= j) {while (arr[i] < pivot) {i++;}while (arr[j] > pivot) {j--;}if (i <= j) {swap(arr[i], arr[j]);i++;j--;}}quickSort(arr, left, j);quickSort(arr, i, right);}int main() {int n = 10000; // 测试数据规模vector<int> arr;generateRandomArray(arr, n);clock_t start = clock();quickSort(arr, 0, n - 1);clock_t end = clock();cout << "排序用时:" << double(end - start) / CLOCKS_PER_SEC << "秒" << endl;return 0;}```2. 快速排序算法的时间复杂度分析根据实验结果,快速排序算法在平均情况下的时间复杂度为O(nlogn),在最坏情况下的时间复杂度为O(n^2)。

《算法设计与分析》实验报告模板 (1)

《算法设计与分析》实验报告模板 (1)

《算法设计与分析》实验报告
学号:姓名:
实验一分治法求解众数问题
一、实验目的
1.掌握分治法的设计思想并能熟练应用;
2.理解分治与递归的关系。

二、实验题目
在一个序列中出现次数最多的元素称为众数,根据分治法的思想设计算法寻找众数。

三、实验程序
四、程序运行结果
实验二动态规划法求解单源最短路径问题
一、实验目的
1.深刻掌握动态规划法的设计思想;
2.熟练应用以上算法思想求解相关问题。

二、实验题目
设有一个带权有向连通图,可以把顶点集划分成多个互不相交的子集,使得任一条边的两个顶点分属不同子集,称该图为多段图。

采用动态规划法求解多段图从源点到终点的最小代价路径。

三、实验程序
四、程序运行结果
实验三贪心法求解单源点最短路径问题
一、实验目的
1.掌握贪心法的设计思想;
2.分析比较同一个问题采用不同算法设计思想求解的结果。

二、实验题目
设有一个带权有向连通图,可以把顶点集划分成多个互不相交的子集,使得任一条边的两个顶点分属不同子集,称该图为多段图。

采用贪心法求解多段图从源点到终点的最小代价路径。

三、实验程序
四、程序运行结果
实验四回溯法求解0/1背包问题
一、实验目的
1.掌握回溯法的设计思想;
2.掌握解空间树的构造方法,以及在求解过程中如何存储求解路径;
二、实验题目
给定n种物品和一个容量为C的背包,选择若干种物品(物品不可分割),使得装入背包中物品的总价值最大。

采用回溯法求解该问题。

三、实验程序
四、程序运行结果。

查找数组元素的最大值和最小值、众数问题

查找数组元素的最大值和最小值、众数问题

《算法设计与分析》上机实验报告专业班级学号学生姓名完成日期1. 上机题目及实验环境1.1上机题目:1.1.1 用分治法查找数组元素的最大值和最小值1.1.2 众数问题1.2实验环境:CPU:Intel Core i3 2.30GHz内存:2.0G操作系统:Windows 7软件平台:Visual C++2. 算法设计与分析2.1 查找数组最值2.1.1 分治递归方法:●将max和min设置为静态全局变量;●将数据集array平均分为两个数据集;●分别求解两个数据集中的最大和最小值;●最终的最大和最小值通过与max和min的值比较;●采用同样的处理方法递归处理以分好的数据集。

2.1.2 细节处理:●数组的大小为n2,n=0,1,2,3......●数组中的数字随机产生,数字的范围为1~100;●静态全局变量:max的初值为0,min的初值为101。

2.2 众数问题2.2.1 快速排序算法:●设置两个变量i、j,排序开始的时候:i=left,j=right+1;●以第一个数组元素作为关键数据,赋值给temp,即temp=array[left];●从j开始向前搜索,即由后开始向前搜索(--j),找到第一个小于temp的值array[j];●从i开始向后搜索,即由前开始向后搜索(++i),找到第一个大于temp的array[i];●交换array[i]和array[j]的值;●重复搜索步骤,直到i=j;●将temp的值和array[j]的值交换,并以此为界,分别在对左右两边进行快速排序。

3. 核心代码3.1 查找最值3.1.1 流程图(如图1)(核心函数为void MaxAndMin(int array[N], int left, int right)):图1.查找最值的流程图3.1.2 核心代码如下:(注:max和min是静态全局变量)void MaxAndMin(int array[N], int left, int right) // 求最大值最小值函数,分治递归法{int mid; // 数组的分界点if ( (left + 1) == right) // 分治的数组只有两个值时,更新max和min的值{if ( array[left] < array[right] && max < array[right] ) // 判断、更新最大值max = array[right];if ( array[left] > array[right] && max < array[left] )max = array[left];if ( array[left] < array[right] && min > array[left]) // 判断、更新最小值min = array[left];if ( array[left] > array[right] && min > array[right])min = array[right];}else{mid = (left + right) / 2; // 对数组进行分治MaxAndMin(array, left, mid); // 对左边的数组进行分治递归MaxAndMin(array, mid + 1, right); // 对右边的数组进行分治递归}}3.2 众数问题3.2.1 流程图(如图图2.众数问题的流程图3.2.2 核心代码如下:void quickSort(int *array,int left,int right) // 用快速排序法排序数组{if(left < right){int i = left, j = right+1;int temp = array[left]; // 以第一个数为基准while(true){while(array[++i] < temp && i < right); // 从前面找大于基准的数while(array[--j] > temp); // 从后面找小于基准的数if(i >= j) // 当left>right时停止break;swap(array[i], array[j]); // 交换两值}array[left] = array[j];array[j] = temp;int part = j; // 以靠左的较小值为界,对左右两部分数继续快排quickSort(array, left, part-1);quickSort(array, part+1, right);}}4. 运行与调试4.1 查找数组最值产生随机数组并排序:(如图3、图4、图5)图3.随机数组之一及结果图4.随机数组之二及结果图5.随机数组之三及结果4.2 众数问题4.2.1 只有一个众数(如图6、图7)图6.只有一个众数的数组图7.只有一个众数的结果4.2.2 没有众数(如图8、图9)图8.没有众数的数组图9.没有众数的结果4.2.3 有两个众数(如图10、图11)图10.有两个众数的数组图11.有两个众数的结果5. 结果分析和小结5.1 结果分析:通过设置不同的测试数据及运行的结果,可以看出程序的算法思想是正确的,程序的运行也是有效的,全面的。

众数问题

众数问题

众数问题实验目的:描述众数问题,掌握有关算法。

实验内容:1)内容描述:给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重数集S中的重数最大的元素称为众数。

2)编程任务:对于给定的由n个自然数组成多重数集S,计算S的众数及其重数。

3)数据输入:输入数据由文件名input.txt的文本文件提供,文件的第1行为多重集元素的个数n;在接下来的n行中,每行有一个自然数.4)结果输出: 若计算结构输出到文件output.txt 。

输出文件有2行,第1行是众数,第2行是重数。

实验原理:先定义3个数组a [maxsize]、b[maxsize]、c[maxsize],将数据通过文件输入方式输入n个数到数组a,再将数组a的值赋值给数组c,接下来执行for循环for(i=0;i<n;i++),for(j=0;j<n;j++),将a[i]与c数组中的数逐一进行比较,如果a[i]=c[j],则将初始化int count=0(count++)进行自增,并令c[j]=0(这样做是为了避免a[i]之后与a[i]相同的数重复记录了重数),一轮循环下来后将count所得值赋值给对应的b[i],b[i]即为a[i]的重数。

接下来定义int max=b[0];对数组b[n]进行for(i=0;i<n;i++)循环,找出b[n]中的最大数b[z],则a[z]即为所求众数,用文件输出方式输出a[z],b[z]。

程序与代码:#include<iostream>#include<fstream>#define maxsize 10000using namespace std;void zhongshu(int a[],int n){int i,j,z=0,max,b[maxsize],c[maxsize]; ifstream myif;ofstream myof;for(i=0;i<n;i++)c[i]=a[i];//将数组a的数值赋值给c数组for(i=0;i<n;i++){int count=0;for(j=0;j<n;j++){if(c[j]==a[i]){c[j]=-1;//将数组c中与a[i]相同的赋值为-1,这样如果数组a后面与a[i]相同的数就不会重复记录他的重数,或者考虑如何删除c[j],或者删除一个数组中重复的数字count++;}}b[i]=count;//将与a[i]相同的个数赋值给b[i],即b[i]为重数;}max=b[0];for(i=0;i<n;i++){if(max<b[i]){max=b[i];z=i;}}//求数组b中的最大数,即重数//以下是考虑当出现最高重数相同,即有多个众数时的情况myof.open("c:\\output.txt");for(i=0;i<n;i++){if(b[i]==b[z])myof<<"众数是:"<<a[i]<<endl;}myof<<"重数是:"<<b[z]<<endl;myof.close();}void main(){int a[maxsize];int i,n;ifstream myif;ofstream myof;myif.open("c:\\input.txt"); //使用绝对路径myif>>n;myif.close();myif.open("c:\\input.txt"); //使用绝对路径for(i=0;i<n;i++)myif>>a[i];myif.close();zhongshu(a,n);}实验结果与分析:实验感悟:首先对于文件输入输出还不是很了解,所以做起来有点费劲,再者是这里判断a[i]的重数个数后不知道如何将数组c中与a[i]相同的数删去,后来想到自然数的定义是非负数,于是就将c数组中与a[i]相同的数赋值-1,这样a数组中后面与a[i]相同的数在执行循环后就不会重复记录重数了。

寻找众数问题实验报告

寻找众数问题实验报告

《算法设计与分析》上机实验报告专业软件工程班级 1101班学号 04113033学生姓名岳彦利完成日期 2013-10-241. 上机题目及实验环境1.1上机题目:众数问题1.2实验环境:CPU:英特尔第二代酷睿i3-2330M @2.2GHz 双核内存:4G操作系统:window s 7软件平台:ubuntu2. 算法设计与分析1. 用快速排序把随机生成的一组数排序放到数组中。

2.把排好的数组用下标按次序逐个比较,如果相等就用count=count+1,设个标记的flag,将count赋给flag,不相等就count=1,下标相加,循环,直到最后一个数。

3.在把最后比较的数放到x中,最终输出次数最多的数x和它的次数flag.3. 核心代码//快速排序递归,a[]代表数组,low代表数组的第一个数的下标,high代标数组最后一个数的下标int Partition(int a[],int low,int high){int x=a[low];//将数组的第一个数赋给xwhile(low<high){while(a[high]>=x && low<high)//从后往前找比x小的数high--;if(low<high){a[low]=a[high];//从后往前找到比x小的数赋给a[low]low++;}while(a[low]<x && low<high)//从前往后找比x大的数low++;if(low<high){a[high]=a[low];//从前往后找比x大的数赋给a[high]high--;}}a[low]=x;return low;}//开速排序void QuickSort(int a[],int low,int high){if(low<high){int pos=Partition(a,low,high);//递归调用QuickSort(a,low,pos-1);QuickSort(a,pos+1,high);}}//查找众数void findmode(int a[],int n){int count=1,flag=1,flag1=0;int i=0,x,x1;while(i<n){if(a[i+1]==a[i])//判断是否相等{count++;if(count==flag){flag1=count;x1=a[i];}if(count>flag){flag=count;x=a[i];}}elsecount=1;i++;}printf("output put:\n");if(flag==1)printf("没有众数!\n");else if(flag==flag1)printf("众数是:%d,%d\n出现的次数都是:%d\n",x,x1,flag);elseprintf("%d\n%d\n",x,flag);}4.运行与调试图一.当没有众数的错误情况图二.没有众数的正确情况图三.输出含有两个众数错误情况图四.输出含有两个众数正确的情况图五.输出含有1个众数的情况5. 结果分析和小结(1)如图一,是因为没有考虑到count=1时要输出的输出的数,所以输出的是一个垃圾数据,后来,加了一个标志flag,如果flag没有变就代表数组中没有众数,修改后如图二。

众数问题--C++实现

众数问题--C++实现

众数问题--C++实现2-2 众数问题算法设计:对于给定的由n个自然数组成的多重集S,计算S的众数(出现次数最多的数字)极其重数(出现次数)。

数据输入:数据由input.txt文件提供,文件第一行是S中的元素个数,接下来的n行中,每行一个自然数。

数据输出:输出到output.txt,第一行是众数,第二行是重数。

程序如下:#include#include#include#includeusing namespace std;int main(){ifstream inputFile("input.txt",ios::in);ofstream outputFile("output.txt",ios::out);if(!inputFile){cerr<<"inputFile could not be opened."<<endl;< p="">exit(1);}map number_count;int number;while(inputFile>>number)++number_count[number];map::iterator map_it=number_count.begin();map_it++; //从第二个元素开始计算int key=map_it->first;int maxcount=map_it->second;while(map_it!=number_count.end()){if(maxcountsecond){maxcount=map_it->second;key=map_it->first;}++map_it;}outputFile<<key<<endl<<maxcount;< p="">return 0;}问题:若有多个众数,则只能显示最后一个。

分治算法众数实验报告

分治算法众数实验报告

一、实验目的1. 理解分治算法的基本思想及其应用场景;2. 掌握分治算法在求解众数问题上的具体实现方法;3. 分析分治算法求解众数问题的性能,包括时间复杂度和空间复杂度;4. 对比分治算法与其他求解众数问题的算法,如哈希表法、计数排序法等。

二、实验内容1. 理解分治算法的基本思想,并分析其应用场景;2. 设计分治算法求解众数问题的具体步骤;3. 编写C++代码实现分治算法求解众数问题;4. 对比分治算法与其他求解众数问题的算法的性能;5. 分析实验结果,总结分治算法在求解众数问题上的优缺点。

三、实验步骤1. 理解分治算法的基本思想:分治算法是一种将大问题分解为小问题,分别解决小问题,最后合并小问题的方法。

分治算法通常具有以下三个步骤:(1)分解:将原问题分解为若干个规模较小的相同问题;(2)解决:递归求解每个子问题;(3)合并:将子问题的解合并为原问题的解。

2. 设计分治算法求解众数问题的具体步骤:(1)将给定的数组进行排序;(2)遍历排序后的数组,统计每个元素的出现次数;(3)找出出现次数最多的元素,即为众数。

3. 编写C++代码实现分治算法求解众数问题:```cpp#include <iostream>#include <vector>#include <algorithm>using namespace std;int countMax(vector<int>& nums, int left, int right) { int maxCount = 0;int maxElement = nums[left];for (int i = left; i <= right; i++) {int count = 0;for (int j = left; j <= right; j++) {if (nums[j] == nums[i]) {count++;}}if (count > maxCount) {maxCount = count;maxElement = nums[i];}}return maxElement;}int main() {int n;cin >> n;vector<int> nums(n);for (int i = 0; i < n; i++) {cin >> nums[i];}sort(nums.begin(), nums.end());int maxElement = countMax(nums, 0, n - 1); int maxCount = 0;for (int i = 0; i < n; i++) {int count = 0;for (int j = i; j < n; j++) {if (nums[i] == nums[j]) {count++;}}if (count > maxCount) {maxCount = count;}}cout << maxElement << endl;cout << maxCount << endl;return 0;}```4. 对比分治算法与其他求解众数问题的算法的性能:(1)哈希表法:时间复杂度为O(n),空间复杂度为O(n);(2)计数排序法:时间复杂度为O(n),空间复杂度为O(n);(3)分治算法:时间复杂度为O(n^2),空间复杂度为O(1)。

众数算法的实验报告

众数算法的实验报告

一、实验目的1. 了解众数算法的基本原理;2. 掌握众数算法的实现方法;3. 分析不同众数算法的优缺点;4. 评价众数算法在实际应用中的效果。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm三、实验原理众数(Mode)是一组数据中出现次数最多的数值。

在数据挖掘、统计学等领域,众数算法被广泛应用于寻找频繁项集、聚类分析等任务。

以下介绍几种常见的众数算法:1. 基于哈希表的众数算法2. 基于计数排序的众数算法3. 基于Boyer-Moore算法的众数算法四、实验内容1. 实现基于哈希表的众数算法2. 实现基于计数排序的众数算法3. 实现基于Boyer-Moore算法的众数算法4. 比较不同众数算法的执行时间、内存消耗等性能指标五、实验步骤1. 导入必要的库```pythonimport timeimport random```2. 实现基于哈希表的众数算法```pythondef mode_hash(data):counts = {}for item in data:if item in counts:counts[item] += 1else:counts[item] = 1max_count = max(counts.values())modes = [key for key, value in counts.items() if value == max_count] return modes```3. 实现基于计数排序的众数算法```pythondef mode_count(data):max_value = max(data)counts = [0] (max_value + 1)for item in data:counts[item] += 1max_count = max(counts)modes = []for i in range(len(counts)):if counts[i] == max_count:modes.append(i)return modes```4. 实现基于Boyer-Moore算法的众数算法```pythondef mode_boyer_moore(data):max_value = max(data)counts = [0] (max_value + 1)for item in data:counts[item] += 1max_count = max(counts)modes = []for i in range(len(counts)):if counts[i] == max_count:modes.append(i)return modes```5. 比较不同众数算法的性能```pythondata = [random.randint(0, 1000) for _ in range(1000000)]start_time = time.time()modes_hash = mode_hash(data)end_time = time.time()hash_time = end_time - start_timestart_time = time.time()modes_count = mode_count(data)end_time = time.time()count_time = end_time - start_timestart_time = time.time()modes_boyer_moore = mode_boyer_moore(data)end_time = time.time()boyer_moore_time = end_time - start_timeprint("基于哈希表的众数算法执行时间:{:.6f}秒".format(hash_time))print("基于计数排序的众数算法执行时间:{:.6f}秒".format(count_time))print("基于Boyer-Moore算法的众数算法执行时间:{:.6f}秒".format(boyer_moore_time))```六、实验结果与分析1. 执行时间:从实验结果可以看出,基于Boyer-Moore算法的众数算法在执行时间上具有优势,其次是基于计数排序的众数算法,而基于哈希表的众数算法在执行时间上相对较慢。

算法实验报告--众数问题

算法实验报告--众数问题

一、实验目的给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重数集S中的重数最大的元素称为众数。

例如,S={1,2,2,2,3,5}。

多重集S得众数是2,其重数为3。

对于给定的由n个自然数组成多重数集S,计算S的众数及其重数。

二、实验环境Windows7 + Visual Studio 2010三、实验内容1.设计思路利用快速排序将数据集S排序,再遍历整个数组,利用Number类记录每个数出现的频率,从而找出集合的众数和重数。

2.相关模块#include<iostream>#include<fstream>using namespace std;//存储数y与出现频率class Number{public:Number(){count = 0;}int value;int count;};void write(char* filename,int size,Number *num);void mode(int *a,int size,Number *num);void quickSort(int*,int,int);int Partition(int*,int,int);int main(){int size=0;int frequency=0;char* inFileName = "H:\\C++\\Algorithms\\in2.txt";char* outFileName = "H:\\C++\\Algorithms\\out2.txt";ifstream input(inFileName,ios::in);//从文件读取数据input >> size;int *a = new int[size];for(int i=0; i<size; ++i)input>>a[i];input.close();//对数组用快排排序quickSort(a,0,size-1);Number *num = new Number[size];mode(a,size,num);write(outFileName,size,num);system("pause");return 0;}//将众数与重数写入文件,如果有多个,则将所有结果依次写入文件void write(char* filename,int size,Number *num){int max = 0;for(int i=1; i<size; ++i)if(num[i].count>num[max].count)max = i -1;ofstream output;output.open(filename,ios::out);output << num[max].value << "\n" << num[max].count << endl;for(int i=0; i<size; ++i)if(num[max].count==num[i].count&&max!=i)output << num[i].value << "\n" << num[i].count << endl;output.close();}//划分int Partition(int *arr,int p,int r){int i=p, j=r+1;int x = arr[p];//sort < x to left, > x to rightwhile(true){while(arr[++i]<x&&i<r);while(arr[--j]>x);if(i>=j)break;swap(arr[i],arr[j]);}arr[p]=arr[j];arr[j]=x;return j;}//快排void quickSort(int *arr,int p,int r){if(p<r){int q = Partition(arr,p,r);quickSort(arr,p,q-1);//sort the left partquickSort(arr,q+1,r);//sort the right part }}//找出众数与重数void mode(int*a,int size, Number *num){int count = 1; //某个数出现的次数//遍历排好序的数组,计算出每个数出现的次数for(int i=0; i<size-1; ++i){if(a[i]==a[i+1])count++;else{num[i].value = a[i];num[i].count = count;count = 1;}}num[size-1].value = a[size-1];num[size-1].count = count;}四、实验结果分析及结论利用快速排序可以在O(n)平均时间内将数据集排好序,再花费O(n)遍历数据集找到众数与重数,总的时间复杂度为O(n)。

众数问题

众数问题

实验二、众数问题★问题描述:给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重集S中重数最大的元素称为众数。

例如,S={1,2,2,2,3,5}。

多重集S的众数是2,其重数为3。

★编程任务:对于给定的由n个自然数组成的多重集S,编程计算S的众数及其重数。

★数据输入:输入数据由文件名为input.txt的文本文件提供。

文件的第1行多重集S中元素个数n;接下来的n行中,每行有一个自然数。

★结果输出:程序运行结束时,将计算结果输出到文件output.txt中。

输出文件有2行,第1行给出众数,第2行是重数。

输入文件示例输出文件示例input.txt output.txt6 21 322235分析:如果我们将所有元素的出现次数进行统计,并从中找出次数中的最大值,那么,这个最大值对应的元素就是众数。

算法思路:首先将数组元素按照大小排序,然后按顺序扫描一遍数组,扫描的同时进行统计。

这样,通过一次排序和一遍扫描,我们就能够找到众数。

•关键步骤:排序,扫描统计•扫描统计时,需要定义三个辅助变量:一个用于计数,一个用于记录当前出现次数最多的元素的出现次数,一个用于记录当前出现次数最多的元素。

实验小结:本次实验基本掌握了如何查找众数问题,实验中用到快速排序算法以及结构体。

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

算法设计与分析:2-2众数问题

算法设计与分析:2-2众数问题

算法设计与分析:2-2众数问题2-2 众数问题问题描述给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重集S中重数最⼤的元素称为众数。

例如,S= {1,2,2,2,3,5}。

多重集S的众数是2,其重数为3。

对于给定的n个⾃然数组成的多重集S,计算S的众数及其重数 。

数组实现Javaimport java.util.Arrays;public class Main {public static void main(String[] args) {int[] numbers = {1, 2, 2, 2, 3, 5};// int[] numbers = {1, 2, 2, 2, 3, 5, 1, 1, 1, 1};// int[] numbers = {1, 2, 2, 2, 3, 5, 1, 1, 1};// int[] numbers = {1, 2, 2, 2, 3, 5, 5, 5, 5, 5, 5};// int[] numbers = {2, 2, 2, 2, 2, 2};// int[] numbers = {2};// int[] numbers = {2, 2};// int[] numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 1, 2, 2, 3, 4, 5};int maxNum = Arrays.stream(numbers).max().getAsInt();int[] count = new int[maxNum+1];for(int i=0; i<numbers.length; i++){count[numbers[i]]++;}int tmpCount = 0;int tmpValue = 0;//loop by array numbers length// for(int i=0; i<numbers.length; i++){// if(count[numbers[i]] > tmpCount){// tmpCount = count[numbers[i]];// tmpValue = numbers[i];// }// }//loop by the maximum number in array numbersfor(int i=0; i<=maxNum; i++){if(count[i] > tmpCount){tmpCount = count[i];tmpValue = i;}}System.out.println("The number: "+tmpValue+" appeared most times: "+tmpCount);}}分治法实现Javaimport java.util.Arrays;public class Main {// private static int[] numbers = {1, 2, 2, 2, 3, 5};// private static int[] numbers = {1, 2, 2, 2, 3, 5, 1, 1, 1, 1};// private static int[] numbers = {1, 2, 2, 2, 3, 5, 1, 1, 1};// private static int[] numbers = {1, 2, 2, 2, 3, 5, 5, 5, 5, 5, 5};// private static int[] numbers = {2, 2, 2, 2, 2, 2};// private static int[] numbers = {2};// private static int[] numbers = {2, 2};private static int[] numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 1, 2, 2, 3, 4, 5};private static int leftest = 0;private static int rightest = numbers.length-1;private static int left, right;private static int count=0;private static int number;public static void main(String[] args) {Arrays.sort(numbers);mode(leftest, rightest);System.out.println("The number: "+number+" appeared most times: "+count);}private static void mode(int l, int r){int midIndex = getMidIndex(l, r);split(numbers, midIndex, l, r);if(count < right-left+1){count = right-left+1;number = numbers[midIndex];}if(left-l > count)mode(l, left-1);if(r-right > count)mode(right+1, r);}private static int getMidIndex(int l, int r){return (l+r)/2;}private static void split(int[] numbers, int midIndex, int l, int r){left = midIndex;right = midIndex;while (left-1 >=l && numbers[--left] == numbers[midIndex]);while (right+1<=r && numbers[++right] == numbers[midIndex]);if(numbers[l] != numbers[midIndex])left++;if(numbers[r] != numbers[midIndex])right--;}}Map实现Javaimport java.util.*;public class Main {public static void main(String[] args) {int[] numbers = {1, 2, 2, 2, 3, 5};// int[] numbers = {1, 2, 2, 2, 3, 5, 1, 1, 1, 1};// int[] numbers = {1, 2, 2, 2, 3, 5, 1, 1, 1};// int[] numbers = {1, 2, 2, 2, 3, 5, 5, 5, 5, 5, 5};// int[] numbers = {2, 2, 2, 2, 2, 2};// int[] numbers = {2};// int[] numbers = {2, 2};// int[] numbers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 1, 2, 2, 3, 4, 5};Map<Integer, Integer> kvMap = new HashMap<>();for (int i = 0; i < numbers.length; i++) {Integer v = kvMap.get(numbers[i]);kvMap.put(numbers[i], v == null ? 1 : v + 1);}//ArrayListList<Map.Entry<Integer, Integer>> entries = new ArrayList<>(kvMap.entrySet());// 对entries按出现频率从⼤到⼩排序Collections.sort(entries, new Comparator<Map.Entry<Integer, Integer>>() {@Overridepublic int compare(Map.Entry<Integer, Integer> e1, Map.Entry<Integer, Integer> e2) {return e2.getValue() - e1.getValue();}});System.out.println("The number: "+entries.get(0).getKey()+" appeared most times: "+entries.get(0).getValue());int size = entries.size();for (int i = 1; i < size; i++) {// 如果之后的entry与第⼀个entry的value相等,那么这个entry的键也是众数if (entries.get(i).getValue().equals(entries.get(0).getValue())) {System.out.println("The number: "+entries.get(i).getKey()+" appeared most times: "+entries.get(i).getValue());} else {break;}}}}Sample outputThe number: 2 appeared most times: 3Reference王晓东《计算机算法设计与分析》(第3版)P41。

算法实验二分治法众数问题

算法实验二分治法众数问题

算法实验二分治法众数问题算法分析与设计实验二分治法主要内容实验目的主要实验仪器设备和环境?实验内容实验要求注意点实验目的理解分治法的基本思想针对特定问题,可以设计出分治算法进行求解主要实验仪器设备和环境每位学生一台计算机计算机的操作系统为–windows 2000或Windows XP工具软件–C++ IDE,JAVA IDE实验内容一众数问题在一个包含n个元素的多重集合S中,每个元素在S中出现的次数称为该元素的重数,多重集合S中重数最大的元素称为众数。

举例来说,多重集合S={1,2,3,3,3,4,4,5},则多重集合S的众数是3,元素3的重数为3。

现要求对随机生成的由n个自然数组成的多重集合S,应用分治法编程计算S的众数及其重数。

实验要求编程语言可以用C,C++或者JAVA,关键步骤必须有注释实验报告必须包含以下内容:算法设计的基本思路、程序清单以及针对测试数据的运行结果?实验报告电子版请发至seualgo@/doc/021*******.html,,Email标题:“学号姓名算法实验二众数问题”,附件请不要压缩,实验报告名:“学号姓名算法实验二众数问题”注意点随机数的生成问题求解众数问题时的分治策略编码提示随机数生成–srand(time(0));//设置随机数种子要#include–rand();//生成[0,MAX)之间的随机整数?要#include–for(int i=0;i<10;i++){ran_num=rand() % 10;cout<<ran_num<<" ";<="" p="">}//生成不大于10的随机整数编码提示一种思路–先根据某数X,将小于X的放于其左,大于X的放于其右–统计X出现的次数T–如果X左边数的个数>T,向左递归–如果X右边数的个数>T,向右递归</ran_num<<">。

算法与分析课程设计—寻找众数问题

算法与分析课程设计—寻找众数问题

}
3、 期望输入与输出
表中存入1,2,3,2,2,4,2元素; 期望输出:“总数是2”“出现次数4”
4、 算法分析与步骤描述
一个表中含有n个元素,可以将表中的元素按大小排 序,然后一次比较大小,并记录各个元素的数量,取出最多的 元素。
5、 问题实例及算法运算步骤
设置一个由7个元素组成的表,其中出现次数最多的元 素称为众数。试写寻找众数的算法。 1. 声明一个含有7位元素的数组array; 2. 将array中的数组由小到大排序; 3. 声明一个count,用作计算元素出现的次数; 4. 做循环,一次比较数组中的元素是否与后一个相同,若 相同,则count加一;反之,记录count,并使count重新 置一; 5. 重复上诉步骤,直至比较完所有元素; 6. 输出使count最大的元素。
6、 算法运行截图 7、 附录代码(java)
package sfdesign; import java.util.Apublic class Mode {
/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Scanner scan=new Scanner(System.in); double[] array={1,2,3,2,2,4,2}; mode(array); } public static double mode(double[] array) { Arrays.sort(array); int count = 1; int longest = 0; double mode = 0; int temp=0; for (int i = 0; i < array.length-1; i++) { if (array[i] == array[i + 1]) { count++; } else { count = 1;//如果不等于,就换到了下一个数,那么计算下一 个数的次数时,count的值应该重新符值为一 continue; } if (count > longest) { mode = array[i]; longest = count; temp=i; } } System.out.println("众数是"+array[temp]); System.out.println("出现次数"+longest);//打印出这个数出现 的次数已判断是否正确 return mode; }

2017.10.7计算机算法分析与设计------众数问题

2017.10.7计算机算法分析与设计------众数问题

2017.10.7计算机算法分析与设计------众数问题2.问题:给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重集S中重数最⼤的元素称为众数。

例如,S={1,2,2,2,3,5}。

多重集S的众数是2,其重数为3。

先对集合中的元素从⼩到⼤排序,然后统计重数,最后找出出现次数最多重数及其对应的元素。

实现步骤:```1.开⼀个数组a[n],a[n]存放集合中的元素;2.sort(a,a+n)对元素从⼩到⼤排;3.对排序后的元素进⾏重数统计```思路:1.以中间的数字为界限,确定左右起始和终⽌界限。

2.分割成2段数组。

3.中间数与2段数组分别⽐较。

若中<左,即最⼤众数可能存在左端,将左端再进⾏2段分割(递归)直到中 > 左为⽌。

右端同理。

左右递归计算,取最值就是最终答案。

####//实现代码如下:#include“iostream”#include“algorithm”using namespace std;int main(){int n,i,m=0,s,max=0,t,*a;//m标记元素,s统计该元素重数,max标记出现的最⼤,t表⽰该重数对应的元素scanf("%d",&n);printf("请输⼊6个数字:");a=new int[n];for(i=0;i<n;i++)scanf("%d",&a[i]);sort(a,a+n);for(i=0;i<n;i++){if(m!=a[i])s=1;elses++;m=a[i];if(s>max){t=m;max=s;}}printf("\n");printf("众数是:%d\n重数是:%d\n",t,max);return 0;}。

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

算法分析与设计
实验报告
实验名称:众数问题
实验日期: 2011/03/13
学生姓名:
学生学号:
一、实验目的
给定含有n个元素的多重集合S,每个元素在S中出现的次数称为该元素的重数。

多重数集S中的重数最大的元素称为众数。

例如,S={1,2,2,2,3,5}。

多重集S得众数是2,其重数为3。

对于给定的由n个自然数组成多重数集S,计算S的众数及其重数。

二、实验环境
Windows7 + Visual Studio 2010
三、实验内容
1.设计思路
利用快速排序将数据集S排序,再遍历整个数组,利用Number类记录每个数出现的频率,从而找出集合的众数和重数。

2.相关模块
#include<iostream>
#include<fstream>
using namespace std;
//存储数y与出现频率
class Number{
public:
Number(){count = 0;}
int value;
int count;
};
void write(char* filename,int size,Number *num);
void mode(int *a,int size,Number *num);
void quickSort(int*,int,int);
int Partition(int*,int,int);
int main()
{
int size=0;
int frequency=0;
char* inFileName = "H:\\C++\\Algorithms\\in2.txt";
char* outFileName = "H:\\C++\\Algorithms\\out2.txt";
ifstream input(inFileName,ios::in);
//从文件读取数据
input >> size;
int *a = new int[size];
for(int i=0; i<size; ++i)
input>>a[i];
input.close();
//对数组用快排排序
quickSort(a,0,size-1);
Number *num = new Number[size];
mode(a,size,num);
write(outFileName,size,num);
system("pause");
return 0;
}
//将众数与重数写入文件,如果有多个,则将所有结果依次写入文件
void write(char* filename,int size,Number *num)
{
int max = 0;
for(int i=1; i<size; ++i)
if(num[i].count>num[max].count)
max = i -1;
ofstream output;
output.open(filename,ios::out);
output << num[max].value << "\n" << num[max].count << endl;
for(int i=0; i<size; ++i)
if(num[max].count==num[i].count&&max!=i)
output << num[i].value << "\n" << num[i].count << endl;
output.close();
}
//划分
int Partition(int *arr,int p,int r)
{
int i=p, j=r+1;
int x = arr[p];
//sort < x to left, > x to right
while(true)
{
while(arr[++i]<x&&i<r);
while(arr[--j]>x);
if(i>=j)break;
swap(arr[i],arr[j]);
}
arr[p]=arr[j];
arr[j]=x;
return j;
}
//快排
void quickSort(int *arr,int p,int r)
{
if(p<r)
{
int q = Partition(arr,p,r);
quickSort(arr,p,q-1);//sort the left part
quickSort(arr,q+1,r);//sort the right part }
}
//找出众数与重数
void mode(int*a,int size, Number *num)
{
int count = 1; //某个数出现的次数
//遍历排好序的数组,计算出每个数出现的次数
for(int i=0; i<size-1; ++i)
{
if(a[i]==a[i+1])
count++;
else
{
num[i].value = a[i];
num[i].count = count;
count = 1;
}
}
num[size-1].value = a[size-1];
num[size-1].count = count;
}
四、实验结果分析及结论
利用快速排序可以在O(n)平均时间内将数据集排好序,再花费O(n)遍历数据集找到众数与重数,总的时间复杂度为O(n)。

相关文档
最新文档