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);
}
