利用C语言写出插入排序，冒泡排序，选择排序，以及快速排序，然后根据排序时间做出一个Excel图表

[vic_duan]

分别编写算法实现插入排序，冒泡排序，选择排序，以及快速排序，利用随机函数在一文件中分别产生500个记录，5000个记录，20000个记录，统计出每种排序方法消耗的时间，然后以Excel图表的方式（柱形图）表现，然后生成一个报告。
求解。。。。。。。。。

[jackyjkchen]

前面的排序和统计都不难，生成excel报告得用com了，因为不是表格形式的，不能用odbc操作excel来偷懒了

[vic_duan]

分别编写算法实现插入排序，冒泡排序，选择排序，以及快速排序，利用随机函数在一文件中分别产生500个记录，5000个记录，20000个记录 只要这几记录所需的时间

[pathuang68]

4种排序算法如下，是哥自己为了练手现写的，供你参考：

/* 1. 插入排序 */
void insertion_sort(int* arr, int n)
{
	int key;
	int i;
	int j;

	for(i = 1; i < n; ++i)
	{
		key = *(arr + i);
		j = i - 1;
		while(j >= 0 && *(arr + j) > key)
		{
			*(arr + j + 1) = *(arr + j);
			--j;
		}
		*(arr + j + 1) = key;
	}
}

/* 2. 冒泡排序 */
void bubble_sort(int* arr, int n)
{
	int key;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 1; j < n - i; ++j)
		{
			if(*(arr + j) < *(arr + j - 1))
			{
				key = *(arr + j);
				*(arr + j) = *(arr + j - 1);
				*(arr + j - 1) = key;
			}
		}
	}
}

/* 3. 选择排序 */
void selection_sort(int* arr, int n)
{
	int key;
	int pos;
	for(int i = 0; i < n; ++i)
	{
		key = *(arr + i);
		pos = i;
		for(int j = i; j < n; ++j)
		{
			if(*(arr + j) < key)
			{
				key = *(arr + j);
				pos = j;
			}
		}
		*(arr + pos) = *(arr + i);
		*(arr + i) = key;
	}
}

/* 4. 快速排序 */
int partition(int* arr, int first, int end)
{
	int key;
	int i = first;
	int j = end;

	while(i < j)
	{
		while(i < j && *(arr + i) < *(arr + j))
		{
			--j;
		}

		if(i < j)
		{
			key = *(arr + i);
			*(arr + i) = *(arr + j);
			*(arr + j) = key;

			++i;
		}

		while(i < j && *(arr + i) < *(arr + j))
		{
			++i;
		}

		if(i < j)
		{
			key = *(arr + j);
			*(arr + j) = *(arr + i);
			*(arr + i) = key;

			--j;
		}
	}
	return i;
}

void intermediate_quick_sort(int* arr, int first, int end)
{
	if(first < end)
	{
		int pivot = partition(arr, first, end);
		intermediate_quick_sort(arr, first, pivot - 1);
		intermediate_quick_sort(arr, pivot + 1, end);
	}
}

void quick_sort(int* arr, int n)
{
	intermediate_quick_sort(arr, 0, n - 1);
}

其它的楼主应该可以自己搞定吧。

统计数据用Excel图表显示，我的理解应该不是用程序代码实现，而是直接将统计结果的数据拷贝到Excel表格中来实现的。否则对于一个学算法的学生来说，这题目的跨度也太大了，还不如自己用代码画图更容易一些。

[pathuang68]

给你个完整的代码吧:)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <memory.h>
#include <string.h>

/* 1. 插入排序 */
void insertion_sort(int* arr, int n)
{
	int key;
	int i;
	int j;

	for(i = 1; i < n; ++i)
	{
		key = *(arr + i);
		j = i - 1;
		while(j >= 0 && *(arr + j) > key)
		{
			*(arr + j + 1) = *(arr + j);
			--j;
		}
		*(arr + j + 1) = key;
	}
}

/* 2. 冒泡排序 */
void bubble_sort(int* arr, int n)
{
	int key;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 1; j < n - i; ++j)
		{
			if(*(arr + j) < *(arr + j - 1))
			{
				key = *(arr + j);
				*(arr + j) = *(arr + j - 1);
				*(arr + j - 1) = key;
			}
		}
	}
}

/* 3. 选择排序 */
void selection_sort(int* arr, int n)
{
	int key;
	int pos;
	for(int i = 0; i < n; ++i)
	{
		key = *(arr + i);
		pos = i;
		for(int j = i; j < n; ++j)
		{
			if(*(arr + j) < key)
			{
				key = *(arr + j);
				pos = j;
			}
		}
		*(arr + pos) = *(arr + i);
		*(arr + i) = key;
	}
}

/* 4. 快速排序 */
int partition(int* arr, int first, int end)
{
	int key;
	int i = first;
	int j = end;

	while(i < j)
	{
		while(i < j && *(arr + i) < *(arr + j))
		{
			--j;
		}

		if(i < j)
		{
			key = *(arr + i);
			*(arr + i) = *(arr + j);
			*(arr + j) = key;

			++i;
		}

		while(i < j && *(arr + i) < *(arr + j))
		{
			++i;
		}

		if(i < j)
		{
			key = *(arr + j);
			*(arr + j) = *(arr + i);
			*(arr + i) = key;

			--j;
		}
	}
	return i;
}

void intermediate_quick_sort(int* arr, int first, int end)
{
	if(first < end)
	{
		int pivot = partition(arr, first, end);
		intermediate_quick_sort(arr, first, pivot - 1);
		intermediate_quick_sort(arr, pivot + 1, end);
	}
}

void quick_sort(int* arr, int n)
{
	intermediate_quick_sort(arr, 0, n - 1);
}

/* 生成测试数据文件 */
void generate_test_data()
{
	FILE* fp;
	char* data500 = "E:/data500.dat";
	char* data5000 = "E:/data5000.dat";
	char* data20000 = "E:/data20000.dat";

	fp = fopen(data500, "w");
	if(!fp)
	{
		printf("open file %s failed", data500);
		exit(1);
	}

	for(int i = 0; i < 500; ++i)
	{
		fprintf(fp, "%d\n", rand());
	}

	fclose(fp);
	
	/***********************************/
	fp = fopen(data5000, "w");
	if(!fp)
	{
		printf("open file %s failed", data5000);
		exit(1);
	}

	//srand((unsigned)time(NULL));
	for(int i = 0; i < 5000; ++i)
	{
		fprintf(fp, "%d\n", rand());
	}

	fclose(fp);
	
	/***********************************/
	fp = fopen(data20000, "w");
	if(!fp)
	{
		printf("open file %s failed", data20000);
		exit(1);
	}

	for(int i = 0; i < 20000; ++i)
	{
		fprintf(fp, "%d\n", rand());
	}

	fclose(fp);
}

void read_data(int* data500, int* data5000, int* data20000)
{
	int i = 0;
	FILE* fp;
	char line_item[20];
	
	fp = fopen("E:/data500.dat", "r");
	if(!fp)
	{
		printf("open file %s failed", data500);
		exit(1);
	}

	while(!feof(fp))
	{
		memset(line_item, 0, 20);
		fgets(line_item, 20, fp);
		int len = strlen(line_item);
		if(len == 0) break;
		line_item[len - 1] = 0;
		int temp = atoi(line_item);
		*(data500 + i++) = temp;
	}
	fclose(fp);

	/********************************/
	i = 0;
	fp = fopen("E:/data5000.dat", "r");
	if(!fp)
	{
		printf("open file %s failed", data5000);
		exit(1);
	}

	while(!feof(fp))
	{
		memset(line_item, 0, 20);
		fgets(line_item, 20, fp);
		int len = strlen(line_item);
		if(len == 0) break;
		line_item[len - 1] = 0;
		int temp = atoi(line_item);
		*(data5000 + i++) = temp;
	}
	fclose(fp);

	/********************************/
	i = 0;
	fp = fopen("E:/data20000.dat", "r");
	if(!fp)
	{
		printf("open file %s failed", data20000);
		exit(1);
	}

	while(!feof(fp))
	{
		memset(line_item, 0, 20);
		fgets(line_item, 20, fp);
		int len = strlen(line_item);
		if(len == 0) break;
		line_item[len - 1] = 0;
		int temp = atoi(line_item);
		*(data20000 + i++) = temp;
	}
	fclose(fp);
}

/* 测试代码 */
int main(int argc, char* argv[])
{
	generate_test_data();

	int* data500 = (int*)malloc(sizeof(int) * 500);
	int* data5000 = (int*)malloc(sizeof(int) * 5000);
	int* data20000 = (int*)malloc(sizeof(int) * 20000);

	clock_t start, finish;

	/* insertion sort*/
	read_data(data500, data5000, data20000);
	start = clock();
	insertion_sort(data500, 500);
	finish = clock();
	int interval_500_insertion = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(insertion 500)\n", interval_500_insertion);

	start = clock();
	insertion_sort(data5000, 5000);
	finish = clock();
	int interval_5000_insertion = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(insertion 5000)\n", interval_5000_insertion);

	start = clock();
	insertion_sort(data20000, 20000);
	finish = clock();
	int interval_20000_insertion = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(insertion 20000)\n", interval_20000_insertion);

	printf("\n");
	/* bubble sort */
	read_data(data500, data5000, data20000);
	start = clock();
	bubble_sort(data500, 500);
	finish = clock();
	int interval_500_bubble = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(bubble 500)\n", interval_500_bubble);

	start = clock();
	bubble_sort(data5000, 5000);
	finish = clock();
	int interval_5000_bubble = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(bubble 5000)\n", interval_5000_bubble);

	start = clock();
	bubble_sort(data20000, 20000);
	finish = clock();
	int interval_20000_bubble = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(bubble 20000)\n", interval_20000_bubble);

	printf("\n");
	/* selection sort */
	read_data(data500, data5000, data20000);
	start = clock();
	selection_sort(data500, 500);
	finish = clock();
	int interval_500_selection = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(selection 500)\n", interval_500_selection);

	start = clock();
	selection_sort(data5000, 5000);
	finish = clock();
	int interval_5000_selection = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(selection 5000)\n", interval_5000_selection);

	start = clock();
	selection_sort(data20000, 20000);
	finish = clock();
	int interval_20000_selection = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(selection 20000)\n", interval_20000_selection);

	printf("\n");
	/* quick sort */
	read_data(data500, data5000, data20000);
	start = clock();
	quick_sort(data500, 500);
	finish = clock();
	int interval_500_quick = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(quick 500)\n", interval_500_quick);

	start = clock();
	quick_sort(data5000, 5000);
	finish = clock();
	int interval_5000_quick = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(quick 5000)\n", interval_5000_quick);

	start = clock();
	quick_sort(data20000, 20000);
	finish = clock();
	int interval_20000_quick = (finish - start) * 1000 / CLOCKS_PER_SEC;
	printf("%d ms\t(quick 20000)\n", interval_20000_quick);

	free(data500);
	free(data5000);
	free(data20000);

	return 0;
}

[篾匠]

那几种排序算法和时间的测量都很简单的, 把测到的时间写到一个文本文件就行了, 然后操作Excel导入数据, 生成图表就行了.
没必要用程序生成Excel文件和图表, 多麻烦啊.