各种排序算法的时间性能比较

#include<iostream>

#include<time.h>

using namespace std;

/**冒泡排序

原理：

1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。

2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就"沉"到数组第N-1个位置。

3．N=N-1，如果N不为0就重复前面二步，否则排序完成。

*/

void BubbleSort(int [], int n);

void BubbleSort(int a[], int n)

{
int j, k;
int flag;
int temp;

flag = n;
while (flag > 0)
{
k = flag;
flag = 0;
for (j = 1; j < k; j++)
if (a[j - 1] > a[j])
{
temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
flag = j;
}
}

}
/**直接插入排序

原理：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。

1. 初始时，a[0]自成1个有序区，无序区为a[1..n-1]。令i=1

2. 将a[i]并入当前的有序区a[0…i-1]中形成a[0…i]的有序区间。

3.  i++并重复第二步直到i==n-1。排序完成。

*/

void Insertsort(int a[], int n);

void Insertsort(int a[], int n)

{
int i, j;
for (i = 1; i < n; i++)
if (a[i] < a[i - 1])
{
int temp = a[i];
for (j = i - 1; j >= 0 && a[j] > temp; j--)
a[j + 1] = a[j];
a[j + 1] = temp;
}

}
/**直接选择排序

原理：直接选择排序和直接插入排序类似，都将数据分为有序区和无序区

所不同的是直接播放排序是将无序区的第一个元素直接插入到有序区以形成一个更大的有序区

而直接选择排序是从无序区选一个最小的元素直接放到有序区的最后。

 

设数组为a[0…n-1]。

1. 初始时，数组全为无序区为a[0..n-1]。令i=0

2. 在无序区a[i…n-1]中选取一个最小的元素，将其与a[i]交换。交换之后a[0…i]就形成了一个有序区。

3. i++并重复第二步直到i==n-1。排序完成。

*/

void Selectsort(int a[], int n);

void Selectsort(int a[], int n)

{
int i, j, nMinIndex;
int temp;
for (i = 0; i < n; i++)
{
nMinIndex = i; //找最小元素的位置
for (j = i + 1; j < n; j++)
if (a[j] < a[nMinIndex])
nMinIndex = j;

 
   //将这个元素放到无序区的开头
temp = a[i];
a[i] = a[nMinIndex];
a[nMinIndex] = temp;
}

}
/**希尔排序

原理：将需要排序的序列划分成为若干个较小的子序列，对子序列进行插入排序，

通过则插入排序能够使得原来序列成为基本有序。这样通过对较小的序列进行插入排序，

然后对基本有序的数列进行插入排序，能够提高插入排序算法的效率。

*/

void ShellSort(int [],int length);

void ShellSort(int array[],int length)

{

     int d = length/2;   //设置希尔排序的增量

     int i ;

     int j;

     int temp;

     while(d>=1)

     {

         for(i=d;i<length;i++)

           {

               temp=array[i];

               j=i-d;

               while(j>=0 && array[j]>temp)

               {

                array[j+d]=array[j];

                j=j-d;

               }

                array[j+d] = temp;

           }

                d= d/2;    //缩小增量

    }

}
/**快速排序

原理：1．先从数列中取出一个数作为基准数。
 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
 3．再对左右区间重复第二步，直到各区间只有一个数。

*/

void QuickSort(int [], int, int);

void QuickSort(int s[], int l, int r)

{

    if (l < r)

    {

        int i = l, j = r, x = s[l];

        while (i < j)

        {

            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
j--;  

            if(i < j) 
s[i++] = s[j];

            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
i++;  

            if(i < j) 
s[j--] = s[i];

        }

        s[i] = x;

        QuickSort(s, l, i - 1); // 递归调用 

        QuickSort(s, i + 1, r);

    }

}
/**归并排序

原理：其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，

那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，

可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了

这样通过先递归的分解数列，再合并数列就完成了归并排序。

*/

void mergesort(int a[], int first, int last, int temp[]);

void mergearray(int a[], int first, int mid, int last, int temp[]);

void MergeSort(int a[], int n)

{
int *pTempArray = new int
;
mergesort(a, 0, n - 1, pTempArray);

}

void mergesort(int a[], int first, int last, int temp[])

{
if (first < last)
{
int mid = (first + last) / 2;
mergesort(a, first, mid, temp);    //左边有序
mergesort(a, mid + 1, last, temp); //右边有序
mergearray(a, first, mid, last, temp); //再将二个有序数列合并
}

}

//将有二个有序数列a[first...mid]和a[mid...last]合并。

void mergearray(int a[], int first, int mid, int last, int temp[])

{
int i = first, j = mid + 1;
int m = mid,   n = last;
int k = 0;

while (i <= m && j <= n)
{
if (a[i] < a[j])
temp[k++] = a[i++];
else
temp[k++] = a[j++];
}

while (i <= m)
temp[k++] = a
c658
[i++];

while (j <= n)
temp[k++] = a[j++];

for (i = 0; i < k; i++)
a[first + i] = temp[i];

}

//显示排序结果

void display(int []);

void display(int a[],int n)

{
int i=0;
for(;i<n;i++)
cout<<a[i]<<" ";
cout<<endl;

}

int main()

{
/*int array[10];
int i=0;
int size = sizeof(array)/sizeof(int);

for(;i<size;i++)cin>>a[i];*/

//BubbleSort(array,size);          //冒泡排序
//Insertsort(array,size);         //直接插入排序
//Selectsort(array,size);        //直接选择排序
//ShellSort(array,size);        //希尔排序
//QuickSort(array,0,size-1);    //快速排序
//MergeSort(array,size);      //归并排序

/*计算排序时间*/

/*1.Time函数
time_t startTime,endTime;
double useTime;
*/

//2.clock函数
clock_t starttime, endtime;

    double totaltime;

    

/*测试一万个数据*/
int a[10000];
for(int j=0;j<10000;j++)
{
int m = rand();
a[j] = m;
}
int size = sizeof(a)/sizeof(int);

//startTime = time(NULL);
starttime = clock();
BubbleSort(a,size);          //冒泡排序
//Insertsort(a,size);         //直接插入排序
//Selectsort(a,size);        //直接选择排序
//ShellSort(a,size);        //希尔排序
//QuickSort(a,0,size-1);   //快速排序
//MergeSort(a,size);      //归并排序
endtime = clock();
totaltime = (double)( (endtime - starttime)/(double)CLOCKS_PER_SEC );   //转换为s<秒>
//endTime = time(NULL);
//display(a,size);
//useTime = difftime( startTime, endTime);
cout<<totaltime*1000<<"ms"<<endl;         //微秒
return 0;

}