void signedradixsort(ForwardIterator first, ForwardIterator last) { if (last-first-1 >= 1) { //separate negative from positive values std::map<int, std::vector<signed int> > buckets; for (ForwardIterator i = first; i != last; ++i) { if (*i < 0) buckets[0].push_back(*i); else buckets[1].push_back(*i); } ForwardIterator copyfirst = first; ForwardIterator begOfpos; for (int i = 0; i < 2; ++i) { //remember where positive values begin begOfpos = copyfirst; for (std::vector<signed int>::iterator it = buckets[i].begin(); it != buckets[i].end(); ) *copyfirst++ = *it++; } //sort negative and positive subranges respectively radixsort(begOfpos, last); negradixsort(first, begOfpos); } }
void radixsort(ForwardIterator first, ForwardIterator last, int factor = 10) { if (last-first-1 >= 1) { //partitioning std::map<int, std::vector<int> > buckets; for (ForwardIterator i = first; i != last; ++i) { //'extract' the digit we want from the number and map it in the bucket if (factor == 10) buckets[*i%factor].push_back(*i); else buckets[(*i/(factor/10)) %10].push_back(*i); } //collecting ForwardIterator copyfirst = first; for (int i = 0; i < 10; ++i) { for (std::vector<int>::const_iterator it = buckets[i].begin(); it != buckets[i].end(); ) //collect and apply to range [first, last) *copyfirst++ = *it++; } //we could recurse even more, but then all values will be mapped to zero, hence there wouldn't be //any change during the collection if (factor > *std::max_element(first, last)) return; radixsort(first, last, factor *= 10); } }
int main() { int arr[MAX]; int i, n; printf("Enter total elements (n < %d) : ", MAX); scanf("%d", &n); n = n < MAX ? n : MAX; //new thing.... printf("Enter %d Elements : ", n); for (i = 0; i < n; i++) scanf("%d", &arr[i]); printf("\nARRAY : "); print(&arr[0], n); radixsort(arr, n); printf("\nSORTED : "); print(&arr[0], n); printf("\n"); return 0; }
/* how to find euler path: connect the two odd-degree nodes with dummy edge and call this algorithm */ int findeulertour() { int i,sp=0,u; static int stack[MAXE+2]; radixsort(); inverseedges(); if(!evendegree()) return 0; len=0; memset(taken,0,ne); for(u=0;u<n;u++) if(gs[u+1]>gs[u]) break; if(u==n) return 0; stack[sp++]=u; i=stack[sp++]=gs[u]; do { top: for(;i<gs[u+1];i++) if(!taken[i]) { taken[i]=taken[inv[i]]=1; stack[sp++]=u; stack[sp++]=i+1; u=to[i]; i=gs[u]; goto top; } tour[len++]=u; i=stack[--sp]; u=stack[--sp]; } while(sp); return len+len-2==ne; }
int main(int argc, const char *argv[]) { int arr[] = {32, 53, 23, 8, 92, 29, 5, 99, 24, 9}; int size = sizeof(arr) / sizeof(arr[0]); radixsort(&arr[0], size); outprint(&arr[0], size); return 0; }
int main() { int vetor[max] = {5,2,7,8,10,6,1,4,9,3}; int i; radixsort(vetor,max); for (i = 0; i < max; i++) { printf("%d ", vetor[i]); } return(0); }
int main() { int arr[100],i,n; printf("Enter no of elements :"); scanf("%d", &n); printf("\nEnter the nos : "); for (i = 0; i < n; i++) scanf("%d", &arr[i]); radixsort(arr, n); print(arr, n); return 0; }
void main(){ int n,i; printf("How many numbers do you want to sort: "); scanf("%d",&n); int rawdata[n]; printf("Start entering the elements\n"); for(i=0;i<n;i++) scanf("%d",&rawdata[i]); radixsort(rawdata,n); printf("Sorted elements are:\n"); for(i=0;i<n;i++) printf("%d\t",rawdata[i]); getch(); }
void List::tradixsort() { int np = (int)sysconf(_SC_NPROCESSORS_ONLN); if(np == 1) radixsort(); else { int t = len/np; Node *n[np+1]; Thread *radixs[np]; Node *p = node->next; n[0] = p; for(int i=1; i<np; i++) { for(int j=0;j<t;j++) p = p->next; n[i] = p; radixs[i-1] = new TRadix(n[i-1], p); } n[np] = NULL; radixs[np-1] = new TRadix(n[np-1], NULL); for(int i=0; i<np; i++) { radixs[i]->start(); } for(int i=0; i<np; i++) radixs[i]->wait(); register int j = np; while( j != 0 ) { j /= 2; TMerge *merge[j]; for(int i = 0, k = 0; k < j; i+=2, k++) { merge[k] = new TMerge(n[i], n[i+1], n[i+1], n[i+2]); merge[k]->start(); } for(int i = 0; i < j; i++) merge[i]->wait(); for(int i = 0; i <= j; i++) n[i] = n[2*i]; } } }
main() { void print(struct node a[20],int n); int creat(); void shell(struct node a[20],int n); int hoare(struct node a[20],int l,int h); void quick1(struct node a[20],int n); void quick2(struct node a[20],int l,int h); void heap(struct node a[20],int i,int m); void heapsort(struct node a[20],int n); void merges(struct node a[20],struct node a2[20],int h1,int mid,int h2); void mergepass(struct node a[20],struct node a2[20],int l,int n); void mergesort(struct node a[20],int n); int yx(int m,int i); int radixsort(struct rnode a[20],int n); int num,l,h,c; struct rnode s[20]; c=1; while(c!=0) { printf(" Ö÷²Ëµ¥ \n"); printf(" 1 ÊäÈë¹Ø¼ü×Ö£¬ÒÔ-9999±íʾ½áÊø¡£\n"); printf(" 2 Ï£¶ûÅÅÐò \n"); printf(" 3 ·ÇµÝ¹éµÄ¿ìËÙÅÅÐò \n"); printf(" 4 µÝ¹éµÄ¿ìËÙÅÅÐò \n"); printf(" 5 ¶ÑÅÅÐò \n"); printf(" 6 ¹é²¢ÅÅÐò \n"); printf(" 7 »ùÊýÅÅÐò \n"); printf(" ÊäÈëÑ¡Ôñ (1--7,0±íʾ½áÊø): "); scanf("%d",&c); switch(c) { case 1:num=creat();print(r,num);break; case 2:shell(r,num);print(r,num);break; case 3:quick1(r,num);print(r,num);break; case 4:l=0;h=num-1;quick2(r,l,h); printf("output quick2sort result:\n"); print(r,num);break; case 5:heapsort(r,num);break; case 6:mergesort(r,num);print(r,num);break; case 7:radixsort(s,num); } } }//main end
/* * exécute le tri */ void execute_tri() { int i; O1 = (ordre*) calloc(grandeur_tableau, sizeof(ordre)); for (i = 0; i < grandeur_tableau; i++) { O1[i].index_initial = i; O1[i].valeure = T1[i]; O1[i].next = NULL; } //exécute le tri selon le choix fait auparavant switch (choixTri) { case 1: mergeSort(O1, grandeur_tableau, Rang); tri = "tri fusion"; break; case 2: tri_insertion(O1, grandeur_tableau, Rang); tri = "tri par insertion"; break; case 3: radixsort(O1, grandeur_tableau, Rang); tri = "tri par base"; break; case 4: heapsort(O1, grandeur_tableau, Rang); tri = "tri par tas"; break; case 5: pigeonnier(O1, grandeur_tableau, Rang); tri = "tri par pigeonnier"; break; case 6: rapide(O1, grandeur_tableau, Rang); tri = "tri rapide"; break; default: tri = "sans tri"; break; } }
void getsuffix(){ for(int k=0;k+1<=n;k=k?k<<1:1){ memcpy(trank,rank,sizeof(rank)); for(int i=1;i<=n;++i){ trank[i].b=i+k<=n?rank[i+k].a:0; trank[i].id=i; } radixsort(trank,n); int tot=0; for(int i=1;i<=n;++i){ if(trank[i].a==trank[i-1].a&&trank[i].b==trank[i-1].b) rank[trank[i].id].a=rank[trank[i-1].id].a; else rank[trank[i].id].a=++tot; } } for(int i=1;i<=n;++i) r[i]=rank[i].a,suf[r[i]]=i; for(int i=1,j=0,k=0;i<=n;height[r[i++]]=k) for(k?--k:k,j=suf[r[i]-1];i+k<=n&&j+k<=n&&a[i+k]==a[j+k];++k); }
int inverter_write(Inverter_t * v, FILE * fp) { uint32_t i, size; inverter_compact(v); radixsort(v->record, 0, v->count - 1, 0); for (i = 0; i < v->count; i++) { *PLIST(v->record[i])++ = EMPTY; size = (char *) PLIST(v->record[i]) - v->record[i]; if (fwrite(&size, sizeof(uint32_t), 1, fp) != 1) return 0; /* can't write */ if (fwrite(v->record[i], size, 1, fp) != 1) return 0; /* can't write */ } inverter_clear(v); return 1; }
void getsuffix(){ for(int i=n;i>=1;--i) rank[i].a=a[i]=a[i]-a[i-1]+100; for(int k=0;k+1<=n;k=k?k<<1:1){ memcpy(trank,rank,sizeof(rank)); for(int i=1;i<=n;++i){ trank[i].b=i+k<=n?rank[i+k].a:0; trank[i].id=i; } radixsort(trank,n); int tot=0; for(int i=1;i<=n;++i){ if(trank[i].a==trank[i-1].a&&trank[i].b==trank[i-1].b) rank[trank[i].id].a=rank[trank[i-1].id].a; else rank[trank[i].id].a=++tot; } } for(int i=1;i<=n;++i) r[i]=rank[i].a,suf[r[i]]=i; }
int main(int argc, char const* argv[]) { int* nums = calloc(argc - 1, sizeof(int)); for (int i = 0; i < argc - 1; i++) { nums[i] = atoi(argv[i + 1]); } puts("Your arguments:"); for (int i = 0; i < argc - 1; i++) printf("%d ", nums[i]); puts("\n"); radixsort(nums, argc - 1); puts("Your arguments (sorted):"); for (int i = 0; i < argc - 1; i++) printf("%d ", nums[i]); free(nums); return 0; }
int main(){ int n; if(!(scanf("%d",&n)) || n<=0){ printf("INVALID INPUT\n"); return 0; } std list[10]; char rl[9],nm[20]; int i,j,mrk; for(i=0;i<n;i++){ scanf("%s%s%d",rl,nm,&mrk); if(mrk<0 || mrk>100 || strlen(rl)!=9){ printf("INVALID INPUT\n"); return 0; } strcpy(list[i].roll,rl); strcpy(list[i].name,nm); list[i].mark=mrk; } for(i=0;i<n;i++){ for(j=0;j<9;j++){ if(j==0 || j>=7){ if(list[i].roll[j]<65 || list[i].roll[j]>90){ printf("INVALID INPUT\n"); return 0; } } else{ if(list[i].roll[j]<48 || list[i].roll[j]>57){ printf("INVALID INPUT\n"); return 0; } } } } radixsort(list,n); for(i=0;i<n;i++) printf("%s %s %d\n",list[i].roll,list[i].name,list[i].mark); }
/** * @brief get suffix array and rank array. */ void get_sa(char* s, int size, int** psa, int** prank) { int p = 0, i = 0, j = 0; int *trank = (int*) malloc(sizeof(int) * (size)); int *rank = (int*) malloc(sizeof(int) * (size)); int *sum = (int*) malloc(sizeof(int) * BASE); int *sa = (int*) malloc(sizeof(int) * (size)); int *tsa = (int*) malloc(sizeof(int) * (size)); memset(sum, 0, sizeof(int) * BASE); for (i = 0; i < size; i ++) { trank[i] = (int)s[i]; } for (i = 0; i < size; i ++) { sum[ trank[i] ] ++; } for (i = 1; i < BASE; i ++) { sum[i] += sum[i-1]; } for (i = size-1; i >= 0; i --) { sa[ --sum[ trank[i] ] ] = i; } rank[ sa[0] ] = 1; for (i = 1, p = 1; i < size; i ++) { if (trank[ sa[i] ] != trank[ sa[i-1] ]) { p ++; } rank[ sa[i] ] = p; } for (j = 1; j <= size; j *= 2) { radixsort(sa, rank, tsa, sum, size, j); trank[ sa[0] ] = 1; for (i = 1, p = 1; i < size; i ++) { if ((rank[ sa[i] ] != rank[ sa[i-1] ]) || (sa[i] + j < size && sa[i-1] + j >= size) || (sa[i] + j >= size && sa[i-1] + j < size) || (sa[i] + j < size && sa[i-1] + j < size && rank[ sa[i] + j ] != rank[ sa[i-1] + j ])) { p ++; } trank[ sa[i] ] = p; } for (i = 0; i < size; i ++) { rank[i] = trank[i]; } } free(trank); free(sum); free(tsa); if (psa) { *psa = sa; } else { free(sa); } if (prank) { *prank = rank; } else { free(rank); } }
int main(int argc, char **argv) { int rank, M, j,i, *d_graph; int *local_matrix, *row_matrix, *col_matrix, *res_matrix, *rowIds, *colIds; int P, N, q, p_row, p_col; double start, finish; MPI_Status status; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &P); MPI_Comm_rank(MPI_COMM_WORLD, &rank); //INPUT HANDLED BY THE ROOT PROCESSOR if (rank == ROOT){ scanf("%d", &N); q = check_fox_conditions(P,N); //Check's if the fox's conditions are met if(q == 0){ MPI_Abort(MPI_COMM_WORLD, 0); return 1; //error } d_graph = (int*)malloc((N*N) * sizeof(int)); for(i=0; i < N; i++){ for(j=0; j < N; j++){ scanf("%d", &d_graph[GET_MTRX_POS(i,j,N)]); if (d_graph[GET_MTRX_POS(i,j,N)] == 0 && i != j) { d_graph[GET_MTRX_POS(i,j,N)] = INF; } } } MPI_Bcast(&q, 1, MPI_INT, 0, MPI_COMM_WORLD); MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD); if(q > 1) divide_matrix( d_graph, N, q); } else{ MPI_Bcast(&q, 1, MPI_INT, 0, MPI_COMM_WORLD); MPI_Bcast(&N, 1, MPI_INT, 0, MPI_COMM_WORLD); } //---------------COMMON------------------ int lngth = N / q; local_matrix = (int*)malloc((lngth*lngth) * sizeof(int)); row_matrix = (int*)malloc((lngth*lngth) * sizeof(int)); col_matrix = (int*)malloc((lngth*lngth) * sizeof(int)); res_matrix = (int*)malloc((lngth*lngth) * sizeof(int)); if(q>1) chnkd_MPI_Recv(local_matrix, lngth*lngth, MPI_INT, 0); else local_matrix = d_graph; p_row = ( rank / q ); p_col = ( rank % q ); //CREATE COMMUNICATORS MPI_Group MPI_GROUP_WORLD; MPI_Comm_group(MPI_COMM_WORLD, &MPI_GROUP_WORLD); MPI_Group row_group, col_group; MPI_Comm row_comm, col_comm, grid_comm; int tmp_row, tmp_col, proc; int row_process_ranks[q], col_process_ranks[q]; for(proc = 0; proc < q; proc++){ row_process_ranks[proc] = (p_row * q) + proc; col_process_ranks[proc] = ((p_col + proc*q) %(q*q)); } radixsort(col_process_ranks, q); radixsort(row_process_ranks, q); MPI_Group_incl(MPI_GROUP_WORLD, q, row_process_ranks, &row_group); MPI_Group_incl(MPI_GROUP_WORLD, q, col_process_ranks, &col_group); MPI_Comm_create(MPI_COMM_WORLD, row_group, &row_comm); MPI_Comm_create(MPI_COMM_WORLD, col_group, &col_comm); if ((rank / q) == (rank % q)) { memcpy(row_matrix, local_matrix, (lngth*lngth) * sizeof(int)); } int ln,d,flag; int step, rotation_src, rotation_dest, src; int count = 0; memcpy(res_matrix, local_matrix, (lngth*lngth) * sizeof(int)); rotation_src = (p_row + 1) % q; rotation_dest = ((p_row - 1) + q) % q; ln = (lngth*q) << 1; start = MPI_Wtime(); for (d = 2; d < ln; d = d << 1) { memcpy(col_matrix, local_matrix, (lngth*lngth) * sizeof(int)); for ( step = 0; step < q; step++) { src = (p_row + step) % q; count++; if (src == p_col) { MPI_Bcast(local_matrix, lngth*lngth, MPI_INT, src, row_comm); floyd_warshall( local_matrix, col_matrix, res_matrix, lngth); } else { MPI_Bcast(row_matrix, lngth*lngth, MPI_INT, src, row_comm); floyd_warshall( row_matrix, col_matrix, res_matrix, lngth); } if( step < q-1) MPI_Sendrecv_replace(col_matrix, lngth*lngth, MPI_INT, rotation_dest, STD_TAG,rotation_src, STD_TAG, col_comm, MPI_STATUS_IGNORE); } memcpy(local_matrix, res_matrix, (lngth*lngth) * sizeof(int)); } int *sol; sol = malloc(N*N*sizeof(int)); MPI_Gather(res_matrix, lngth*lngth, MPI_INT, sol, lngth*lngth, MPI_INT, 0, MPI_COMM_WORLD); if (rank == 0) { finish = MPI_Wtime(); printf("Tempo de execução %f\n",finish - start); } if (rank == 0) { int row, col, pos_x, pos_y, pos, tmp_y, tmp_x; for (i = 0; i < P; i++) { pos_x = i / q; pos_y = i % q; pos = i * lngth*lngth; for (row = 0; row < lngth; row++) { for (col = 0; col < lngth; col++) { tmp_x = GET_MTRX_POS(pos_x,row,lngth); tmp_y = GET_MTRX_POS(pos_y,col,lngth); if (sol[GET_MTRX_POS(row,col,lngth) + pos] == INF) d_graph[GET_MTRX_POS(tmp_x,tmp_y,N)] = 0; else d_graph[GET_MTRX_POS(tmp_x,tmp_y,N)] = sol[GET_MTRX_POS(row,col,lngth) + pos]; } } } prints_matrix(d_graph,N); } MPI_Finalize(); return 0; }
void fsort(int binno, int depth, union f_handle infiles, int nfiles, FILE *outfp, struct field *ftbl) { u_char *weights, **keypos, *bufend, *tmpbuf; static u_char *buffer, **keylist; static size_t bufsize; int ntfiles, mfct = 0, total, i, maxb, lastb, panic = 0; int c, nelem; long sizes[NBINS+1]; union f_handle tfiles, mstart = {MAXFCT-16}; int (*get)(int, union f_handle, int, RECHEADER *, u_char *, struct field *); RECHEADER *crec; struct field tfield[2]; FILE *prevfp, *tailfp[FSORTMAX+1]; memset(tailfp, 0, sizeof(tailfp)); prevfp = outfp; memset(tfield, 0, sizeof(tfield)); if (ftbl[0].flags & R) tfield[0].weights = Rascii; else tfield[0].weights = ascii; tfield[0].icol.num = 1; weights = ftbl[0].weights; if (buffer == NULL) { bufsize = BUFSIZE; if ((buffer = malloc(bufsize)) == NULL || (keylist = calloc(MAXNUM, sizeof(u_char *))) == NULL) err(2, NULL); } bufend = buffer + bufsize - 1; if (binno >= 0) { tfiles.top = infiles.top + nfiles; get = getnext; } else { tfiles.top = 0; if (SINGL_FLD) get = makeline; else get = makekey; } for (;;) { memset(sizes, 0, sizeof(sizes)); c = ntfiles = 0; if (binno == weights[REC_D] && !(SINGL_FLD && ftbl[0].flags & F)) { /* pop */ rd_append(weights[REC_D], infiles, nfiles, prevfp, buffer, bufend); break; } else if (binno == weights[REC_D]) { depth = 0; /* start over on flat weights */ ftbl = tfield; weights = ftbl[0].weights; } while (c != EOF) { keypos = keylist; nelem = 0; crec = (RECHEADER *) buffer; while ((c = get(binno, infiles, nfiles, crec, bufend, ftbl)) == 0) { *keypos++ = crec->data + depth; if (++nelem == MAXNUM) { c = BUFFEND; break; } crec = (RECHEADER *)((char *)crec + SALIGN(crec->length) + sizeof(TRECHEADER)); } /* * buffer was too small for data, allocate * a bigger buffer. */ if (c == BUFFEND && nelem == 0) { bufsize *= 2; tmpbuf = realloc(buffer, bufsize); if (!tmpbuf) err(2, "failed to realloc buffer"); crec = (RECHEADER *) (tmpbuf + ((u_char *)crec - buffer)); buffer = tmpbuf; bufend = buffer + bufsize - 1; continue; } if (c == BUFFEND || ntfiles || mfct) { /* push */ if (panic >= PANIC) { fstack[MAXFCT-16+mfct].fp = ftmp(); if (radixsort((const u_char **)keylist, nelem, weights, REC_D)) err(2, NULL); append(keylist, nelem, depth, fstack[ MAXFCT-16+mfct].fp, putrec, ftbl); mfct++; /* reduce number of open files */ if (mfct == 16 ||(c == EOF && ntfiles)) { fstack[tfiles.top + ntfiles].fp = ftmp(); fmerge(0, mstart, mfct, geteasy, fstack[tfiles.top+ntfiles].fp, putrec, ftbl); ntfiles++; mfct = 0; } } else { fstack[tfiles.top + ntfiles].fp= ftmp(); onepass(keylist, depth, nelem, sizes, weights, fstack[tfiles.top+ntfiles].fp); ntfiles++; } } } get = getnext; if (!ntfiles && !mfct) { /* everything in memory--pop */ if (nelem > 1) { if (STABLE) { i = sradixsort((const u_char **)keylist, nelem, weights, REC_D); } else { i = radixsort((const u_char **)keylist, nelem, weights, REC_D); } if (i) err(2, NULL); } append(keylist, nelem, depth, outfp, putline, ftbl); break; /* pop */ } if (panic >= PANIC) { if (!ntfiles) fmerge(0, mstart, mfct, geteasy, outfp, putline, ftbl); else fmerge(0, tfiles, ntfiles, geteasy, outfp, putline, ftbl); break; } total = maxb = lastb = 0; /* find if one bin dominates */ for (i = 0; i < NBINS; i++) if (sizes[i]) { if (sizes[i] > sizes[maxb]) maxb = i; lastb = i; total += sizes[i]; } if (sizes[maxb] < max((total / 2) , BUFSIZE)) maxb = lastb; /* otherwise pop after last bin */ fstack[tfiles.top].lastb = lastb; fstack[tfiles.top].maxb = maxb; /* start refining next level. */ get(-1, tfiles, ntfiles, crec, bufend, 0); /* rewind */ for (i = 0; i < maxb; i++) { if (!sizes[i]) /* bin empty; step ahead file offset */ get(i, tfiles, ntfiles, crec, bufend, 0); else fsort(i, depth+1, tfiles, ntfiles, outfp, ftbl); } if (lastb != maxb) { if (prevfp != outfp) tailfp[panic] = prevfp; prevfp = ftmp(); for (i = maxb+1; i <= lastb; i++) if (!sizes[i]) get(i, tfiles, ntfiles, crec, bufend,0); else fsort(i, depth+1, tfiles, ntfiles, prevfp, ftbl); } /* sort biggest (or last) bin at this level */ depth++; panic++; binno = maxb; infiles.top = tfiles.top; /* getnext will free tfiles, */ nfiles = ntfiles; /* so overwrite them */ } if (prevfp != outfp) { concat(outfp, prevfp); fclose(prevfp); } for (i = panic; i >= 0; --i) if (tailfp[i]) { concat(outfp, tailfp[i]); fclose(tailfp[i]); } }
int main (int argc, char **argv) { int N,MxInt,i,Nthread; int *data, *check_data, *unsorted_data; printf("\n COMP4300 Ass2 Sorting Program\n"); printf(" Input Total Number of Data Items\n"); printf(" Maximum Integer Value\n"); printf(" and Number of Threads to Create\n"); scanf("%d%d%d",&N,&MxInt,&Nthread); assert(MxInt<MAX_INTS); assert(N>0 && N<MAX_INTS); assert(Nthread > 0 && Nthread < MAX_THRDS); printf("\n-------------------------------------\n"); printf(" Total Number of Data Items %-12d\n",N); printf(" Maximum Integer Value %-12d\n",MxInt); printf(" Number of Threads to Use %-12d\n",Nthread); printf("-------------------------------------\n\n"); /* Allocate data array and generate random numbers */ unsorted_data = (int *) malloc (N * sizeof(int)); data = (int*) malloc( N*sizeof(int) ); check_data = (int*) malloc( N*sizeof(int) ); init_data (unsorted_data, N, MxInt); prtvec(unsorted_data,N,"Unsorted Data"); /* Take copy and sort using radix sort, then use to verify */ for (i = 0; i < N; i++) check_data[i] = unsorted_data[i]; /* RADIX SORT */ measure_time(START_TIME, NULL); radixsort(check_data, N, MxInt); measure_time(STOP_TIME, "RadixSort"); for (i = 0; i < N; i++) data[i] = unsorted_data[i]; // RECURSIVE SORT measure_time(START_TIME, NULL); recur_qsort(data, 0, N-1); measure_time(STOP_TIME, "Recursive QuickSort"); check_results(check_data, data, N); for (i = 0; i < N; i++) data[i] = unsorted_data[i]; // ROUTINE 1 - ITERATIVE SORT measure_time(START_TIME, NULL); qsort_1(data, N); measure_time(STOP_TIME, "Routine 1"); check_results(check_data, data, N); for (i = 0; i < N; i++) data[i] = unsorted_data[i]; // ROUTINE 2 - RECURSIVE PTHREAD QUICKSORT measure_time(START_TIME, NULL); int numBusyThreads = 1; struct recur_pthread_qsort_args args = { data, 0, N-1, &numBusyThreads, Nthread}; qsort_2 (&args); measure_time(STOP_TIME, "Routine 2"); check_results(check_data, data, N); for (i = 0; i < N; i++) data[i] = unsorted_data[i]; // ROUTINE 3 - ITERATIVE BUSY WAITING PTHREAD QUICKSORT measure_time (START_TIME, NULL); qsort_3 (data, N, Nthread); measure_time (STOP_TIME, "Routine 3"); check_results(check_data, data, N); for (i = 0; i < N; i++) data[i] = unsorted_data[i]; // ROUTINE 4 - ITERATIVE CV PTHREAD QUICKSORT measure_time (START_TIME, NULL); qsort_4 (data, N, Nthread); measure_time (STOP_TIME, "Routine 4"); // PRINT "SORTED" DATA prtvec(data,N,"Sorted Data"); /* Sequential check that the results are correct */ check_results(check_data, data, N); printf("Execution completed successfully\n"); return 0; }
void solve() { char s[MAXSTR],t[MAXSTR]; ll mask1=0,mask2=0,mask3; int i,j,tn; int source,sink,letters,words; int match[MAXSTR]; fgets(s,MAXSTR-1,stdin); trimcrlf(s); for(i=j=0;;) { while(s[j]==' ') j++; if(!s[j]) break; t[i++]=s[j++]; } t[i]=0; mask1=(1LL<<getix(t[0]))|(1LL<<getix(t[1])); for(i=2;t[i];i++) { if(!isalpha(t[i])) printf("illegal char [%c]\n",t[i]),exit(0); mask2|=(1LL<<getix(t[i])); } tn=strlen(t); for(ni=i=0;i<nw;i++) if((wmask[i]&mask1)==mask1 && (wmask[i]&mask2)) include[ni++]=i; if(ni<tn-2) { /* trivial reject - fewer eligible words than letters */ puts("-1"); return; } /* create graph */ source=0; letters=1; words=letters+tn-2; sink=words+ni; n=sink+1; ne=0; if(n>MAXV) puts("increase MAXV and recompile"),exit(0); for(i=0;i<tn-2;i++) addedge(source,letters+i); for(i=0;i<tn-2;i++) for(j=0;j<ni;j++) { mask3=mask1|(1LL<<getix(t[i+2])); if((wmask[include[j]]&mask3)==mask3) addedge(letters+i,words+j); } for(i=0;i<ni;i++) addedge(words+i,sink); radixsort(); inverseedges(); memset(f,0,ne*sizeof(int)); memset(cost,0,ne*sizeof(int)); /* set capacities and costs */ for(i=0;i<ne;i++) { if(from[i]==source) f[i]=1; if(to[i]==sink) f[i]=1,cost[i]=strlen(w[include[from[i]-words]]); if(from[i]==sink) f[i]=1,cost[i]=-strlen(w[include[to[i]-words]]); if(from[i]>=letters && from[i]<words && to[i]>=words && to[i]<sink) f[i]=1; } mincost(source,sink); for(i=0;i<ne;i++) if(from[i]==source && f[i]) { /* unmatched letter, reject */ puts("-1"); return; } printf("%d\n",tn-2); for(i=0;i<ne;i++) if(!f[i] && from[i]>=letters && from[i]<words && to[i]>=words && to[i]<sink) match[from[i]-letters]=to[i]-words; for(i=0;i<tn-2;i++) puts(w[include[match[i]]]); }
/* Main program. */ int main(void) { int i, j, n_samples, max_n, step_n; int array_size; int radix; test_item_t a[N_ITEMS], test_array[N_ITEMS]; test_item_t *timing_array, *copy_array; timing_t *t; /* Assign random values to the key of each array element. */ rand_array(a, N_ITEMS, 100); /* Now test quicksort(). */ memcpy(test_array, a, sizeof(test_array)); printf("array before quicksort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); quicksort(test_array, N_ITEMS, sizeof(test_item_t), item_cmp); printf("array after quicksort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); /* Now test mergesort0(). */ memcpy(test_array, a, sizeof(test_array)); printf("array before mergesort0\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); mergesort0(test_array, N_ITEMS, sizeof(test_item_t), item_cmp); printf("array after mergesort0\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); /* Now test mergesort(). */ memcpy(test_array, a, sizeof(test_array)); printf("array before mergesort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); mergesort(test_array, N_ITEMS, sizeof(test_item_t), item_cmp); printf("array after mergesort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); /* Now test radix sort. */ memcpy(test_array, a, sizeof(test_array)); printf("array before radixsort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); radixsort(test_array, N_ITEMS, sizeof(test_item_t), get_value, 10); printf("array after radixsort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); /* Now test heapsort. */ memcpy(test_array, a, sizeof(test_array)); printf("array before heapsort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); heapsort(test_array, N_ITEMS, sizeof(test_item_t), item_cmp); printf("array after heapsort\n = "); print_array(test_array, N_ITEMS); printf("\n\n"); /* Time the quicksort and mergesort sorting functions. */ printf("Enter the number of samples to use: "); scanf("%d", &n_samples); printf("Enter the maximum array length to sort: "); scanf("%d", &max_n); printf("Enter the step size for array lengths: "); scanf("%d", &step_n); t = timing_alloc(5); /* Five different sorting algorithms. */ printf("\nResults (n, qsort, quicksort, mergesort, mergesort0, heapsort) (msec)\n" ); for(i = step_n; i <= max_n; i += step_n) { array_size = i * sizeof(test_item_t); timing_array = malloc(array_size); copy_array = malloc(array_size); rand_array(copy_array, i, MAX_VALUE); timing_reset(t); for(j = 0; j < n_samples; j++) { memcpy(timing_array, copy_array, array_size); timing_start(); qsort(timing_array, i, sizeof(test_item_t), item_cmp); timing_stop(t,0); memcpy(timing_array, copy_array, array_size); timing_start(); quicksort(timing_array, i, sizeof(test_item_t), item_cmp); timing_stop(t,1); memcpy(timing_array, copy_array, array_size); timing_start(); mergesort(timing_array, i, sizeof(test_item_t), item_cmp); timing_stop(t,2); memcpy(timing_array, copy_array, array_size); timing_start(); mergesort0(timing_array, i, sizeof(test_item_t), item_cmp); timing_stop(t,3); memcpy(timing_array, copy_array, array_size); timing_start(); heapsort(timing_array, i, sizeof(test_item_t), item_cmp); timing_stop(t,4); } printf("%d", i); timing_print(t,"\t%.2f",n_samples); putchar('\n'); free(timing_array); free(copy_array); } timing_free(t); /* Time radix sort on the largest array, using different radix sizes. */ printf("\nRadix Sort Results. Using n = %d\n", max_n); printf("(radix, time)\n"); array_size = max_n * sizeof(test_item_t); timing_array = malloc(array_size); copy_array = malloc(array_size); rand_array(copy_array, max_n, MAX_VALUE); for(radix = 2; radix <= max_n; radix <<= 1) { timer_reset(); for(j = 0; j < n_samples; j++) { memcpy(timing_array, copy_array, array_size); timer_start(); radixsort(timing_array, max_n, sizeof(test_item_t), get_value, radix); timer_stop(); } printf("%d", radix); timer_print("\t%.2f", n_samples); putchar('\n'); } free(timing_array); free(copy_array); return 0; }
main() { int i,n,x,j,z=0,r; float m; double mean=0; double sd=0; clock_t e1,e2; FILE *f1; f1=fopen("abcd.txt","a"); printf("enter the number of elements to be sorted and number of runs"); scanf("%d %d",&n,&x); int a[n]; for(j=0;j<x;j++) { for(i=0;i<n;i++) { a[i]=rand(); //printf("%d ",a[i]); } for(i=0;i<n;i++) { while(a[i]/(int)pow(10,z)!=0) { z++; } } //printf("%d",z); e1=clock(); for(i=0;i<z;i++) { radixsort(a,i,n); } /*printf("\n****************************\n"); for(i=0;i<n;i++) { printf("%d ",a[i]); }*/ e2=clock(); fprintf(f1,"%f%c",((float)(e2-e1))/CLOCKS_PER_SEC,' '); printf("\nrun %d : %f",j+1,((float)(e2-e1))/CLOCKS_PER_SEC); } fclose(f1); f1=fopen("abcd.txt","r"); for(i=0;i<x;i++) { fscanf(f1,"%f ",&m); mean=mean+m; } mean=mean/x; fclose(f1); f1=fopen("abcd.txt","r"); for(i=0;i<x;i++) { fscanf(f1,"%f ",&m); sd=sd+pow(mean-m,2); } sd=sqrt(sd/x); fclose(f1); f1=fopen("abcd.txt","a"); fprintf(f1,"%f%c%f",mean,' ',sd); fclose(f1); }