排序算法测量时间

1. 测量排序类运行的时间

测量排序类运行的时间取决于对比图的复杂程度。
不管是提高自身的能力，还是面试，八大排序都是很重要的一个知识点，所以理解并实践实现是很有必要的，以下给出算法思想与代码实现，并且进行运行时间测试八大排序的效率。
冒泡排序是一种简单的排序算法。
主要思想是顺序的比较相邻的两个数，如果符合比较条件就替换两个数。
做法可以从后往前推，也可以从前往后推，每次推出当前长度的最大值，直至最后便可以完整的排序。

2. 如何测算每种排序算法的所用实际时间,如何修改排序算法

你又不是干计算机的。问这个干吗？

3. 排序算法的时间复杂度

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。

一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。比如直接插入排序的时间复杂度是O(n^2),空间复杂度是O(1) 。

而一般的递归算法就要有O(n)的空间复杂度了，因为每次递归都要存储返回信息。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

(3)排序算法测量时间扩展阅读：

排序算法经过了很长时间的演变，产生了很多种不同的方法。对于初学者来说，对它们进行整理便于理解记忆显得很重要。每种算法都有它特定的使用场合，很难通用。因此，我们很有必要对所有常见的排序算法进行归纳。

排序大的分类可以分为两种：内排序和外排序。在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使用外存，则称为外排序。下面讲的排序都是属于内排序。

内排序有可以分为以下几类：

(1)、插入排序：直接插入排序、二分法插入排序、希尔排序。

(2)、选择排序：直接选择排序、堆排序。

(3)、交换排序：冒泡排序、快速排序。

(4)、归并排序

(5)、基数排序

4. 我的java排序算法程序，想计算运行时间，结果为0，求各路高手解答。

因为你的数太少，现在的CPU运行速度很快的 你的代码没贴完整 我自己修改了下弄了个完整的 输入了10000个整数 运行时间大概是110毫秒。
public class Test5 {
public static void main(String[] args) {
long begin = System.currentTimeMillis();
int[] s_array = new int[10000];
int n = s_array.length;
for (int i = 0; i < n; i++) {
s_array[i] = i;
}
for (int i = 0; i < n - 1; i++) {
int k = i;
for (int j = i + 1; j < n; j++) {
if (s_array[j] < s_array[k])
k = j;
}
if (k != i) {
int temp;
temp = s_array[i];
s_array[i] = s_array[k];
s_array[k] = temp;
}
}
long end = System.currentTimeMillis();
System.out.println();
System.out.print("排序结果：");
for (int i = 0; i < n; i++) {
System.out.print(s_array[i] + " ");
}
System.out.println();
System.out.println("选择排序法用时为：" + (end - begin));
System.out.println("选择排序法比较次数为：" + (n * (n - 1)) / 2);
}
}

5. 什么是排序算法的时间性能

时间性能包括关键码的比较次数和记录的移动次数，其中有一个起主导，每种都可能需要讨论最好，最坏和平均性能，一般以平均和最坏为主

6. C语言各种排序算法比较次数和运行时间的计算，改如何写，算法我已经写好了。

1. 比较次数，你加个变量比较一次统计一下不就可以了。

2. 统计运行时间

time_tbeg=clock();
InsertSort(...);
time_tend=clock();

printf("%lf
",(end-beg)/CLOCKS_PER_SEC);

应该是要加头文件<time.h>

7. 排序算法时间

计算一个算法所消耗的时间是没有意义的，因为一个算法所用的时间不仅仅取决于算法本身，还与实现算法所使用的编程语言，输入的数据，执行算法的的硬件环境等等密切相关。
所以，一般地，我们用算法的时间复杂度（有时还要考虑空间复杂度）来衡量一个算法的好坏。计算时间复杂度是建立在执行算法中任何一个指令所消耗的时间相同的假设之上的，所以只是对算法性能的一个参考。
下面我给出常见的几种排序算法的时间复杂度：
排序法 时间复杂度
冒泡排序 O(n^2)
快速排序 O(n*log2n)
选择排序 O(n^2)
二叉树排序 O(n*log2n)
插入排序 O(n^2)
堆排序 O(n*log2n)

8. 数据结构实验算法排序实验问题..

测试时间可以用GetCurrentTime()函数。返回的时间单位为毫秒（ms）
比如 你有一个函数func();你要测它的执行时间可以这么写。
int t1 = GetCurrentTime();
func();
int t2 = GetCurrentTime();
printf("执行时间为%d (ms)",t2-t1);

至于流程，你可以先把各个排序算法的写出来，然后给一组（如果你觉得不过瘾可以多给几组，或者随机生成几组）数组，分别跑一下你的算法，用我上面的方法测时间，输出来就行了。

9. 数据结构课程设计－内部排序算法时间的比较

用系统计时器算时间复杂度。
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#define LIST_INIT_SIZE 50000
int bj1,yd1,n;
clock_t start_t,end_t;
typedef struct
{
int key;
}ElemType;
typedef struct
{
ElemType *elem;
int length;
}SqList;
void addlist(SqList &L)
{
int i;
a: printf("请输入你要输入的个数:");
scanf("%d",&n);
if(n>50000)
{
printf("超出范围重新输入!!!\n");
goto a;
}
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)exit(0);
L.length=0;
for(i=1;i<n+1;i++)
{
b: L.elem[i].key=rand();
if(L.elem[i].key>30000)goto b;
++L.length;
}
}
void SelectSort(SqList &L)//选择
{
start_t=clock();
int i,j,k,bj=0,yd=0;
for(i=1;i<L.length;i++)
{
k=i;
for(j=i+1;j<L.length;j++)
{
bj++;
if(L.elem[j].key<L.elem[k].key)k=j;
}
if(i!=k)
{
L.elem[0].key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem[0].key;
yd+=3;
}
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void qipao(SqList &L)//起泡
{
start_t=clock();
int i=1,j,bj=0,yd=0;
while(i<L.length)
{
for(j=1;j<L.length;j++)
{
bj++;
if(L.elem[j].key>L.elem[j+1].key)
{
L.elem[0].key=L.elem[j].key;
L.elem[j].key=L.elem[j+1].key;
L.elem[j+1].key=L.elem[0].key;
yd+=3;
}
}
i++;
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void InsertSort(SqList &L)//直接插入
{
start_t=clock();
int i,j,yd=0,bj=0;
for(i=2;i<=L.length;i++)
{
if(L.elem[i].key<L.elem[i-1].key)
{
L.elem[0].key=L.elem[i].key;
yd++;
j=i-1;
bj++;
while(L.elem[0].key<L.elem[j].key)
{
L.elem[j+1].key=L.elem[j].key;
j--;
yd++;
bj++;
}
L.elem[j+1].key=L.elem[0].key;
yd++;
}
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void xier(SqList &L)//希尔
{
start_t=clock();
int i,d=L.length/2,j,w=0,k,yd=0,bj=0;
while(w<d)
{
w=1;
for(i=w;i<L.length;i=i+d)
{
k=i;
for(j=i+d;j<L.length;j=j+d)
{
if(L.elem[i].key>L.elem[j].key)
{
k=j;
bj++;
}
}
if(i!=k)
{
L.elem[0].key=L.elem[i].key;
L.elem[i].key=L.elem[k].key;
L.elem[k].key=L.elem[0].key;
yd+=3;
}
w++;
}
d=d/2;
w=1;
}
end_t=clock();
printf("比较次数为 %d移动次数为 %d\n",bj,yd);
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}

void BeforeSort()
{
yd1=0,bj1=0;
}
void display(int m,int n)
{
printf("比较次数为 %d移动次数为 %d\n",m,n);
}
int Partition(SqList &L,int low,int high)//快速排序
{
int pivotkey;
L.elem[0]=L.elem[low];
yd1++;
pivotkey=L.elem[low].key;
while (low<high)
{
yd1++;
while(low<high&&L.elem[high].key>=pivotkey)
--high;
L.elem[low]=L.elem[high];
bj1++;
yd1++;
while (low<high&&L.elem[low].key<=pivotkey)
++low;
L.elem[high]=L.elem[low];
bj1++;
yd1++;
}
L.elem[low]=L.elem[0];
yd1++;
return low;
}
void QSort(SqList &L,int low,int high)
{
int pivotloc;
if(low<high)
{
pivotloc=Partition(L,low,high);
QSort(L,low,pivotloc-1);
QSort(L,pivotloc+1,high);
}
}
void QuickSort(SqList &L)
{
start_t=clock();
BeforeSort();
QSort(L,1,L.length);
display(yd1,bj1);
end_t=clock();
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void Merge(ElemType R[],ElemType R1[],int low,int m,int high)//归并
{
int i=low, j=m+1, k=low;
while(i<=m&&j<=high)
{
if(R[i].key<=R[j].key)
{
bj1++;
R1[k]=R[i];
yd1++;
i++;
k++;
}
else
{
bj1++;
R1[k]=R[j];
yd1++;
j++;
k++;
}
}
while(i<=m)
{
R1[k]=R[i];
yd1++;
i++;
k++;
}
while(j<=high)
{
R1[k]=R[j];
yd1++;
j++;
k++;
}
}
void MergePass(ElemType R[],ElemType R1[],int length, int n)
{
int i=0,j;
while(i+2*length-1<n)
{
Merge(R,R1,i,i+length-1,i+2*length-1);
i=i+2*length;
}
if(i+length-1<n-1)
Merge(R,R1,i,i+length-1,n-1);
else
for(j=i;j<n;j++)
R1[j]=R[j];
}
void MSort(ElemType R[],ElemType R1[],int n)
{
int length=1;
while (length<n)
{
MergePass(R,R1,length,n);
length=2*length;
MergePass(R1,R,length,n);
length=2*length;
}
}
void MergeSort(SqList &L)
{
start_t=clock();
BeforeSort();
MSort(L.elem,L.elem,L.length);
display(yd1,bj1);
end_t=clock();
printf("排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}

void main()
{
SqList L;
addlist(L);
printf("起泡排序: \n");
qipao(L);
addlist(L);
printf("直插排序: \n");
InsertSort(L);
addlist(L);
printf("选择排序: \n");
SelectSort(L);
addlist(L);
printf("希尔排序: \n");
xier(L);
addlist(L);
printf("快速排续: \n");
QuickSort(L);
addlist(L);
printf("归并排序: \n");
MergeSort(L);
}

10. 如何在c排序算法中加入时间测试

开始结束都加上获取时间，然后做差。