我需要用c++写选择排序、冒泡排序、合并排序、快速排序、插入排序算法，以待排序数组的大小n为输入规模，固定n，随机产生20组测试样本，统计不同排序算法在20个样本上的平均运行时间；

好的，我可以回答这个问题。以下是各种排序算法的 C 代码实现：

选择排序：

void selectionSort(int arr[], int n) {
int i, j, min_idx;
for (i = ; i < n-1; i++) {
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
swap(&arr[min_idx], &arr[i]);
}
}

冒泡排序：

void bubbleSort(int arr[], int n) {
int i, j;
for (i = ; i < n-1; i++)
for (j = ; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(&arr[j], &arr[j+1]);
}

合并排序：

void merge(int arr[], int l, int m, int r) {
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = ; i < n1; i++)
L[i] = arr[l + i];
for (j = ; j < n2; j++)
R[j] = arr[m + 1+ j];
i = ;
j = ;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r) {
if (l < r) {
int m = l+(r-l)/2;
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}

快速排序：

int partition (int arr[], int low, int high) {
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high- 1; j++) {
if (arr[j] <= pivot) {
i++;
swap(&arr[i], &arr[j]);
}
}
swap(&arr[i + 1], &arr[high]);
return (i + 1);
}
void quickSort(int arr[], int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}

插入排序：

void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;
while (j >= && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}

统计不同排序算法在20个样本上的平均运行时间，可以使用 clock() 函数来计时。具体实现可以参考以下代码：

int main() {
int n = 100; // 待排序数组的大小
int arr[n];
srand(time(NULL));
for (int i = ; i < n; i++)
arr[i] = rand() % 100; // 随机产生待排序数组
int num_tests = 20; // 测试样本数量
double time_taken[num_tests][5]; // 存储每个排序算法的运行时间
for (int i = ; i < num_tests; i++) {
// 复制待排序数组
int arr_copy[n];
memcpy(arr_copy, arr, n * sizeof(int));
// 选择排序
clock_t t;
t = clock();
selectionSort(arr_copy, n);
t = clock() - t;
time_taken[i][] = ((double)t)/CLOCKS_PER_SEC;
// 冒泡排序
memcpy(arr_copy, arr, n * sizeof(int));
t = clock();
bubbleSort(arr_copy, n);
t = clock() - t;
time_taken[i][1] = ((double)t)/CLOCKS_PER_SEC;
// 合并排序
memcpy(arr_copy, arr, n * sizeof(int));
t = clock();
mergeSort(arr_copy, , n-1);
t = clock() - t;
time_taken[i][2] = ((double)t)/CLOCKS_PER_SEC;
// 快速排序
memcpy(arr_copy, arr, n * sizeof(int));
t = clock();
quickSort(arr_copy, , n-1);
t = clock() - t;
time_taken[i][3] = ((double)t)/CLOCKS_PER_SEC;
// 插入排序
memcpy(arr_copy, arr, n * sizeof(int));
t = clock();
insertionSort(arr_copy, n);
t = clock() - t;
time_taken[i][4] = ((double)t)/CLOCKS_PER_SEC;
}
// 计算平均运行时间
double avg_time[5] = {};
for (int i = ; i < num_tests; i++)
for (int j = ; j < 5; j++)
avg_time[j] += time_taken[i][j];
for (int j = ; j < 5; j++)
avg_time[j] /= num_tests;
// 输出结果
printf("选择排序平均运行时间: %f\n", avg_time[]);
printf("冒泡排序平均运行时间: %f\n", avg_time[1]);
printf("合并排序平均运行时间: %f\n", avg_time[2]);
printf("快速排序平均运行时间: %f\n", avg_time[3]);
printf("插入排序平均运行时间: %f\n", avg_time[4]);
return ;
}