int main(int argc, char** argv) { MPI_Status status; int i, n; int* data, *temp; clock_t start, end; double elapsed_time, t1, t2; //MPI MPI_Init(NULL, NULL); int world_rank; MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); int world_size; MPI_Comm_size(MPI_COMM_WORLD, &world_size); // Create data data = (int *)malloc(sizeof(int)*N); temp = (int *)malloc(sizeof(int)*N); if (world_rank == 0) { if (data == NULL) { printf("Fail to malloc\n"); exit(1); } for (i=N-1; i>=0; i--) data[N-1-i] = i; // Check sorted if (isSorted(data, N)) printf("Array is sorted\n"); else printf("Array is NOT sorted\n"); } //Sort Part MPI_Barrier(MPI_COMM_WORLD); t1 = MPI_Wtime(); int s = N/world_size; MPI_Bcast(&s,1,MPI_INT,0,MPI_COMM_WORLD); int * chunk = (int *)malloc(s*sizeof(int)); MPI_Scatter(data,s,MPI_INT,chunk,s,MPI_INT,0,MPI_COMM_WORLD); bubbleSort(chunk,s); // merge int step = 1; while(step<world_size) { if(world_rank%(2*step)==0) { if(world_rank+step<world_size) { int m; MPI_Recv(&m,1,MPI_INT,world_rank+step,0,MPI_COMM_WORLD,&status); int * other; other = (int *)malloc(m*sizeof(int)); MPI_Recv(other,m,MPI_INT,world_rank+step,0,MPI_COMM_WORLD,&status); chunk = merge(chunk,s,other,m); s = s+m; } } else { int near = world_rank-step; MPI_Send(&s,1,MPI_INT,near,0,MPI_COMM_WORLD); MPI_Send(chunk,s,MPI_INT,near,0,MPI_COMM_WORLD); break; } step = step*2; } if(world_rank == 0){ if (isSorted(chunk, N)) printf("Array is sorted\n"); else printf("%d : Array is NOT sorted\n", world_size); t2 = MPI_Wtime(); printf( "Elapsed time MPI_Wtime is %f\n", t2 - t1 ); } MPI_Finalize(); return 0; }
int main() { const unsigned long int N = 100; std::cout << N << std::endl; srand((int) time(NULL)); int * a = new int[N]; int * aux = new int[N]; copiaNumeros(a,N); for (int i = 0; i < N; ++i) { aux[i] = a[i]; } auto begin = std::chrono::high_resolution_clock::now(); bubbleSort(a, N); auto end = std::chrono::high_resolution_clock::now(); auto tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Bubble: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); cocktailSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Cocktail: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); insertionSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Insertion: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); bucketSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Bucket: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); countingSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Counting: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); mergeSort(a, 0, N-1, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Merge: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); radixSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Radix: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); shellSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Shell: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); selectionSort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Selection: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); quickSort(a, 0, N-1); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Quick: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); heap_sort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Heap: "<<tiempo.count()<<std::endl; for( int i = 0; i<N; i++) { a[i] = aux[i]; } begin = std::chrono::high_resolution_clock::now(); binarySort(a, N); end = std::chrono::high_resolution_clock::now(); tiempo = std::chrono::duration_cast<std::chrono::microseconds>(end-begin); std::cout<<"Binary: "<<tiempo.count()<<std::endl; delete a; delete aux; return 0; }
void ItemStorage::sort() { bubbleSort(storage, slot_number); }
int aslr_sumup(unsigned int i){ bubbleSort((addr_size*)aslrtab+i*num_samples,num_samples); maxrep(i); return 0; }
void test_sort_character_data(){ char data[5] = {'d','b','c','a','e'}; char expected[5] = {'a','b','c','d','e'}; bubbleSort(data, 5, sizeof(char), compareChar); ASSERT(0 == memcmp(data,expected,sizeof(expected))); }
void InsertionSet::execute(BasicBlock* block) { bubbleSort(m_insertions.begin(), m_insertions.end()); executeInsertions(block->m_values, m_insertions); }
int main(int argc, char** argv) { int i, n; int* A, *temp; clock_t start, end; double elapsed_time, t1, t2; MPI_Init(NULL, NULL); int world_rank, world_size; MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); MPI_Comm_size(MPI_COMM_WORLD, &world_size); n = world_size; int chunkSize = N / world_size; int start_index = world_rank * chunkSize; t1 = MPI_Wtime(); A = (int *)malloc(sizeof(int)*chunkSize); temp = (int *)malloc(sizeof(int)*N); if (A == NULL) { printf("Fail to malloc\n"); exit(1); } for (i=chunkSize-1; i>=0; i--) A[chunkSize-1-i] = i + start_index; if (isSorted(A, chunkSize)) printf("Array is sorted\n"); else printf("Array is NOT sorted\n"); bubbleSort(A, chunkSize); if (world_rank == 0) { int rank; int *partial[n]; printArray(A, 5); partial[0] = A; for (rank = 1; rank < world_size; rank++) { int* rev = (int *)malloc(sizeof(int)*chunkSize); MPI_Recv(rev, chunkSize, MPI_INT, rank, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE); printArray(rev, 5); partial[rank] = rev; } temp = multiMerge(partial, N, n); if (isSorted(temp, N)) printf("Array is sorted\n"); else printf("Array is NOT sorted\n"); t2 = MPI_Wtime(); printf( "Elapsed time MPI_Wtime is %f\n", t2 - t1 ); //printArray(temp, N); } else if (world_rank != 0) { MPI_Send(A, chunkSize, MPI_INT, 0, 0, MPI_COMM_WORLD); } MPI_Finalize(); return 0; }
void test_sort_only_one_integer_element(){ int data[1] = {5}; int expected[1] = {5}; bubbleSort(data, 1, sizeof(int), compareInt); ASSERT(0 == memcmp(data,expected,sizeof(expected))); }
void main() { int a[1000]; /*declarete array whith integer values*/ gen_array(a); /*fill an array of random numbers*/ printf("Test bubble sorting\n"); printArray(a, ARRAY_SIZE(a)); clock_t theStartt = clock(); /*starting clock*/ bubbleSort(a, ARRAY_SIZE(a)); clock_t theEndt = clock(); /*finish clock*/ printArray(a, ARRAY_SIZE(a)); printf ("time of Bubble sorting: %.10lf\n", (double)(theEndt - theStartt)/CLOCKS_PER_SEC); gen_array(a); /*assigned array new value*/ printf("\nTest selection sorting\n"); printArray(a, ARRAY_SIZE(a)); clock_t theStart1 = clock(); /*starting clock*/ selectionSort(a, ARRAY_SIZE(a)); clock_t theEnd1 = clock(); /*finish clock*/ printArray(a, ARRAY_SIZE(a)); printf ("time of Selection sorting: %.10lf\n", (double)(theEnd1 - theStart1)/CLOCKS_PER_SEC); gen_array(a); /*assigned array new value*/ printf("\nTest insertion sorting\n"); printArray(a, ARRAY_SIZE(a)); clock_t theStart0 = clock(); /*starting clock*/ insertionSort(a, ARRAY_SIZE(a)); clock_t theEnd0 = clock(); /*finish clock*/ printArray(a, ARRAY_SIZE(a)); printf ("time of Inserton sorting: %.10lf\n", (double)(theEnd0 - theStart0)/CLOCKS_PER_SEC); gen_array(a); /*assigned array new value*/ printf("\nTest Shell sorting\n"); printArray(a, ARRAY_SIZE(a)); clock_t theStart = clock(); /*starting clock*/ shellSort(a, ARRAY_SIZE(a)); clock_t theEnd = clock(); /*finish clock*/ printArray(a, ARRAY_SIZE(a)); printf ("time of Shell sorting: %.10lf\n", (double)(theEnd - theStart)/CLOCKS_PER_SEC); gen_array(a); printf("\nTest quickSort\n"); printArray(a, ARRAY_SIZE(a)); clock_t theStart3 = clock(); quickSort(a, ARRAY_SIZE(a)); clock_t theEnd3 = clock(); printArray(a, ARRAY_SIZE(a)); printf ("time of quickSort : %.10lf\n", (double)(theEnd3 - theStart3)/CLOCKS_PER_SEC); }
int average(int *array1, int size, int code) { int array2[size]; int array3[size]; int array4[size]; int array5[size]; int array6[size]; int array7[size]; int array8[size]; int array9[size]; int array10[size]; int i; double time = 0; clock_t start_t, end_t; //copies array1 to the rest of the arrays for(i = 0; i <= size; i++) { array2[i] = array1[i]; array3[i] = array1[i]; array4[i] = array1[i]; array5[i] = array1[i]; array6[i] = array1[i]; array7[i] = array1[i]; array8[i] = array1[i]; array9[i] = array1[i]; } switch(code) { case 1: start_t = clock(); insertionSort(array1, size); insertionSort(array2, size); insertionSort(array3, size); insertionSort(array4, size); insertionSort(array5, size); insertionSort(array6, size); insertionSort(array7, size); insertionSort(array8, size); insertionSort(array9, size); insertionSort(array10, size); end_t = clock(); time = (double)(end_t - start_t); break; case 2: start_t = clock(); selectionSort(array1, size); selectionSort(array2, size); selectionSort(array3, size); selectionSort(array4, size); selectionSort(array5, size); selectionSort(array6, size); selectionSort(array7, size); selectionSort(array8, size); selectionSort(array9, size); selectionSort(array10, size); end_t = clock(); time = (double)(end_t - start_t); break; case 3: start_t = clock(); bubbleSort(array1, size); bubbleSort(array2, size); bubbleSort(array3, size); bubbleSort(array4, size); bubbleSort(array5, size); bubbleSort(array6, size); bubbleSort(array7, size); bubbleSort(array8, size); bubbleSort(array9, size); bubbleSort(array10, size); end_t = clock(); time = (double)(end_t - start_t); break; case 4: start_t = clock(); mergeSort(array1, 0, size); mergeSort(array2, 0, size); mergeSort(array3, 0, size); mergeSort(array4, 0, size); mergeSort(array5, 0, size); mergeSort(array6, 0, size); mergeSort(array7, 0, size); mergeSort(array8, 0, size); mergeSort(array9, 0, size); mergeSort(array10, 0, size); end_t = clock(); time = (double)(end_t - start_t); break; case 5: start_t = clock(); quickSort(array1, 0, size); quickSort(array2, 0, size); quickSort(array3, 0, size); quickSort(array4, 0, size); quickSort(array5, 0, size); quickSort(array6, 0, size); quickSort(array7, 0, size); quickSort(array8, 0, size); quickSort(array9, 0, size); quickSort(array10, 0, size); end_t = clock(); time = (double)(end_t - start_t); break; default: puts("command not found"); } return time / 10; }
//Huge main function. int main(int argc, char *argv[]) { if (argc < 3){ //if you don't type enough arguments printf("Sockets client, usage:\n"); printf("sockets_client {IP-address} {port} \n"); return 0; } else { free(server); server = malloc((strlen(argv[1] + 1) * sizeof(char))); strcpy(server, argv[1]); portno = atoi(argv[2]); } int c; while(1){ if(screen == 0){ CATEGORY = 8; currentRecord = 0; recordView = 0; xt_par0(XT_CLEAR_SCREEN); lifeTracker(); xt_par2(XT_SET_ROW_COL_POS,row = 8, col = 2); } while(screen == 0) { while((c = getkey()) == KEY_NOTHING); if(c == KEY_F9) screen = 3; else if(c == KEY_F3 && maxRecord > 0 && col == 20) screen = 4; else if(c == KEY_DOWN) { if(col == 2 && row >= 8 && row < catCounter + 7){ xt_par2(XT_SET_ROW_COL_POS,CATEGORY = ++row,col); updateRecords(recordView); } if(col == 20 && row >= 7 && row <= tempCounter * 5 + 1){ if(row < 22){ xt_par2(XT_SET_ROW_COL_POS,row+=5,col); ++currentRecord; } else if(recordView < tempCounter-4){ ++recordView; if(search == 1) searchResults(recordView); else updateRecords(recordView); xt_par2(XT_SET_ROW_COL_POS,row=22,col); ++currentRecord; } } if(col > 94 && col < 120){ if(row == 9) xt_par2(XT_SET_ROW_COL_POS,row = 12,col = 95); else if(row == 12) xt_par2(XT_SET_ROW_COL_POS,row = 13,col = 95); else if(row == 13) xt_par2(XT_SET_ROW_COL_POS,row = 16,col); else if(row < 20) xt_par2(XT_SET_ROW_COL_POS,++row,col); else if(row == 20 && col < 110) xt_par2(XT_SET_ROW_COL_POS,++row,col); else if(row == 20 && col > 110) xt_par2(XT_SET_ROW_COL_POS,++row,col = 109); } } else if(c == KEY_UP){ if(col == 2 && row > 8 && row <= 18){ xt_par2(XT_SET_ROW_COL_POS,CATEGORY = --row,col); updateRecords(recordView); } if(col == 20 && row >= 7 && row < 24){ if(row <= 24 && row > 7){ xt_par2(XT_SET_ROW_COL_POS,row-=5,col); --currentRecord; } else if(recordView > 0){ --recordView; if(search == 1) searchResults(recordView); else updateRecords(recordView); xt_par2(XT_SET_ROW_COL_POS,row=7,col); --currentRecord; } } if(row > 9 && col > 94 && col < 120){ if(row == 12) xt_par2(XT_SET_ROW_COL_POS,row = 9,col = 95); else if(row == 13) xt_par2(XT_SET_ROW_COL_POS,row = 12,col = 95); else if(row == 16) xt_par2(XT_SET_ROW_COL_POS, row = 13, col = 95); else if(row < 22) xt_par2(XT_SET_ROW_COL_POS, --row, col); } } else if(c == KEY_ENTER && col > 94 && col < 120 && row > 12 && row < 18) xt_par2(XT_SET_ROW_COL_POS,++row,col=95); else if((c == KEY_LEFT || c == KEY_RIGHT) && col == 2) { CATEGORY = row; updateRecords(recordView); xt_par2(XT_SET_ROW_COL_POS,row=7,col=20); } else if((c == KEY_LEFT || c == KEY_RIGHT) && col == 20) { xt_par2(XT_SET_ROW_COL_POS,row=CATEGORY,col=2); if (search == 1) clearSearch(); currentRecord = recordView = search = 0; updateRecords(recordView); } else if(c == KEY_LEFT && col >= 95) { if(col > 95) xt_par2(XT_SET_ROW_COL_POS,row,--col); else if(row == 13 && col == 95) xt_par2(XT_SET_ROW_COL_POS,--row,col = 101); else if(row >= 17 && row <= 21 && col == 95) xt_par2(XT_SET_ROW_COL_POS,--row, col = 119); } else if(c == KEY_RIGHT && col > 94) { if(row == 9 && col < 112) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(row == 12 && col < 101) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(row == 12 && col == 101) xt_par2(XT_SET_ROW_COL_POS,++row,col = 95); else if(row == 13 && col < 112) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(row >= 16 && row < 21 && col < 119) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(row == 21 && col < 109) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(row >= 16 && row <= 21 && col == 119) xt_par2(XT_SET_ROW_COL_POS,++row,col = 95); } else if(c == KEY_DELETE) { putchar(' '); if(row == 9) Category[col - 95] = ' '; else if(row == 12) Title[col - 95] = ' '; else if(row == 13) Title[col - 88] = ' '; else if(row >= 16 && row < 22) Body[(row - 16) * 25 + col - 95] = ' '; } else if(c == KEY_BACKSPACE && col >= 95) { if((row == 9 || row == 12) && col > 95) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Category[col - 95] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if((row == 9 || row == 12) && col == 95) { putchar(' '); Title[col - 95] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row == 13 && col > 95) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Title[col - 88] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row == 13 && col == 95) { xt_par2(XT_SET_ROW_COL_POS,--row,col = 101); putchar(' '); Title[col - 88] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row >= 16 && row < 22 && col > 95) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Body[(row - 16) * 25 + col - 95] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row == 16 && col == 95) { putchar(' '); Body[(row - 16) * 25 + col - 95] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row > 16 && row < 22 && col == 95) { xt_par2(XT_SET_ROW_COL_POS,--row,col = 119); putchar(' '); Body[(row - 16) * 25 + col - 95] = ' '; xt_par2(XT_SET_ROW_COL_POS,row,col); } } else if((c >= ' ' && c <= '~') && col >= 95 && col < 120){ if(row == 9 && col < 112) { putchar(c); Category[col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,row,++col); } else if(row == 9 && col == 112) { putchar(c); Category[col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row == 12 && col < 101) { putchar(c); Title[col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,row,++col); } else if(row == 12 && col == 101) { putchar(c); Title[col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,++row,col=95); } else if(row == 13 && col < 112) { putchar(c); Title[col - 88] = c; xt_par2(XT_SET_ROW_COL_POS,row,++col); } else if(row == 13 && col == 112) { putchar(c); Title[col - 88] = c; xt_par2(XT_SET_ROW_COL_POS,row,col); } else if(row >= 16 && row < 21 && col < 119) { putchar(c); Body[(row - 16) * 25 + col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,row,++col); } else if(row >= 16 && row < 21 && col == 119) { putchar(c); Body[(row - 16) * 25 + col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,++row,col = 95); } else if(row == 21 && col < 109) { putchar(c); Body[(row - 16) * 25 + col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,row,++col); } else if(row == 21 && col == 109) { putchar(c); Body[(row - 16) * 25 + col - 95] = c; xt_par2(XT_SET_ROW_COL_POS,row,col); } } else if(c == KEY_F2) screen = 1; else if(c == KEY_F4 && col == 20 && maxRecord != 0) screen = 2; else if(c == KEY_F6) { if(sort == 0){ bubbleSort(); sort = 1; } else if (sort == 1){ bubbleSortTime(); sort = 0; } } else if (c == KEY_F7){ if(col < 95) { xt_par2(XT_SET_ROW_COL_POS,row = 9,col = 95); for(reset = 0; reset < 29; reset++) Title[reset] = ' '; for(reset = 0; reset < 140; reset++) Body[reset] = ' '; for(reset = 0; reset < 16; reset++) Category[reset] = ' '; } else if(Title[0] == ' ' && Body[0] == ' ' && Category[0] == ' ') { xt_par2(XT_SET_ROW_COL_POS,row = CATEGORY,col = 2); clearSearch(); updateRecords(0); } else if(Title[0] != ' ' || Body[0] != ' ' || Category[0] != ' ') { clearSearch(); search = 1; searchResults(0); xt_par2(XT_SET_ROW_COL_POS,row = 7, col = 20); } } } if (screen == 1 || screen == 2){ for(reset = 0; reset < 29; reset++) Title[reset] = ' '; for(reset = 0; reset < 140; reset++) Body[reset] = ' '; for(reset = 0; reset < 16; reset++) Category[reset] = ' '; addScreen(); if (screen == 2){ char TempBodyA[71]; char TempBodyB[71]; int k = 0; while(k != 70) { TempBodyA[k] = ' '; TempBodyB[k] = ' '; k++; } k = 0; xt_par2(XT_SET_ROW_COL_POS, row = 12, col = 25); xt_par0(XT_CH_GREEN); printf("Record %d (%s)", currentRecord+1, catStorage[currentRecord].timedate); //get the time using myui1 xt_par0(XT_CH_WHITE); xt_par2(XT_SET_ROW_COL_POS, row = 14, col = 25); printf("%s", catStorage[currentRecord].category); int j = 0; while(catStorage[currentRecord].body[j] != '\0'){ if (j < 70) TempBodyA[j] = catStorage[currentRecord].body[j]; else if (j < 140) TempBodyB[j%70] = catStorage[currentRecord].body[j]; j++; } TempBodyA[70] = '\0'; TempBodyB[70] = '\0'; xt_par2(XT_SET_ROW_COL_POS, row = 16, col = 25); printf("%s", catStorage[currentRecord].subject); xt_par0(XT_CH_WHITE); xt_par2(XT_SET_ROW_COL_POS, row = 19, col = 25); printf("%s", TempBodyA); xt_par2(XT_SET_ROW_COL_POS, row = 20, col = 25); printf("%s", TempBodyB); xt_par2(XT_SET_ROW_COL_POS, row = 14, col = 25); strncpy(Title, catStorage[currentRecord].subject, sizeof(Title)); strncpy(Body, catStorage[currentRecord].body, sizeof(Body)); strncpy(Category, catStorage[currentRecord].category, sizeof(Category)); } } while(screen == 1 || screen == 2) { while((c = getkey()) == KEY_NOTHING); if (c == KEY_F9){ screen = 0; xt_par0(XT_CLEAR_SCREEN); } else if (c == KEY_DOWN){ if(row == 14) xt_par2(XT_SET_ROW_COL_POS, row = 16, col = 25); else if(row == 16) xt_par2(XT_SET_ROW_COL_POS,row = 19,col = 25); else if(row < 20) xt_par2(XT_SET_ROW_COL_POS,++row,col); } else if (c == KEY_UP){ if(row == 16) xt_par2(XT_SET_ROW_COL_POS, row = 14, col = 25); if(row == 19) xt_par2(XT_SET_ROW_COL_POS,row = 16,col = 25); else if(row == 20) xt_par2(XT_SET_ROW_COL_POS,--row,col); } else if(c == KEY_LEFT && col > 25 && col < 95) xt_par2(XT_SET_ROW_COL_POS,row,--col); else if(c == KEY_LEFT && col == 25 && row == 20) xt_par2(XT_SET_ROW_COL_POS,--row,col=94); else if(c == KEY_RIGHT && col > 24 && col < 37 && row == 14) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(c == KEY_RIGHT && col > 24 && col < 53 && row == 16) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(c == KEY_RIGHT && col > 24 && col < 94 && row > 18) xt_par2(XT_SET_ROW_COL_POS,row,++col); else if(c == KEY_RIGHT && col == 94 && row == 19) xt_par2(XT_SET_ROW_COL_POS,++row,col=25); else if (c == KEY_ENTER && row > 18 && row < 20) xt_par2(XT_SET_ROW_COL_POS,++row,col=25); else if (c == KEY_BACKSPACE && col >= 25 && col < 95 && ((row > 18 && row < 21) || row == 16 || row == 14)){ if(row == 14 && col > 25 && col < 39) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Category[col - 25] = ' '; } else if(row == 16 && col > 25 && col <= 54) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Title[col - 25] = ' '; } else if(row == 19 && col > 25 && col <= 95) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Body[col - 25] = ' '; } else if(row == 20 && col > 25 && col <= 95) { xt_par2(XT_SET_ROW_COL_POS,row,--col); putchar(' '); Body[col + 45] = ' '; } else if(row == 20){ xt_par2(XT_SET_ROW_COL_POS,--row,col=94); putchar(' '); Body[69] = ' '; } xt_par2(XT_SET_ROW_COL_POS,row,col); } else if (c == KEY_DELETE) { if(row == 14 && col >= 25 && col < 38) { putchar(' '); Category[col - 25] = ' '; } else if(row == 16 && col >= 25 && col < 54) { putchar(' '); Title[col - 25] = ' '; } else if(row == 19 && col >= 25 && col <= 95) { putchar(' '); Body[col - 25] = ' '; } else if(row == 20 && col >= 25 && col <= 95) { putchar(' '); Body[col + 45] = ' '; } xt_par2(XT_SET_ROW_COL_POS,row,col); } else if((c >= ' ' && c <= '~') && col >= 25 && col < 95) { if(row == 14 && col >= 25 && col < 40) { putchar(c); Category[col - 25] = c; } else if(row == 16 && col >= 25 && col < 54) { putchar(c); Title[col - 25] = c; } else if(row == 19 && col >= 25 && col <= 95) { putchar(c); Body[col - 25] = c; } else if(row == 20 && col >= 25 && col <= 95) { putchar(c); Body[col + 45] = c; } if (col < 94 && !(row == 16 && col > 52) && !(row == 14 && col > 36)){ ++col; } else{ if (row == 19) xt_par2(XT_SET_ROW_COL_POS,++row,col=25); else xt_par2(XT_SET_ROW_COL_POS,row,col); } } else if(c == KEY_F2 && screen == 1 /* && there is a valid title and description */){ //save record to corresponding subject if(Title[0] != ' ' || Body[0] != ' ' || Category[0] != ' ') { removeBlanks(); readmyStoreFromChildSOCKETS("add", Title, Body, Category, NULL); } int k = 0; while(k != 29) Title[k++] = ' '; k = 0; while(k != 140) Body[k++] = ' '; k = 0; while(k != 15) Category[k++] = ' '; maxRecord++; screen = 0; } else if(c == KEY_F2 && screen == 2 /* && there has been a valid change in the record */){ //update record removeBlanks(); char str[80]; for(i = 0; i < maxRecord; i++){ if(strcmp(catStorage[currentRecord].subject, dataStorage[i].subject) == 0 && strcmp(catStorage[currentRecord].body, dataStorage[i].body) == 0 && strcmp(catStorage[currentRecord].category, dataStorage[i].category) == 0 && strcmp(catStorage[currentRecord].timedate, dataStorage[i].timedate) == 0){//looks for corresponding record in the actual record list sprintf(str, "%d", i+1); break; } } readmyStoreFromChildSOCKETS("edit", str, Title, Body, Category); int k = 0; while(k != 29) Title[k++] = ' '; k = 0; while(k != 140) Body[k++] = ' '; k = 0; while(k != 15) Category[k++] = ' '; screen = 0; } } if (screen == 4){ for(reset = 0; reset < 29; reset++) Title[reset] = ' '; for(reset = 0; reset < 140; reset++) Body[reset] = ' '; for(reset = 0; reset < 16; reset++) Category[reset] = ' '; deleteScreen(); if (screen == 4){ char TempBodyA[71]; char TempBodyB[71]; int k = 0; while(k != 70) { TempBodyA[k] = ' '; TempBodyB[k] = ' '; k++; } k = 0; xt_par2(XT_SET_ROW_COL_POS, row = 12, col = 25); xt_par0(XT_CH_GREEN); printf("Record %d (%s)", currentRecord+1, catStorage[currentRecord].timedate); //get the time using myui1 xt_par0(XT_CH_WHITE); xt_par2(XT_SET_ROW_COL_POS, row = 14, col = 25); printf("%s", catStorage[currentRecord].category); int j = 0; while(catStorage[currentRecord].body[j] != '\0'){ if (j < 70) TempBodyA[j] = catStorage[currentRecord].body[j]; else if (j < 140) TempBodyB[j%70] = catStorage[currentRecord].body[j]; j++; } TempBodyA[70] = '\0'; TempBodyB[70] = '\0'; xt_par2(XT_SET_ROW_COL_POS, row = 16, col = 25); printf("%s", catStorage[currentRecord].subject); xt_par0(XT_CH_WHITE); xt_par2(XT_SET_ROW_COL_POS, row = 19, col = 25); printf("%s", TempBodyA); xt_par2(XT_SET_ROW_COL_POS, row = 20, col = 25); printf("%s", TempBodyB); xt_par2(XT_SET_ROW_COL_POS, row = 14, col = 25); strncpy(Title, catStorage[currentRecord].subject, sizeof(Title)); strncpy(Body, catStorage[currentRecord].body, sizeof(Body)); strncpy(Category, catStorage[currentRecord].category, sizeof(Category)); //print corresponding record in correct locations using myui1 } } while(screen == 4) { while((c = getkey()) == KEY_NOTHING); if (c == KEY_F9){ screen = 0; xt_par0(XT_CLEAR_SCREEN); } else if (c == KEY_F3){ char str[80]; for(i = 0; i < maxRecord; i++){ if(strcmp(catStorage[currentRecord].subject, dataStorage[i].subject) == 0 && strcmp(catStorage[currentRecord].body, dataStorage[i].body) == 0 && strcmp(catStorage[currentRecord].category, dataStorage[i].category) == 0 && strcmp(catStorage[currentRecord].timedate, dataStorage[i].timedate) == 0){ //looks for corresponding record in the actual record list sprintf(str, "%d", i+1); break; } } readmyStoreFromChildSOCKETS("delete", str, NULL, NULL, NULL); maxRecord--; screen = 0; } } if (screen == 3) break; } getkey_terminate(); xt_par0(XT_CLEAR_SCREEN); xt_par0(XT_BG_DEFAULT); xt_par2(XT_SET_ROW_COL_POS,row=1,col=1); getkey_terminate(); return 0; }
int main(int argc, char** argv) { int i, n; int* A; clock_t start, end; double elapsed_time, t1, t2; MPI_Init(NULL, NULL); int world_rank; MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); int world_size; MPI_Comm_size(MPI_COMM_WORLD, &world_size); t1 = MPI_Wtime(); if(world_rank == 0) { A = (int *)malloc(sizeof(int)*N); if (A == NULL) { printf("Fail to malloc\n"); exit(0); } for (i=N-1; i>=0; i--) A[N-1-i] = i; if (isSorted(A, N)) printf("Array is sorted\n"); else printf("Array is NOT sorted\n"); } //Scatter int *sub_A = (int *)malloc(sizeof(int) * N/world_size); assert(sub_A != NULL); MPI_Scatter(A, N/world_size, MPI_INT, sub_A, N/world_size, MPI_INT, 0, MPI_COMM_WORLD); // if(world_rank == 0){ // printf("Rank: %d \n", world_rank); // printArray(&sub_A[0], 10); // } bubbleSort(sub_A, N/world_size); printf("Rank: %d isSorted: %d\n", world_rank, isSorted(sub_A, N/world_size)); // printArray(sub_A, N/world_size); //Gather int *result = NULL; if(world_rank == 0){ result = (int *)malloc(sizeof(int) * N); } MPI_Gather(sub_A, N/world_size, MPI_INT, result, N/world_size, MPI_INT, 0, MPI_COMM_WORLD); if(world_rank == 0){ printArray(&result[0], N); for(i = 0; i < world_size/2; i++){ merge_swap(&result[N/world_size*i], &result[N/world_size*(world_size-i-1)], world_size); } printArray(&result[0], N); } // printArray(&result[0], N); // printArray(&result[N-10], 10); // printArray(&A[N-10], 10); // if (isSorted(A, N)) // printf("Array is sorted\n"); // else // printf("Array is NOT sorted\n"); // t2 = MPI_Wtime(); // printf( "Elapsed time MPI_Wtime is %f\n", t2 - t1 ); MPI_Finalize(); return 0; }
main(){ int d,sear; struct node *head; struct node *second; head= (struct node *) malloc( sizeof(struct node) ); second= (struct node *) malloc( sizeof(struct node) ); head->data = 5; head->next = second; second->data=6; second->next = NULL; do { printf("\nMENU\n"); printf("1. Add a new node to the start of the list\n"); printf("2. Add a new node to the end of the list \n"); printf("3. Display all of the nodes in the list \n"); printf("4. Display the length of the list \n"); printf("5. Search the linked list for a data value\n"); printf("6. delete a node to the start of the list\n"); printf("7. delete a node to the end of the list \n"); printf("8. sort the list \n"); printf("9. exit\n"); printf("enter the option you want to choose"); scanf("%d",&d); switch(d){ case 1: addToStart(&head); break; case 2: addToEnd(head); break; case 3: DisplayAllNodes(head); break; case 4: DisplayLengthAllNodes(head); break; case 5: printf("enter the value you want to search\n"); scanf("%d",&sear); searchList(head, sear); break; case 6: deleteFromStart(&head); break; case 7: deleteFromEnd(head); break; case 8: bubbleSort(head); break; case 9: exit(0); break; default: break; } system("cls"); }while(d!=9); system("pause"); }
int main() { //Print initial array printf("\n//=====Shuffled array===================//"); setarray(); printarray("Initial Array"); //=====Simple sorts=====// printf("\n\n//=====Simple sorts====================//"); //Insertion sort setarray(); insertionSort(array,10); printarray("InsertionSort"); //Selection sort setarray(); selectionSort(array,10); printarray("SelectionSort"); //=====Eficient Sorts=====// printf("\n\n//=====Eficient sorts==================//"); //Mergesort setarray(); mergeSort(array,0,9,10); printarray("MergeSort"); //Heapsort setarray(); heapSort(array,10); printarray("HeapSort"); //Quicksort setarray(); quickSort(array,0,9); printarray("QuickSort"); //Bubble sort and variants printf("\n\n//=====Bubble sort and variants========//"); //Bubblesort setarray(); bubbleSort(array,10); printarray("BubbleSort"); //Shellsort setarray(); shellSort(array,10); printarray("ShellSort"); //Combsort setarray(); combSort(array,10); printarray("CombSort"); //Distribution sorts printf("\n\n//=====Distribution sorts==============//"); //Countingsort setarray(); countingSort(array, 10, 0, 99); printarray("CountingSort"); //Radixsort setarray(); radixSort(array, 10); printarray("RadixSort"); //Other sorts printf("\n\n//=====Other sorts=====================//"); //Gnomesort setarray(); gnomeSort(array,10); printarray("GnomeSort"); //Cyclesort setarray(); cycleSort(array,10); printarray("CycleSort"); printf("\n\n"); }
int main(int argc, const char * argv[]) { for(int i=0;i<tam;i++){ int v =rand()%1000; vetorQuick[i]=v; vetorSelDir[i]=v; vetorOrdDir[i]=v; vetorBubble[i]=v; vetorShell[i] = v; } showVetor(vetorQuick); int trocas[5]={0,0,0,0,0}; clock_t tempoInicial, tempoFinal; double tempoGasto[5]={0,0,0,0,0}; //quick tempoInicial = clock(); quickSort(0, tam-1,trocas); tempoFinal = clock(); tempoGasto[0] = (tempoFinal-tempoInicial)*1000/CLOCKS_PER_SEC; showVetor(vetorQuick); //selecao direta tempoInicial = clock(); trocas[1]=selecaoDireta(); tempoFinal = clock(); tempoGasto[1] = (tempoFinal-tempoInicial)*1000/CLOCKS_PER_SEC; showVetor(vetorSelDir); //insercao direta tempoInicial = clock(); trocas[2]=insercaoDireta(); tempoFinal = clock(); tempoGasto[2] = (tempoFinal-tempoInicial)*1000/CLOCKS_PER_SEC; showVetor(vetorOrdDir); //bubble tempoInicial = clock(); trocas[3]=bubbleSort(); tempoFinal = clock(); tempoGasto[3] = (tempoFinal-tempoInicial)*1000/CLOCKS_PER_SEC; showVetor(vetorBubble); //Shell tempoInicial = clock(); trocas[4]=shellSort(); tempoFinal = clock(); tempoGasto[4] = (tempoFinal-tempoInicial)*1000/CLOCKS_PER_SEC; showVetor(vetorShell); printf("Ordenacao tempos e trocas:\nTempo em milisegundos para quick: %f e Quantidade de trocas: %d", tempoGasto[0],trocas[0]); printf("\nTempo em milisegundos para selecao direta: %f e Quantidade de trocas: %d", tempoGasto[1],trocas[1]); printf("\nTempo em milisegundos para insercao direta: %f e Quantidade de trocas: %d", tempoGasto[2],trocas[2]); printf("\nTempo em milisegundos para bubble: %f e Quantidade de trocas: %d", tempoGasto[3],trocas[3]); printf("\nTempo em milisegundos para shell: %f e Quantidade de trocas: %d", tempoGasto[4],trocas[4]); return 0; }
void test_sort_integer_data(){ int data[5] = {5,2,8,1,3}; int expected[5] = {1,2,3,5,8}; bubbleSort(data, 5, sizeof(int), compareInt); ASSERT(0 == memcmp(data,expected,sizeof(expected))); }
int main() { ADT indata[10][10]; bubbleSort(indata[0], 10); return 0; }
void test_sort_float_data(){ float data[5] = {5.2f,2.1f,8.4f,7.7f,8.2f}; float expected[5] = {2.1f,5.2f,7.7f,8.2f,8.4f}; bubbleSort(data, 5, sizeof(float), compareFloat); ASSERT(0 == memcmp(data,expected,sizeof(expected))); }
int main(int argc, char* argv[]) { if (argc < 7) { printf("Numero de argumentos insuficiente\n"); printf("Uso: ./prog <tam_vetor> <chave> <tipo_busca>\n"); printf("\t<tipo> = 1 sequencial, 2 binaria\n\n"); printf("\t<sort> = 1 bubble, 2 insertion\n"); printf("\t<tipo_vetor> = 1 aleatorio, 2 sequencial\n"); printf("\t<tipo_op> = 1 leitura, 2 escrita\n"); return 0; } int n = atoi(argv[1]); // tamanho do vetor int chave = atoi(argv[2]); // numero a buscar nos dados int op = atoi(argv[3]); int sort = atoi(argv[4]); int tipovet = atoi(argv[5]); int rw = atoi(argv[6]); int * vet; if(tipovet == 1) vet = (int *)geraVetorAleatorio(n); else if (tipovet == 2) vet = (int *)geraVetorSequencial(n); printf("exemplos: %d, %d\n", vet[n-2], vet[n-1]); long int pos; clock_t c1; if (op == 1) { fprintf(stdout,"Realizando busca...\n"); fflush(stdout); c1 = clock(); pos = buscaSequencial(vet, n, chave); printf("busca: %.6fs\n", (float)(clock()-c1)/CLOCKS_PER_SEC); } else if (op == 2) { fprintf(stdout,"Ordenando...\n"); fflush(stdout); c1 = clock(); if(sort == 1) bubbleSort(vet, n); // nao usar - dica do Obama else if(sort == 2) insertionSort(vet, n); printf("sort: %.6fs\n", (float)(clock()-c1)/CLOCKS_PER_SEC); fprintf(stdout,"Realizando busca...\n"); fflush(stdout); c1 = clock(); pos = buscaBinaria(vet, 0, n-1, chave); printf("busca: %.6fs\n", (float)(clock()-c1)/CLOCKS_PER_SEC); } if (pos == -1) { printf("Valor nao encontrado\n\n"); } else { printf("Valor encontrado na posicao: %ld\n\n", pos); } free(vet); return 0; }
/* Sort a hand of cards. */ void sortHand(Hand *hand, int handSize){ bubbleSort((void **)(hand -> cards), handSize, (int(*)(void *, void *))compareCards); }
int main(int argc, char * argv[]) { clock_t time; std::vector<int> input; std::vector<int> output; //check for proper number of command-line arguments if(argc != 2) { std::cerr << "Incorrect number of arguments!" << std::endl; return 0; } //read values from input file and populate array std::ifstream file; std::string line; file.open(argv[1]); if(file.is_open()) { while(getline(file, line)) { input.push_back(atoi(line.c_str())); } file.close(); } else { std::cerr << "Unable to open file!" << std::endl; return 0; } std::cout << "The vector has been populated." << std::endl; //perform insertion sort on the vector std::cout << "Insertion sort is beginning." << std::endl; time = clock(); output = insertionSort(input); time = clock() - time; std::cout << "Insertion sort finished in " << double(time) / CLOCKS_PER_SEC << " seconds." << std::endl; if(output.size() <= 10)print(output); //perform selection sort on the vector std::cout << "Selection sort is beginning." << std::endl; time = clock(); output = selectionSort(input); time = clock() - time; std::cout << "Selection sort finished in " << double(time) / CLOCKS_PER_SEC << " seconds." << std::endl; if(output.size() <= 10)print(output); //perform merge sort on the vector std::cout << "Merge sort is beginning." << std::endl; time = clock(); output = mergeSort(input); time = clock() - time; std::cout << "Merge sort finished in " << double(time) / CLOCKS_PER_SEC << " seconds." << std::endl; if(output.size() <= 10)print(output); //perform heapsort on the vector std::cout << "Heapsort is beginning." << std::endl; time = clock(); output = heapSort(input); time = clock() - time; std::cout << "Heapsort finished in " << double(time) / CLOCKS_PER_SEC << " seconds." << std::endl; if(output.size() <= 10)print(output); //perform quicksort on the vector std::cout << "Quicksort is beginning." << std::endl; time = clock(); output = quickSort(input); time = clock() - time; std::cout << "Quicksort finished in " << double(time) / CLOCKS_PER_SEC << " seconds." << std::endl; if(output.size() <= 10)print(output); //perform bubble sort on the vector std::cout << "Bubble sort is beginning." << std::endl; time = clock(); output = bubbleSort(input); time = clock() - time; std::cout << "Bubble sort finished in " << double(time) / CLOCKS_PER_SEC << " seconds." << std::endl; if(output.size() <= 10)print(output); return 0; }
static void top_amp(struct PEXP *pexp, MODEL *model, int start, int end, int n_harm, int pred) { int removed = 0, not_removed = 0; int top, i, j; struct AMPINDEX sorted[MAX_AMP]; /* sort into ascending order of amplitude */ printf("\n"); for(i=start,j=0; i<end; i++,j++) { sorted[j].amp = model->A[i]; sorted[j].index = i; printf("%f ", model->A[i]); } bubbleSort(sorted, end-start); printf("\n"); for(j=0; j<n_harm; j++) printf("%d %f\n", j, sorted[j].amp); /* keep phase of top n_harm, predict others */ for(i=start; i<end; i++) { top = 0; for(j=0; j<n_harm; j++) { if (model->A[i] == sorted[j].amp) { top = 1; assert(i == sorted[j].index); } } #define ALTTOP #ifdef ALTTOP model->phi[i] = 0.0; /* make sure */ if (top) { model->phi[i] = i*pexp->phi1; removed++; } else { model->phi[i] = PI*(1.0 - 2.0*(float)rand()/RAND_MAX); // note: try rand for higher harms removed++; } #else if (!top) { model->phi[i] = 0.0; /* make sure */ if (pred) { //model->phi[i] = pexp->phi_prev[i] + i*N*(model->Wo + pexp->Wo_prev)/2.0; model->phi[i] = i*model->phi[1]; } else model->phi[i] = PI*(1.0 - 2.0*(float)rand()/RAND_MAX); // note: try rand for higher harms removed++; } else { /* need to make this work thru budget of bits */ quant_phase(&model->phi[i], -PI, PI, 3); not_removed++; } #endif } printf("dim: %d rem %d not_rem %d\n", end-start, removed, not_removed); }
/** * Sorts array of n values. */ void sort(int values[], int n) { bubbleSort(values, n); return; }
int main(int argc, char *argv[]){ if(argc == 1){ printf("Very Few Arguments\n"); printf("File Name Missing\n"); exit(1); } list *l = (list *)malloc(sizeof(list)); init(l); path *paths; FILE *fp; int i, j, flag = 0, SIZE = 1024, USIZE = 1024, uCount, uFlag = 0, uFlag_1 = 0, uTmp; char zipFileName[32] = "", *buffer, *binary, *output, *huffList, character, dflag, cnt, *saket; for(i = 0; argv[1][i] != '\0'; i++){ zipFileName[i] = argv[1][i]; } zipFileName[i++] = '.'; zipFileName[i++] = 's'; zipFileName[i++] = 'a'; zipFileName[i++] = 'k'; fp = fopen(argv[1], "r"); if(!fp){ printf("File Doesn't Exist\n"); exit(2); } buffer = (char *)malloc(SIZE * sizeof(char)); i = 0; while((character = getc(fp)) != EOF){ buffer[i] = character; if(i >= (SIZE - 1)){ SIZE *= 2; buffer = (char *)realloc(buffer, SIZE); } if(flag == 0){ append(l, character); flag = 1; } else searchAndAdd(l, character); i++; } buffer[i] = '\0'; fclose(fp); bubbleSort(l); //Initial Sorting According to Weight. l = huffmanTree(l); assignPath(l); paths = (path *)malloc(l->cnt * sizeof(path)); storePath(l->head, paths); huffList = (char *)malloc(SIZE * sizeof(char)); storeHuffList(huffList, paths, l->cnt); binary = (char *)malloc(SIZE * sizeof(char)); binaryConversion(buffer, binary, paths); printf("%s\n", binary); i = strlen(binary); printf("%d\n", i); free(buffer); free(paths); appendRedundantBits(binary); printf("%s\n", binary); output = (char *)malloc(SIZE * sizeof(char)); binToAscii(binary, output); printf("%s\n", output); free(binary); dflag = (char)252; //11111100 cnt = (char)l->cnt;//nodeCount fp = fopen(zipFileName, "w+"); fprintf(fp, "%c", cnt); fprintf(fp, "%s", huffList); fprintf(fp, "%c", dflag); fprintf(fp, "%s", output); free(huffList); free(output); fclose(fp); printf("\nCompressed\n\t-------------------------------------------------------------------------------------------------------------\n"); return 0; }
int main(void) { setvbuf(stdout, NULL, _IONBF, 0); Header head; head.head = NULL; head.tail = NULL; head.nodeCount = 0; int menu = 0, list = 0; do { do { system("cls"); printf("\n Manipular qual lista.\n"); printf("1 - Encadeada.\n"); printf("2 - Sequencial.\n"); scanf("%d", &list); system("cls"); } while (list != 1 && list != 2); system("cls"); printf("\n Digite o numero da opcao desejada.\n"); printf("1 - Inserir elemento no final da lista.\n"); printf("2 - Inserir elemento no inicio da lista.\n"); printf("3 - Remover elemento a partir de um valor.\n"); printf("4 - Imprimir a lista.\n"); printf("5 - Inserir na posicao N.\n"); printf("6 - Remover ultimo da lista.\n"); printf("7 - Remover primeiro da lista.\n"); printf("8 - Remover elemento na posicao N.\n"); printf("9 - Carregar lista do arquivo.\n"); printf("10 - Salvar lista atual em arquivo.\n"); printf("11 - Inserction.\n"); printf("12 - Selection.\n"); printf("13 - Bubble.\n"); printf("14 - Shell.\n"); printf("15 - Quick.\n"); printf("16 - Merge.\n"); printf("17 - Busca Binaria.\n"); printf("18 - Busca Seq.\n"); printf("20 - Sair.\n"); scanf("%d", &menu); system("cls"); switch (menu) { case 1: if (list == 1) { insertNodeAtTheEnd(&head, getValue(), 1); reference(&head); } else { insertSeqAtTheEnd(getValue(), 1); } break; case 2: if (list == 1) { insertNodeAtStart(&head, getValue(), 1); reference(&head); } else { insertSeqAtStart(getValue(), 1); } break; case 3: if (list == 1) { deleteNodeByValue(&head); reference(&head); } else { deleteSeqByValue(); } break; case 4: if (list == 1) { printList(&head); } else { printSeq(); } break; case 5: if (list == 1) { insertAtN(&head, getValue(), getPosIns(&head)); reference(&head); } else { insertSeqAtN(getValue(), getPosSeqIns()); } break; case 6: if (list == 1) { deleteLastNode(&head, 1); reference(&head); } else { deleteLastSeq(1); } break; case 7: if (list == 1) { deleteFirstNode(&head, 1); reference(&head); } else { deleteFirstSeq(1); } break; case 8: if (list == 1) { deleteNodeAtN(&head, getPosDel(&head)); reference(&head); } else { deleteSeqAtN(getPosSeqDel(), 1); } break; case 9: listOptions(&head, list); break; case 10: if (list == 1) { writeLinkedList(&head); } else { writeSequentialList(); } break; case 11: if (list == 1) { linkedInserctionSort(&head); } else { inserctionSort(); } break; case 12: if (list == 1) { linkedSelectionSort(&head); } else { selectionSort(); } ; break; case 13: if (list == 1) { linkedBubbleSort(&head); } else { bubbleSort(); } break; case 14: if (list == 1) { linkedShellSort(&head); } else { shellSort(); } break; case 15: if (list == 1) { linkedCallQuickSort(&head); } else { callQuickSort(); } break; case 16: if (list == 1) { linkedCallMergeSort(head.nodeCount); } else { callMergeSort(); } break; case 17: if (list == 1) { linkedCallBynarySearch(&head); } else { callBynarySearch(); } break; case 18: if (list == 1) { searchNodeByValue(&head); } else { searchByValue(); } break; } } while (menu != 20); wipeList(&head); return EXIT_SUCCESS; }
int main() { //variable declrations int myArray[50], myArray2[] = {1, 2, 3, 4, 5}, myArray3[] = {1, 2, 3, 4, 5}; int index, searchResults, key; //testing fillArray fillArray(myArray, 50, 1000); //testing printNperline() printf("Before sort printing 10 per line\n"); printNperline(myArray, 50, 10); printf("\n"); printf("Before sort printing 4 per line\n"); printNperline(myArray, 50, 4); printf("\n"); printf("Before sort printing 6 per line\n"); printNperline(myArray, 50, 6); //testing bubble sort on myArray bubbleSort(myArray, 50); //printing myArray after sort printf("\n"); printf("After sort printing 6 per line\n"); printNperline(myArray, 50, 6); printf("\n"); printf("After sort printing 15 per line\n"); printNperline(myArray, 50, 15); printf("\n"); printf("After sort printing 11 per line\n"); printNperline(myArray, 50, 11); //testing linear search printf("\n"); printf("Testing linear search for 82\n"); key = 82; searchResults = linearSearch(myArray, 50, key); if(searchResults >= 0) printf("The key value %d was found in myArray at position %d\n", key, searchResults); else printf("The key value %d was not found in myArray\n", key); printf("\n"); printf("Testing linear search for %d which is the last element in the array\n", myArray[49]); key = myArray[49]; searchResults = linearSearch(myArray, 50, key); if(searchResults >= 0) printf("The key value %d was found in myArray at position %d\n", key, searchResults); else printf("The key value %d was not found in myArray\n", key); printf("\n"); printf("Testing linear search for %d which is the first element in the array\n", myArray[0]); key = myArray[0]; searchResults = linearSearch(myArray, 50, key); if(searchResults >= 0) printf("The key value %d was found in myArray at position %d\n", key, searchResults); else printf("The key value %d was not found in myArray\n", key); //testing shiftElements printf("\n"); printf("Shifting the elements in the array right 6 elements\n"); shiftElements(myArray, 50, 6); printNperline(myArray, 50, 10); printf("\n"); printf("Shifting the elements in the array left 4 elements\n"); shiftElements(myArray, 50, -4); printNperline(myArray, 50, 10); }
int main(int argc, char** argv) { int i, n; int* A, *temp, *temp2; clock_t start, end; double elapsed_time, t1, t2; MPI_Init(NULL, NULL); // Find out rank, size int world_rank; MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); int world_size; MPI_Comm_size(MPI_COMM_WORLD, &world_size); int elements_per_proc = N/world_size; t1 = MPI_Wtime(); A = (int *)malloc(sizeof(int)*N); temp = (int *)malloc(sizeof(int)*N); temp2 = (int *)malloc(sizeof(int)*N); if (A == NULL) { printf("Fail to malloc\n"); exit(1); } //create an array of Numbers if process is 0 if (world_rank == 0) { for (i=N-1; i>=0; i--) A[N-1-i] = i; } // Create a buffer that will hold a subset of the numbers int *sub_bubble_nums = malloc(sizeof(int) * elements_per_proc); // Scatter the random numbers to all processes MPI_Scatter(A, elements_per_proc, MPI_INT, sub_bubble_nums, elements_per_proc, MPI_INT, 0, MPI_COMM_WORLD); // Sort the sub array with bubble sort bubbleSort(sub_bubble_nums, elements_per_proc); // Gather all partial averages down to the root process MPI_Gather(sub_bubble_nums, elements_per_proc, MPI_INT, temp, elements_per_proc, MPI_INT, 0, MPI_COMM_WORLD); // Compute the total average of all numbers. if (world_rank == 0) { mergeSort(N,temp,temp2); //bubbleSort(temp,N); t2 = MPI_Wtime(); printf( "Elapsed time MPI_Wtime is %f\n", t2 - t1 ); } if (isSorted(temp, N)) printf("%i is sorted\n",world_rank); else printf("Array is NOT sorted\n"); MPI_Finalize(); return 0; }
int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); qreal ax = -5, bx = 5; TVect b; TVect testVector = {-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 9}; char *itemMenu[] = { "A - Загрузить тестовый вектор", "B - Загрузить вектор с помощью генератора случайных чисел", "C - Сортировать вектор с помощью метода выбора", "D - Сортировать вектор с помощью метода пузырька", "E - Сортировать вектор с помощью метода вставки", "F - Сохранить вектор в файле", "G - Считать вектор из файла", "X - Выйти из программы" }; char *hotKeys = "ABCDEFG"; char selectedBranch; initRandom(); while (true) { selectedBranch = menu(itemMenu, hotKeys); switch (selectedBranch) { case 'A': cout << "Загрузка тестового вектора" << endl; loadTestVector(b, testVector); printArray(b); break; case 'B': cout << "Загрузка вектора с помощью генератора случайных чисел" << endl; fillArrayRand(b, ax, bx); printArray(b); break; case 'C': cout << "Сортировать вектор с помощью метода выбора" << endl; cout << "Вектор до сортировки" << endl; printArray(b); selectionSort(b); cout << "Вектор после сортировки" << endl; printArray(b); break; case 'D': cout << "Сортировать вектор с помощью метода пузырька" << endl; cout << "Вектор до сортировки" << endl; printArray(b); bubbleSort(b); cout << "Вектор после сортировки" << endl; printArray(b); break; case 'E': cout << "Сортировать вектор с помощью метода вставки" << endl; cout << "Вектор до сортировки" << endl; printArray(b); insertionSort(b, N); cout << "Вектор после сортировки" << endl; printArray(b); break; case 'F': cout << "Сохранить вектор в файле" << endl; cout << "Введите имя файла:"; { string fileName = ""; cin >> fileName; char *cstr = new char[fileName.length() + 1]; strcpy(cstr, fileName.c_str()); if (writeVectFile(cstr, b)) { cout << "Вектор сохранён в файле"<< "\n"; } else { cout << "При сохранении произошла ошибка\n"; } delete [] cstr; } break; case 'G': cout << "Считать вектор из файла" << endl; cout << "Введите имя файла:"; { string fileName = ""; cin >> fileName; if (readVectFile(fileName,b)) { cout << "Вектор прочитан из файла"<< "\n"; } else { cout << "При считывании произошла ошибка\n"; } } break; default: break; } } initRandom(); fillArrayRand(b, ax, bx); printArray(b); //selectionSort(b); bubbleSort(b); cout<<"After selection sorting"<<endl; printArray(b); cout<<"Insertion sorting"<<endl; fillArrayRand(b, ax, bx); cout<<"Before:"<<endl; printArray(b); cout<<"After:"<<endl; insertionSort(b, N); printArray(b); writeVectFile("/home/ametovii/Temp/vect.txt", b); return 0; }
//////////////////////////////////////////////////////////////////////////////// // Interface function //////////////////////////////////////////////////////////////////////////////// extern "C" void mergeSortHost( uint *dstKey, uint *dstVal, uint *bufKey, uint *bufVal, uint *srcKey, uint *srcVal, uint N, uint sortDir ){ uint *ikey, *ival, *okey, *oval; uint stageCount = 0; for(uint stride = SHARED_SIZE_LIMIT; stride < N; stride <<= 1, stageCount++); if(stageCount & 1){ ikey = bufKey; ival = bufVal; okey = dstKey; oval = dstVal; }else{ ikey = dstKey; ival = dstVal; okey = bufKey; oval = bufVal; } printf("Bottom-level sort...\n"); memcpy(ikey, srcKey, N * sizeof(uint)); memcpy(ival, srcVal, N * sizeof(uint)); for(uint pos = 0; pos < N; pos += SHARED_SIZE_LIMIT) bubbleSort(ikey + pos, ival + pos, umin(SHARED_SIZE_LIMIT, N - pos), sortDir); printf("Merge...\n"); uint *ranksA = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); uint *ranksB = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); uint *limitsA = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); uint *limitsB = (uint *)malloc( getSampleCount(N) * sizeof(uint) ); memset(ranksA, 0xFF, getSampleCount(N) * sizeof(uint)); memset(ranksB, 0xFF, getSampleCount(N) * sizeof(uint)); memset(limitsA, 0xFF, getSampleCount(N) * sizeof(uint)); memset(limitsB, 0xFF, getSampleCount(N) * sizeof(uint)); for(uint stride = SHARED_SIZE_LIMIT; stride < N; stride <<= 1){ uint lastSegmentElements = N % (2 * stride); //Find sample ranks and prepare for limiters merge generateSampleRanks(ranksA, ranksB, ikey, stride, N, sortDir); //Merge ranks and indices mergeRanksAndIndices(limitsA, ranksA, stride, N); mergeRanksAndIndices(limitsB, ranksB, stride, N); //Merge elementary intervals mergeElementaryIntervals(okey, oval, ikey, ival, limitsA, limitsB, stride, N, sortDir); if( lastSegmentElements <= stride ) { //Last merge segment consists of a single array which just needs to be passed through memcpy(okey + (N - lastSegmentElements), ikey + (N - lastSegmentElements), lastSegmentElements * sizeof(uint)); memcpy(oval + (N - lastSegmentElements), ival + (N - lastSegmentElements), lastSegmentElements * sizeof(uint)); } uint *t; t = ikey; ikey = okey; okey = t; t = ival; ival = oval; oval = t; } free(limitsB); free(limitsA); free(ranksB); free(ranksA); }