void runTests(void) {
testNewHeap();
testFindLargestChild();
testDelete();
testInsert();
testSort();
}
void testDbSorts(struct htmlPage *dbPage, char *org, char *db,
char *accColumn, struct slName *geneList)
/* Test on one database. */
{
struct htmlPage *emptyConfig;
struct htmlFormVar *sortVar = htmlFormVarGet(dbPage->forms, orderVarName);
struct slName *gene, *sort;
uglyf("testDbSorts %s %s\n", org, db);
if (sortVar == NULL)
errAbort("Couldn't find var %s", orderVarName);
emptyConfig = emptyConfigPage(dbPage, org, db);
if (emptyConfig != NULL)
{
for (sort = sortVar->values; sort != NULL; sort= sort->next)
{
for (gene = geneList; gene != NULL; gene = gene->next)
{
testSort(emptyConfig, org, db, sort->name, gene->name, accColumn);
}
}
htmlPageFree(&emptyConfig);
}
}
int test2() {
testSort();
return 0;
}
int main(int argc, char* argv[])
{
//printf("Hello World!\n");
int i=0;
int digit;
int tmp;
int *m_array =(int *)malloc(sizeof(int)*LENGTH);
int *m_array_out =(int *)malloc(sizeof(int)*LENGTH);
if (m_array==0 || m_array_out==0)
{
printf("内存空间不够%d字节\n",LENGTH);
return 0;
}
else
{
for (i=0;i<LENGTH;i++)
{
m_array[i]=rand()%LENGTH;
//m_array[i]=LENGTH-i;
//m_array[i]=i;
//printf("%d ",m_array[i]);
}
//selectSort(m_array,LENGTH);
//mergeSort(m_array,LENGTH);
//quickSort(m_array,LENGTH);
//heapSort(m_array,LENGTH);
//quickSort2(m_array,LENGTH);
//tailRecurQuickSort(m_array,LENGTH);
//randQuickSort(m_array,LENGTH);
//countingSort(m_array,LENGTH,LENGTH-1,m_array_out);
tmp=LENGTH-1;
digit=0;
while (tmp>0)
{
tmp=tmp>>4;
digit++;
}
radixSort(m_array,LENGTH,digit,m_array_out);
// printf("\n");
// for (i=0;i<LENGTH;i++)
// {
// printf("%d ",m_array[i]);
// }
// printf("\n");
testSort(m_array,LENGTH);
//testSort(m_array_out,LENGTH);
// for (i=0;i<LENGTH;i++)
// {
// printf("binarySearch idx: %d\n",binarySearch(m_array,LENGTH,m_array[i]));
// }
// printf("binarySearch idx: %d\n",binarySearch(m_array,LENGTH,-11));
free(m_array);
free(m_array_out);
return 0;
}
}
void testObj::test<4>(void)
{
testSort(30,30,10,10);
}
void testObj::test<3>(void)
{
testSort(20,30,40,10);
}
void testObj::test<2>(void)
{
testSort(40,30,20,10);
}
void testObj::test<1>(void)
{
testSort(10,20,30,40);
}
int main(int argc, char * argv[]) {
char *USAGE = "\n Incorrect usage. Use must be one of:\n\n"
" $ ./run -t # to run test suite\n\n"
" $ ./run -b # to run benchmarks\n\n"
" or\n\n"
" $ ./run -t -b # to run both\n\n";
if(argc<2 || argc>3) {
printf("%s", USAGE);
return 0;
}
int testBool = 0;
int benchmarkBool = 0;
int c;
extern char *optarg;
extern int optind, optopt;
while ((c = getopt(argc, argv, "tb")) != -1) {
switch(c) {
case 't':
++testBool;
break;
case 'b':
++benchmarkBool;
break;
}
}
struct {
sortFun fun;
char * name;
} funs[] = { \
// {bubbleSort, "bubblesort"}, \ // Simply too slow to benchmark...
{quickSort, "quicksort "}, \
{qsort, "stdlib qsort"}, \
{mergeSort, "mergesort "}, \
{heapSort, "heapsort "}};
if(testBool) {
// UNIT TESTING
printf("\n");
size_t i;
for(i=0; i<sizeof(funs)/sizeof(funs[0]); ++i) {
testSort(funs[i].fun, funs[i].name);
}
printf("\n");
}
if(benchmarkBool) {
// BENCHMARKING
unsigned int NUMTRIALS = 10;
unsigned int ARRAYSIZE = 200000;
// Build shuffled array
char *shuffled = malloc(ARRAYSIZE * sizeof(char));
size_t i;
for(i=0; i<ARRAYSIZE; ++i) {
shuffled[i] = (char) rand() % 254 - 127;
}
size_t j;
for(i=0; i<sizeof(funs)/sizeof(funs[0]); ++i) {
printf("Benchmarking %s algorithm on shuffled array of %u chars (%u trials), best time: ", \
funs[i].name, ARRAYSIZE, NUMTRIALS);
struct timespec startTime;
struct timespec endTime;
unsigned long thisTime;
unsigned long bestTime = INT_MAX;
for(j=0; j<NUMTRIALS; ++j) {
char *_shuffled = malloc(ARRAYSIZE * sizeof(char));
copy(_shuffled, shuffled, ARRAYSIZE * sizeof(char));
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &startTime);
funs[i].fun(_shuffled, ARRAYSIZE, sizeof(char), cmpChar);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &endTime);
free(_shuffled);
thisTime = 1000000000*(endTime.tv_sec - startTime.tv_sec) + (endTime.tv_nsec - startTime.tv_nsec);
bestTime = thisTime<bestTime ? thisTime : bestTime;
}
printf ("%lu nanoseconds\n", bestTime);
}
printf("\n");
// Build sorted array
char *sorted = malloc(ARRAYSIZE * sizeof(char));
copy(sorted, shuffled, ARRAYSIZE * sizeof(char));
qsort(sorted, ARRAYSIZE, sizeof(char), cmpChar);
for(i=0; i<sizeof(funs)/sizeof(funs[0]); ++i) {
printf("Benchmarking %s algorithm on sorted array of %u chars (%u trials), best time: ", \
funs[i].name, ARRAYSIZE, NUMTRIALS);
struct timespec startTime;
struct timespec endTime;
unsigned long thisTime;
unsigned long bestTime = INT_MAX;
for(j=0; j<NUMTRIALS; ++j) {
char *_sorted = malloc(ARRAYSIZE * sizeof(char));
copy(_sorted, sorted, ARRAYSIZE * sizeof(char));
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &startTime);
funs[i].fun(_sorted, ARRAYSIZE, sizeof(char), cmpChar);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &endTime);
free(_sorted);
thisTime = 1000000000*(endTime.tv_sec - startTime.tv_sec) + (endTime.tv_nsec - startTime.tv_nsec);
bestTime = thisTime<bestTime ? thisTime : bestTime;
}
printf ("%lu milliseconds\n", bestTime);
}
printf ("\n");
free(shuffled);
free(sorted);
}
return 0;
}
