排序演算法測量時間

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排序演算法中加入時間測試

開始結束都加上獲取時間，然後做差。