随机生成50000个数，分别用冒泡排序、快速排序、堆排序、选择排，在VS2019上,C++运行时间比较

#include<iostream>
#include <time.h>
#include<assert.h>
#define N 50000
using namespace std;

clock_t start, stop;     //clock_t是clock（）函数返回的变量类型
double duration;


//冒泡排序
void sort1(int a[], int n)
{
	int i, j, temp, m = 0;
	int flag;
	for (i = 0; i < n - 1; i++)
	{
		flag = 0;
		for (j = n - 1; j > i; j--)
		{
			if (a[j - 1] > a[j])
			{
				temp = a[j - 1];
				a[j - 1] = a[j];
				a[j] = temp;
				flag = 1;
			}
		}
		if (flag == 0)break;
	}
}

//快速排序
int partition(int arr[], int left, int right)  //找基准数 划分
{
    int i = left + 1;
    int j = right;
    int temp = arr[left];

    while (i <= j)
    {
        while (arr[i] < temp)
        {
            i++;
        }
        while (arr[j] > temp)
        {
            j--;
        }
        if (i < j)
            swap(arr[i++], arr[j--]);
        else i++;
    }
    swap(arr[j], arr[left]);
    return j;

}

void quick_sort(int arr[], int left, int right)
{
     if (left > right)
         return;
     int j = partition(arr, left, right);
    quick_sort(arr, left, j - 1);
    quick_sort(arr, j + 1, right);
}

//堆排序
void AdjustDown(int a[], size_t n, int root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}
		if (a[child] > a[parent])
		{
			swap(a[child], a[parent]);
			parent = child;;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int a[], size_t n)
{
	assert(a);
	int parent = (n - 2) >> 1;
	//建堆
	for (; parent >= 0; --parent)
	{
		AdjustDown(a, n, parent);
	}
	for (int i = n - 1; i >= 0; --i)
	{
		swap(a[0], a[i]);
		AdjustDown(a, i, 0);
	}
}
//选择排序
void selectSort(int a[], int len)
{

	int minindex, temp;
	for (int i = 0; i < len - 1; i++)
	{
		minindex = i;
		for (int j = i + 1; j < len; j++)
		{
			if (a[j] < a[minindex])
				minindex = j;

		}
		temp = a[i];
		a[i] = a[minindex];
		a[minindex] = temp;
	}
}

int main()
{
	int i, j, temp, m = 0;
	int a[N];
	cout << "生成"<< N<< "个随机数"<< endl<<endl;
	for (i = 0; i < N; i++)
	{
		a[i] = rand() % N;
		/*printf("%5d",a[i]);
		m++;
		if (m %10==0)printf("\n");*/
	}

	
	start = clock();
	sort1(a, N);
	stop = clock();
	//CLOCKS_PER_SEC是一个常数，表示机器时钟每秒所走的时钟打点数，有的IDE下叫CLK_TCK
	duration = (double)(stop - start) / CLOCKS_PER_SEC;
	cout<<"冒泡排序运行时间是："<< duration<<"秒"<<endl << endl;

	for (i = 0; i < N; i++)
		a[i] = rand() % N;
	start = clock();
	quick_sort(a , 0, N);
	stop = clock();
	//CLOCKS_PER_SEC是一个常数，表示机器时钟每秒所走的时钟打点数，有的IDE下叫CLK_TCK
	duration = (double)(stop - start) / CLOCKS_PER_SEC;
	cout << "快速排序运行时间是：" << duration <<"秒" << endl << endl;

	start = clock();
	HeapSort(a, N);
	stop = clock();
	//CLOCKS_PER_SEC是一个常数，表示机器时钟每秒所走的时钟打点数，有的IDE下叫CLK_TCK
	duration = (double)(stop - start) / CLOCKS_PER_SEC;
	cout << "堆排序运行时间是：" << duration << "秒"<< endl << endl;

	for (i = 0; i < N; i++)
		a[i] = rand() % N;
	start = clock();
	selectSort(a, N);
	stop = clock();
	//CLOCKS_PER_SEC是一个常数，表示机器时钟每秒所走的时钟打点数，有的IDE下叫CLK_TCK
	duration = (double)(stop - start) / CLOCKS_PER_SEC;
	cout << "选择排序运行时间是：" << duration << "秒"<< endl << endl;

	return 0;
}

Debug模式下

Release模式下

结果显示，以上4种排序算法，对50000个随机速排序，堆排序效率最高，冒泡排序耗时最长。