算法时间比较

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define maxn 100000

    typedef struct {
        int data;
        struct node*pri,*next;
    }node;

void swap(node *p,node*q);
void bubbleSort(int num[]);
node* createDulNode(int *a,int n);
void  quickSort(node *left,node *right);
void  outPutLink(node *left,node * right);
void outPutArr(int a[],int len);


clock_t start,stop;

int main() {
    srand((unsigned)time(NULL))  ;
    int a[maxn];

    for (int i = 0; i < maxn; ++i) {
        a[i]=rand();
    }


    node *head=createDulNode(a,maxn);
  //  printf("before quicksort");
    //outPutLink(head->next,head->pri);
    start=clock();
    quickSort(head->next,head->pri);
    stop=clock();
   // printf("after quicksort");
   // outPutLink(head->next,head->pri);
    printf("span time is %fs
",(double)(stop-start)/CLK_TCK);
    outPutLink(head->next,head->pri);


//   printf("before bubblesort");
//   outPutArr(a,maxn);
//    start=clock();
//    bubbleSort(a);
//    stop=clock();
//    //printf("span time is %fs
",(double)(stop-start)/CLK_TCK);
//    printf("after bubblesort");
//    outPutArr(a,maxn);




    return 0;
}
//one:bubbleSort
//o(n^2)
void bubbleSort(int num[]) {
    for (int j = 0; j < maxn; ++j) {
        for (int i = j+1; i < maxn; ++i) {
            if(num[i]<num[j]){
                int tmp=num[i];
                num[i]=num[j];
                num[j]=tmp;
            }
        }
    }
}

//two:quickSort,o(nlgn)
void  quickSort(node *left,node *right){
 if(left->pri!=right){
     node *tmp=right;
     node *p=left->pri;
     node *q=left;
     while(q!=right){

         if(q->data<tmp->data){
             p=p->next;
             swap(p,q);

         }
         q=q->next;
     }
     p=p->next;
     swap(p,tmp);
     quickSort(left,p->pri);
     quickSort(p->next,right);
 }
}
node* createDulNode(int *a,int n){
    node *head=(node*)malloc(sizeof(node));
    head->next=NULL;
    head->pri=NULL;

    node *p=head;
    int i=0;
    node *q=NULL;
    while(i<n){
        q= (node*)malloc(sizeof(node));
        q->data=a[i];
        q->next=p->next;
        q->pri=p;
        p->next=q;
        p=q;
        i++;
    }
    q->next=head;
    head->pri=q;
    return head;
}
void swap(node *p,node*q){
    node tmp=*p;
    tmp.next=q->next;
    tmp.pri=q->pri;
    q->next=p->next;
    q->pri=p->pri;
    *p=*q;
    *q=tmp;
}
void  outPutLink(node *left,node * right){
    node *p=left;
    while(p!=right){
        printf("%d
",p->data);
        p=p->next;
    }
    printf("%d",right->data);
}
void outPutArr(int a[],int len){
    int cnt=0;

    while(cnt<len){
        printf("%d
",a[cnt]);
        cnt++;
    }
}

linkTest:

maxn=100000 

maxn=10000

maxn=1000

arrSort:maxn=1000

 

maxn=10000

maxn=100000