linux中的测用时函数

最新推荐文章于 2024-06-07 21:37:00 发布

原创最新推荐文章于 2024-06-07 21:37:00 发布 · 634 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#linux #list #pivot #null #algorithm #less

有关linux ubuntu 专栏收录该内容

23 篇文章

订阅专栏

本文介绍了一个使用C语言实现的快速排序算法，并通过实际测试评估了其性能表现。该程序能够生成一个指定长度的随机整数列表，并利用快速排序算法进行排序，同时记录排序所需的时间。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#define MAX_LENGTH 100
/*Show usage*/
void usage(char * prog)
{
        printf("%s Usage:\n", prog);
        printf("%s <the count of numbers to sort (should be less than 100)>\n", prog);
}
/*Generate and initialize the list*/
int * generate_list(int count)
{
        int i;
        int * list;
        list = (int *)malloc(count*sizeof(int));
        if(list == NULL)
        {
                perror("malloc");
                return NULL;
        }
        /*Initialize the list with integers less than 100*/
        srandom((unsigned int)time(NULL));
        for (i  = 0; i < count ; i ++)
                list[i] = random()%100;
        return list;
}
/*Show the list*/
void show_list(int * list, int length)
{
        int i;
        for(i = 0; i < length; i ++)
                printf("%d      ", list[i]);
        printf("\n");
}
/*algorithm*/
int partition(int * list, int first, int last)
{
        int left = first;
        int right = last;
        int pivot = list[left];//靠靠靠?
        while(left < right)//靠靠靠靠靠靠
        {
                while((right > left) && (list[right] >= pivot))
                        right --;//靠靠?
                if(left < right)
                {
                        list[left] = list[right];//靠靠靠?
                        left ++;
                }
                while((left < right) && (list[left] < pivot))
                        left ++;//靠靠?
                if(left < right)
                {
                        list[right] = list[left];//靠靠靠?
                        right --;
                }
        }
        list[left] = pivot;//靠靠靠?
        return left;
}
void quick_sort(int * list, int first, int last)
{
        if(first < last)//靠靠1
        {
                int split = partition(list, first, last);
			//縧ist靠靠
                quick_sort(list, first, split-1);//靠靠靠靠縮plite靠靠靠
                quick_sort(list, split +1, last);//靠靠靠靠
        }
        return;
}
int main(int argc, char * argv[])
{
        int length;
        int * list = NULL;
        struct timeval tpstart,tpend;
        float timeuse;
        /*Deal with the arguments*/
        if(argc != 2)
        {
                usage(argv[0]);
                exit(127);
        }
        length = atoi(argv[1]);
        if(!length || length > MAX_LENGTH)
        {
                usage(argv[0]);
                exit(129);
        }
        list = generate_list(length);
        if(list == NULL)
                exit(128);
        else
        {
                printf("Soruce list:\n");
                show_list(list, length);
                gettimeofday(&tpstart,NULL);
                quick_sort(list, 0, length -1);
                gettimeofday(&tpend,NULL);
                printf("Ordered list:\n");
                show_list(list, length);
                timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+ tpend.tv_usec-tpstart.tv_usec;
                timeuse/=1000;
                printf("quick_sort time used: %f msec\n", timeuse);
        }
        free(list);
        return 1;
}