排序算法性能比较报告

合集下载

算法实验报告结果分析

算法实验报告结果分析

一、实验背景随着计算机科学技术的不断发展,算法作为计算机科学的核心内容之一,其重要性日益凸显。

为了验证和评估不同算法的性能,我们进行了一系列算法实验,通过对比分析实验结果,以期为后续算法研究和优化提供参考。

二、实验方法本次实验选取了三种常见的算法:快速排序、归并排序和插入排序,分别对随机生成的数据集进行排序操作。

实验数据集的大小分为10000、20000、30000、40000和50000五个级别,以验证算法在不同数据量下的性能表现。

实验过程中,我们使用Python编程语言实现三种算法,并记录每种算法的运行时间。

同时,为了确保实验结果的准确性,我们对每种算法进行了多次运行,并取平均值作为最终结果。

三、实验结果1. 快速排序快速排序是一种高效的排序算法,其平均时间复杂度为O(nlogn)。

从实验结果来看,快速排序在所有数据量级别下均表现出较好的性能。

在数据量较小的10000和20000级别,快速排序的运行时间分别为0.05秒和0.1秒;而在数据量较大的40000和50000级别,运行时间分别为0.8秒和1.2秒。

总体来看,快速排序在各个数据量级别下的运行时间均保持在较低水平。

2. 归并排序归并排序是一种稳定的排序算法,其时间复杂度也为O(nlogn)。

实验结果显示,归并排序在数据量较小的10000和20000级别下的运行时间分别为0.15秒和0.25秒,而在数据量较大的40000和50000级别,运行时间分别为1.5秒和2.5秒。

与快速排序相比,归并排序在数据量较小的情况下性能稍逊一筹,但在数据量较大时,其运行时间仍然保持在较低水平。

3. 插入排序插入排序是一种简单易实现的排序算法,但其时间复杂度为O(n^2)。

实验结果显示,插入排序在数据量较小的10000和20000级别下的运行时间分别为0.3秒和0.6秒,而在数据量较大的40000和50000级别,运行时间分别为8秒和15秒。

可以看出,随着数据量的增加,插入排序的性能明显下降。

排序算法比较

排序算法比较

排序算法比较
排序算法的效率主要取决于算法的时间复杂度。

以下是常见的几种排序算法的时间复杂度和优缺点的对比:
1. 冒泡排序
冒泡排序的时间复杂度为O(n^2)。

优点是它的实现简单易懂,缺点是排序速度很慢,对大规模数据排序不太适用。

2. 插入排序
插入排序的时间复杂度也为 O(n^2)。

它的优点是适用于小数
据量的排序,缺点是对于大规模数据排序仍然效率不高。

3. 选择排序
选择排序的时间复杂度也为 O(n^2)。

它的优点是对于小数据
量的排序速度较快,但是因为其算法结构固定,所以其效率在大规模数据排序中表现不佳。

4. 快速排序
快速排序的时间复杂度为 O(nlogn)。

它是一种非常常用的排序算法,适用于大规模数据排序。

快速排序的优点在于分治的思想,可以充分发挥多线程并行计算的优势,缺点是在极端情况下(如输入的数据已经有序或者逆序)排序速度会较慢。

5. 堆排序
堆排序的时间复杂度为 O(nlogn)。

它的优点在于实现简单、稳定,可以用于实时系统中的排序。

缺点是在排序过程中需要使用一个堆结构来维护排序序列,需要额外的内存开销。

同时,由于堆的性质,堆排序不能发挥多线程并行计算的优势。

6. 归并排序
归并排序的时间复杂度为 O(nlogn)。

它的优点在于稳定、可靠,效率在大规模数据排序中表现良好。

归并排序在实现过程中需要使用递归调用,需要额外的内存开销。

同时,归并排序不适用于链式存储结构。

算法性能实验报告

算法性能实验报告

一、实验目的本次实验旨在通过对比分析几种常用排序算法的性能,深入了解各种算法在不同数据规模和不同数据分布情况下的时间复杂度和空间复杂度,为实际应用中算法的选择提供参考。

二、实验环境- 操作系统:Windows 10- 编程语言:C++- 编译器:Visual Studio 2019- 测试数据:随机生成的正整数序列三、实验内容本次实验主要对比分析了以下几种排序算法:1. 冒泡排序(Bubble Sort)2. 选择排序(Selection Sort)3. 插入排序(Insertion Sort)4. 快速排序(Quick Sort)5. 归并排序(Merge Sort)6. 希尔排序(Shell Sort)四、实验方法1. 对每种排序算法,编写相应的C++代码实现。

2. 生成不同规模(1000、5000、10000、50000、100000)的随机正整数序列作为测试数据。

3. 对每种排序算法,分别测试其时间复杂度和空间复杂度。

4. 对比分析不同算法在不同数据规模和不同数据分布情况下的性能。

五、实验结果与分析1. 时间复杂度(1)冒泡排序、选择排序和插入排序的平均时间复杂度均为O(n^2),在数据规模较大时性能较差。

(2)快速排序和归并排序的平均时间复杂度均为O(nlogn),在数据规模较大时性能较好。

(3)希尔排序的平均时间复杂度为O(n^(3/2)),在数据规模较大时性能优于冒泡排序、选择排序和插入排序,但不如快速排序和归并排序。

2. 空间复杂度(1)冒泡排序、选择排序和插入排序的空间复杂度均为O(1),属于原地排序算法。

(2)快速排序和归并排序的空间复杂度均为O(n),需要额外的空间来存储临时数组。

(3)希尔排序的空间复杂度也为O(1),属于原地排序算法。

3. 不同数据分布情况下的性能(1)对于基本有序的数据,快速排序和归并排序的性能会受到影响,此时希尔排序的性能较好。

(2)对于含有大量重复元素的数据,快速排序的性能会受到影响,此时插入排序的性能较好。

算法实验报告

算法实验报告

算法实验报告算法实验报告引言:算法是计算机科学的核心内容之一,它是解决问题的方法和步骤的描述。

算法的设计和分析是计算机科学与工程中的重要研究方向之一。

本实验旨在通过对算法的实际应用和实验验证,深入理解算法的性能和效果。

实验一:排序算法的比较在本实验中,我们将比较三种常见的排序算法:冒泡排序、插入排序和快速排序。

我们将通过对不同规模的随机数组进行排序,并记录每种算法所需的时间和比较次数,以评估它们的性能。

实验结果显示,快速排序是最快的排序算法,其时间复杂度为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)实验项目组成该程序由主函数main()和子函数quicksort(),shellsort(),binSort()组成。

(3)实验项目的程序结构:(4)函数的功能描述quicksort(int a[],int l,int r,int *u1,int *v1) 快速排序算法shellsort(int a[],int n) shell排序算法binSort(int a[],int n) 2分插入排序算法(5)实验数据与实验结果测试数据:在main()函数里面可以事先给定要排序的整数,这里给的是11,3,28,52,46,32,66,88 等 8个非顺序数据.实验结果见下图:(6)算法描述:#include "stdio.h"#include "conio.h"quicksort(int a[],int l,int r,int *u1,int *v1) /*快速排序*/ {int i,j,temp,k=0,u,v;i=l; j=r;temp=a[i];if(l>=r) return;while(i!=j){while(a[j]>=temp&&i<j) j--;*u1=*u1+1;if(i<j) { a[i]=a[j]; *v1=*v1+1; i++;}while(a[i]<temp&&i<j) i++;*u1=*u1+1;if(i<j) {a[j]=a[i];*v1=*v1+1;j--;}}a[i]=temp;quicksort(a,l,i-1,u1,v1);quicksort(a,i+1,r,u1,v1);}void shellsort(int a[],int n) /*希尔排序*/ {int d,i,j,x,y , temp,v;x=0; y=0 ;for(d=n/2;d>0;d=d/2){for(i=d;i<n;i++){temp=a[i];j=i-d;while(j>=0 && temp<a[j]){a[j+d]=a[j];y++;j=j-d;}x++ ;a[j+d]=temp;}}printf("\n the number of compare x=%d ",x);printf("\n the number of move y=%d\n ",y); for(v=0;v<=7;v++){ printf("%5d",a[v]);}printf("\n");}void binSort(int a[],int n) /* 折半插入排序 */ {int i,j,low,hight,mid,m=0,k =0 ;int v;int temp;for(i=1;i<n;i++){temp=a[i];low=0; hight=i-1;while(low<=hight){mid=(low+hight)/2;if (temp<a[mid])hight=mid-1;else low=mid+1;m++;}for(j=i-1;j>=low;j--)a[j+1]=a[j]; k++;if(low!=i) k++;a[low]=temp;}printf("the number of compare m=%d\n",m);printf("the number of move k=%d\n",k);for(v=0;v<=7;v++){ printf("%8d",a[v]); }}void main(){int i,j,k,v;int *u1=2,*v1 =0;int a[8]={11,3,28,52,46,32,66,88};int b[8]={11,3,28,52,46,32,66,88};int c[8]={11,3,28,52,46,32,66,88};printf("binSort\n");printf("\n");binSort(a,8);printf("\n");printf("shellSort\n");shellsort(b,8);printf("\n");printf("quickSort\n");printf("\n");quicksort(c,0,8,u1,v1);for(v=0;v<=7;v++){ printf("%5d",a[v]);}printf("\n the number of compare u1=%d ",*u1); printf("\n the number of move v1=%d \n ",*v1);getch();}。

排序的实验报告

排序的实验报告

排序的实验报告排序的实验报告引言:排序是计算机科学中常见的问题之一。

在实际应用中,我们经常需要对一组数据进行排序,以便更好地理解和分析数据。

本实验旨在比较不同排序算法的效率和性能,以及探讨它们在不同数据集上的表现。

实验设计:为了进行排序算法的比较,我们选择了五种常见的排序算法,分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。

我们使用Python编程语言实现了这些算法,并在同一台计算机上运行它们以确保公平比较。

实验步骤:1. 数据集的准备我们选择了三种不同规模的数据集:小规模(100个元素)、中规模(1000个元素)和大规模(10000个元素)。

这些数据集包含了随机生成的整数。

2. 算法实现我们按照上述算法的描述,使用Python编程语言实现了这些排序算法。

为了确保准确性和效率,我们在实现过程中进行了多次测试和调试。

3. 实验运行我们分别对小规模、中规模和大规模的数据集运行这些排序算法,并记录下每个算法的运行时间。

实验结果:1. 小规模数据集排序结果对于小规模的数据集,所有的排序算法都能够在很短的时间内完成排序。

然而,快速排序和归并排序的运行时间明显短于冒泡排序、选择排序和插入排序。

2. 中规模数据集排序结果随着数据规模的增加,冒泡排序、选择排序和插入排序的运行时间显著增加,而快速排序和归并排序的运行时间仍然较短。

特别是在中规模数据集上,快速排序和归并排序的效率明显高于其他算法。

3. 大规模数据集排序结果在大规模数据集上,冒泡排序、选择排序和插入排序的运行时间急剧增加,而快速排序和归并排序的运行时间仍然保持在可接受的范围内。

这进一步证明了快速排序和归并排序的高效性。

讨论:通过对不同规模数据集的排序实验,我们可以得出以下结论:1. 快速排序和归并排序是最有效的排序算法,它们的运行时间相对较短。

2. 冒泡排序、选择排序和插入排序在小规模数据集上表现良好,但在大规模数据集上效率较低。

3. 对于特定的应用场景,选择合适的排序算法非常重要。

排序和查找的实验报告

排序和查找的实验报告

排序和查找的实验报告实验报告:排序和查找引言排序和查找是计算机科学中非常重要的基本算法。

排序算法用于将一组数据按照一定的顺序排列,而查找算法则用于在已排序的数据中寻找特定的元素。

本实验旨在比较不同排序和查找算法的性能,并分析它们的优缺点。

实验设计为了比较不同排序算法的性能,我们选择了常见的几种排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。

我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。

在查找算法的比较实验中,我们选择了顺序查找和二分查找两种常见的算法。

同样地,我们使用相同的随机数据集对这些算法进行了测试,并记录了它们的执行时间和占用空间。

实验结果在排序算法的比较实验中,我们发现快速排序和归并排序在大多数情况下表现最好,它们的平均执行时间和空间占用都要优于其他排序算法。

而冒泡排序和插入排序则表现较差,它们的执行时间和空间占用相对较高。

在查找算法的比较实验中,二分查找明显优于顺序查找,尤其是在数据规模较大时。

二分查找的平均执行时间远远小于顺序查找,并且占用的空间也更少。

结论通过本实验的比较,我们得出了一些结论。

首先,快速排序和归并排序是较优的排序算法,可以在大多数情况下获得较好的性能。

其次,二分查找是一种高效的查找算法,特别适用于已排序的数据集。

最后,我们也发现了一些排序和查找算法的局限性,比如冒泡排序和插入排序在大数据规模下性能较差。

总的来说,本实验为我们提供了对排序和查找算法性能的深入了解,同时也为我们在实际应用中选择合适的算法提供了一定的参考。

希望我们的实验结果能够对相关领域的研究和应用有所帮助。

排序算法设计实验报告总结

排序算法设计实验报告总结

排序算法设计实验报告总结1. 引言排序算法是计算机科学中最基础的算法之一,它的作用是将一组数据按照特定的顺序进行排列。

在现实生活中,我们经常需要对一些数据进行排序,比如学生成绩的排名、图书按照标题首字母进行排序等等。

因此,了解不同的排序算法的性能特点以及如何选择合适的排序算法对于解决实际问题非常重要。

本次实验旨在设计和实现几种经典的排序算法,并对其进行比较和总结。

2. 实验方法本次实验设计了四种排序算法,分别为冒泡排序、插入排序、选择排序和快速排序。

实验采用Python语言进行实现,并通过编写测试函数对算法进行验证。

测试函数会生成一定数量的随机数,并对这些随机数进行排序,统计算法的执行时间和比较次数,最后将结果进行记录和分析。

3. 测试结果及分析3.1 冒泡排序冒泡排序是一种简单且常用的排序算法,其基本思想是从待排序的数据中依次比较相邻的两个元素,如果它们的顺序不符合要求,则交换它们的位置。

经过多轮的比较和交换,最小值会逐渐冒泡到前面。

测试结果显示,冒泡排序在排序1000个随机数时,平均执行时间为0.981秒,比较次数为499500次。

从执行时间和比较次数来看,冒泡排序的性能较差,对于大规模数据的排序不适用。

3.2 插入排序插入排序是一种简单但有效的排序算法,其基本思想是将一个待排序的元素插入到已排序的子数组中的正确位置。

通过不断将元素插入到正确的位置,最终得到排序好的数组。

测试结果显示,插入排序在排序1000个随机数时,平均执行时间为0.892秒,比较次数为249500次。

插入排序的性能较好,因为其内层循环的比较次数与待排序数组的有序程度相关,对于近乎有序的数组排序效果更好。

3.3 选择排序选择排序是一种简单但低效的排序算法,其基本思想是在待排序的数组中选择最小的元素,将其放到已排序数组的末尾。

通过多次选择和交换操作,最终得到排序好的数组。

测试结果显示,选择排序在排序1000个随机数时,平均执行时间为4.512秒,比较次数为499500次。

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

排序算法性能之比较
----19090107 李萍
✧课程题目:
编程实现希尔、快速、堆排序、归并排序算法。

要求随机产生待排数据存入磁盘文件,然后读入数据文件,实施排序后将数据写入另一个文件。

✧开发平台:
✧算法描述:
◆希尔排序:
希尔排序(Shell Sort)是对直接插入排序的一种改进,其基本思想为:先将整个待排序列划分成若干子序列,在子序列内分别进行直接插入排序,然后重复上述的分组和排序;只是分组方法不同;最后对整个序列进行直接插入排序。

◆快速排序:
快速排序几乎是最快的排序算法,被称为20世纪十大算法之一。

其基本思想为:从待排序记录序列中选取一个记录(通常选取第一个记录为枢轴),其关键字值设为k,将关键字值小于k的记录移到前面,而将关键字值大于k的记录移到后面,结果将待排序记录序列分成两个子表,最后将关键字值为k的记录插入到分界线处。

这是一次“划分”。

对划分后的子表继续按上述原则进行划分,直到所有子表的表长不超过1为止,此时待排序记录序列就变成了一个有序序列。

◆堆排序:
堆排序是选择排序的一种改进。

堆是具有下列性质的完全二叉树:每个结点的值都小于或等于其左、右孩子结点的值(小顶堆);或者每个结点都大于或等于其左、右孩子的值(大顶堆)。

堆排序基本思想为(采用大顶堆):首先待排序的记录序列构造成一个堆,此时选出堆中所有记录的最大者,即堆顶记录,然后将它从堆中移走(通常将堆顶记录和堆中最后一个记录交换),并将剩余的记录再调整成堆,这样又找出了次大的记录,依此类推,直到堆中只有一个记录为止。

◆归并排序:
归并就是将两个或两个以上的有序序列合并成一个有序序列。

归并排序的主要思想是:将若干有序序列逐步归并,最终归并为一个有序序列。

✧程序结构:
①各函数之间的关系图如下:
②程序运行结果:
欢迎界面:
运行界面:
✧算法性能比较
◆理论分析:
排序方法平均情况最好情况最坏情况
希尔排序O(nlog2n)~O(n2) O(n1.3) O(n2)
快速排序O(nlog2n) O(nlog2n) O(n2)
归并排序O(nlog2n) O(nlog2n) O(nlog2n)
堆排序O(nlog2n) O(nlog2n) O(nlog2n)
从时间复杂性上看:快速排序,归并排序和堆排序的平均复杂性相同,希尔排序的时间较大些。

◆实际分析:
在保证算法正确性的情况下,程序分别选取了
50000,100000,150000,200000,250000,300000,400000,500000,1000000,2000000个随机数,测试四种算法运行时间。

从测试结果上看:
1)当随机数个数在1000000以下时,四种算法的运行时间都在1s以下。

2)从图中可以很直观的看出快速排序至始至终都是运行速度最快的,性能最高。

3)当随机数个数在500000以下时,四种算法运行时间相差不大,随着随机数个数不断增大时,四种算法的效率可以明显看出来:快速排序>归并排序>堆排序>希尔排序。

4)堆排序和归并排序的运行时间相当,这和理论情况是相同的,但是快速排序却明显高于堆排序和归并排序,和理论情况有些出入。

希尔排序运行时间最长也是符合理论情况的。

◆原因分析:
为什么会出现理论结果与实际结果不符的情况呢?这里涉及两个概念:
1.时间频度:一个算法中的语句执行次数称为语句频度或时间频度。

代表一个算法执行所耗费的时间,从理论上是不能算出来的,必须上机运行测试才能知道,记为T(n)。

2.时间复杂性:在刚才提到的时间频度中,n称为问题的规模,当n不断变化时,时间频度T(n)也会不断变化。

但有时我们想知道它变化时呈现什么规律。

为此,我们引入时间复杂度概念。

一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数。

记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度,简称时间复杂度。

在各种不同算法中,若算法中语句执行次数为一个常数,则时间复杂度为O(1),另外,在时间频度不相同时,时间复杂度有可能相同,如T(n)=n2+3n+4与
T(n)=4n2+2n+1它们的频度不同,但时间复杂度相同,都为O(n2)。

所以时间复杂性只是在数量级上给用户提供一个时间的上下限,不是精准的运行时间,所以出现以上情况是正常的。

✧收获与体会
1)随机数的产生:
密码被广泛应用于信息系统中,以实现系统信息的保密性、完整性、可用性、可控性和不可否认性。

随机数在密码学中扮演着极其重要的角色,比如密钥管理、密码学协议、数字签名、身份认证等都需要用到随机数。

如何产生高质量的随机数一直是一个经久不衰的话题,如今,它已成为密码学乃至信息安全领域的一个重要研究方向。

生成随机数的方法繁多,从产生机理来说,可分为数学方法和物理方法两种,其所产生的随机数分别被称之为伪随机数和真随机数,前者易被破解,后者取自物理世界的真实随机源,难以破解,但这并不代表基于真随机源产生的随机数质量就很高,要取决于产生算法如何利用这个真随机源,相反的,许多用数学方法产生的随机数质量比较好。

因此,若能将数学方法和物理方法结合起来,则可能产生高质量的真随机数。

从实现方法来说,有以软件为主、以硬件为主以及软硬结合等方法。

设计一个真随机数发生器包括两步:首先是获取真随机源;然后是利用真随机源依照特定的数学方法获得真随机数。

【注1】
我们平时设计的小程序会涉及到随机数的产生,我们都会使用random函数,但单单使用此函数生成的随机数就是伪随机,每次产生的随机数都是相同的。

这是因为计算机产生随机数的方式一般是利用主板上的定时器产生的数据来生成的,而且会采用一定的算法,当一个数确定后,其实它的下一个数就确定了,所以每次都用相同的时间种子时,产生的随机数都是相同的。

因此,要想使每次的随机数都不同时,我们可以给予不同的时间种子,即在调用random函数之前先调用srand(time(NULL))。

2)测试程序运行时间函数的总结:
1.利用clock函数:
#include<iostream>
#include<ctime>
using namespace std;
int main()
{
time_t begin,end;
begin=clock();
//your code
end=clock();
cout<<"runtime: "<<double(end-begin)<<endl;
}【注2】
2.要进一步提高计时精度,就要采用QueryPerformanceFrequency()函数和QueryPerformanceCounter()函数。

2)这两个函数是VC提供的仅供Windows 9X使用的高精度时间函数,并要求计算机从硬件上支持高精度计时器。

int main(void)
{
LARGE_INTEGER BegainTime ;
LARGE_INTEGER EndTime ;
LARGE_INTEGER Frequency ;
QueryPerformanceFrequency(&Frequency);
QueryPerformanceCounter(&BegainTime) ;
//要测试的代码放在这里
QueryPerformanceCounter(&EndTime);
//输出运行时间(单位:s)
cout << "运行时间(单位:s):" <<
(double)( EndTime.QuadPart -BegainTime.QuadPart )/ Frequency.QuadPart <<endl;
system("pause") ;
return 0 ;
} 【注3】
参考文献:
【1】吉根林、陈波数据结构教程(C++版) 电子工业出版社2009年
【2】宋勇、陈贤富、姚海东随机数发生器探讨及一种真随机数发生器实现
计算机工程2007,33(2)
- 5 -。

相关文档
最新文档