int main(int argc, char **argv)
{
redcord_t d[SIZE] = {{1, "one"}, {3, "three"}, {2, "two"}, {-9, "neg-nine"},\
{28, "twenty-eight"}, {-100, "neg-hundred"}, {44, "forty-four"},\
{0, "zero"}, {12, "twelve"}, {99, "gogo"}, {28, "gona"}, {0, "home"},\
{-1, "bit"}, {-9, "44"}, {8, "99"}, {3, "ff"}, {5, "lk"}, {11, "wish"}};
sq_list L;
char ch_sel;
int i = 0;
int incre[INCRE_SIZE] = {4, 3, 1}; //increasement for shell sorting
struct timeval time_start;
struct timeval time_end;
for (i = 1; i < SIZE + 1; i++)
{
L.data[i] = d[i - 1];
}
L.length = SIZE;
printf("initial sq_list:\n");
display(L);
printf("Input sorting mode(y:ascend or n:descend):");
while (1 != scanf("%c%*c", &ch_sel) && ch_sel != EOF)
{
while (getchar())
{
;
}
}
if (ch_sel == 'y' || ch_sel == 'Y')
{
gettimeofday(&time_start, NULL);
shell_sort(&L, incre, INCRE_SIZE, ASCEND);
gettimeofday(&time_end, NULL);
printf("shell sorting result:(time = %lfs)\n", TIME_INTERVAL(time_start, time_end));
display(L);
}
else if (ch_sel == 'n' || ch_sel == 'N')
{
gettimeofday(&time_start, NULL);
shell_sort(&L, incre, INCRE_SIZE, DESCEND);
gettimeofday(&time_end, NULL);
printf("shell sorting result:(time = %lfs)\n", TIME_INTERVAL(time_start, time_end));
display(L);
}
else
{
printf("Invalid Input!\n");
}
return 0;
}
char *word_default(void)
{
dict_elem_t *head_p;
int total;
dict_elem_t *elem_fund;
total = get_elem_count("dict.txt");
head_p = malloc(total * sizeof(*head_p));
head_p = read_to_mem_from_txt("dict.txt", head_p, total);
shell_sort(head_p, 0, total-1);
printf("\n\t\t\tWelcome enjoy this dictionary\n\n");
printf("input you word ,exit is quit... \n");
while(1) {
elem_fund = search(head_p, total); //退出，说明没找到，继续找
if (elem_fund == NULL) {
//add_ne
continue;
}
else if ((unsigned)elem_fund == 1) {
distory(head_p, total);
return (char *) 1;
} else if ((unsigned)elem_fund == 2) {
puts("error");
distory(head_p, total);
return (char *)2;
} else {
print_one_elem(elem_fund);
}
}
}
int main ()
{
int i, n;
int *polje;
do {
printf ("Unesi velicinu polja: ");
scanf ("%d", &n);
} while (n<=0);
if ((polje = malloc (n * sizeof (int))) == NULL) {
fprintf (stderr, "Ne mogu alocirati polje");
exit (1);
}
srand ((unsigned) time (NULL));
printf ("Generiram polje...\n");
for (i=0 ; i<n ; ++i)
polje[i] = rand () % 1000;
printf ("Sortitam polje...\n");
shell_sort (polje, n);
/* ispisi sortirano polje */
for (i=0 ; i<n ; i++)
printf ("%d ", polje[i]);
printf ("\n");
return 0;
}
void shell_insertion_sort(elem_t *a, const int start, const int end) {
int gap = end - start;
while(gap > 1) {
gap = gap / 3 + 1;
shell_sort(a, start, end, gap);
}
}
int main( int argc, char * argv[] )
{
int pid = getpid();
sprintf( fn, "/proc/%d/stat", pid );
data = malloc( 590000000L * sizeof(int) );
setbuffer(stdout, NULL, 0);
FILE * fp;
fp = fopen("result.txt", "w");
setbuffer(fp, NULL, 0);
unsigned long i, j, n;
double t[100][50];
for ( i = 1<<17, n = 0; i <= (1<<27); i <<= 1, n++ )
{
printf("%d:", i);
for ( j = 0; j < 20; ++j )
{
t[n][j] = shell_sort( data, i );
if ( j != 0 ) printf("\b\b");
printf( "%.2d", j );
fprintf(fp, "%.3f ", t[n][j]);
}
putchar('\n');
fputc('\n', fp);
}
free(data);
return 0;
}
int main(void) {
int len = 50, array[len], backup[len];
random_int_array(array, len, 100);
for(int i = 0; i < len; i++) { backup[i] = array[i]; }
int_array_output(array, len);
// insert_sort(array, len);
shell_sort(array, len);
int_array_output(array, len);
int idx = binary_search(array, len, 10);
printf("%d \n", idx);
/*
if(in_array(array, backup, len) == false) {
printf("Fail in test \n");
}
*/
if(assert_int_array_increasing(array, len) == false) {
printf("Fail in test \n");
}
int a = 2, b = 3;
printf("(%d + %d) / 2 = %d \n", a, b, (int)floor((a + b) / 2.0));
return 0;
}
int main(int argc, char *argv[]) {
/* Benytter en pointer for å lage en referanse til vår allokerte data.*/
int *a;
int i;
/* samme som array = new int[length]; i c++. Allokerer plass til et array i minnet.
* størrelsen på denne plassen bestemmes av lengden på input(minus en, fordi første
* tegn i argc er navnet), * størrelse av int's, funnet av sizeof. Sizeof
* returnerer størrelsen i bytes. Det som kan er forvirrende ved denne setningen er
* hvorfor man må gjøre det på slik måte. Først og fremst er det mulig å bare skrive
* int a[length]; men i C er et array egentlig bare en pointer til del i minnet. Så
* i vårt tilfelle har vi laget en pointer med "int *a" og deretter forteller vi i den
* påfølgende setningen at vi vil reservere plass i minnet, plassen vi reserverer baseres
* hvilket filsystem som benyttes */
a = (int*) malloc((argc - 1) * sizeof(int));
for (i = 0; i < argc - 1; i++){
*(a+i) = atoi(argv[i + 1]);
}
shell_sort(a, argc - 1);
for (i = 0; i < argc - 1; i++)
printf("%d ", a[i]);
printf("\n");
/* Det er viktig å benytte free for å fjerne variabler fra minnet vi ikke
* lenger har behov for. Pointers mister referansen og Computeren vet ikke
* om vi trenger dem mer. */
free(a);
return 0;
}
VArray *
sortVerticesDegreeDesc(VArray *va, UInt *d)
{
shell_sort(va->array, va->length,
sizeof(Vertex), d, &vertex_compare_desc);
return va;
}
int main(int argc,char *argv[])
{
int N=atoi(argv[1]);
item_t *array=malloc(N*sizeof(*array));
item_t *array_2=malloc(N*sizeof(*array_2));
int i;
FILE *input;
clock_t c1,c2;
input=fopen("merged_sequence.dat","r");
srand((unsigned)time(NULL));
for(i=0;i<N;i++){
array[i]=rand()%N;
}
copy_array(array_2,array,N);
while(fgets(buffer,BUFFER_SIZE,input) != NULL){
copy_array(array,array_2,N);
c1=clock();
shell_sort(array,0,N-1);
c2=clock();
printf("sequence: %s",buffer);
printf("sort time: %fs\n\n",(double)(c2-c1)/CLOCKS_PER_SEC);
}
return(0);
}
/**
* Check multiple rectangles and combine them to give one paragraph
* for all text detected from rectangles
*/
char *paraof_ocrtext(struct cc_subtitle *sub)
{
int i;
int len = 0;
char *str;
struct cc_bitmap* rect;
shell_sort(sub->data, sub->nb_data, sizeof(struct cc_bitmap), compare_rect_by_ypos, NULL);
for(i = 0, rect = sub->data; i < sub->nb_data; i++, rect++)
{
if(rect->ocr_text)
len += strlen(rect->ocr_text);
}
if(len <= 0)
return NULL;
else
{
str = malloc(len+1);
if(!str)
return NULL;
*str = '\0';
}
for(i = 0, rect = sub->data; i < sub->nb_data; i++, rect++)
{
strcat(str, rect->ocr_text);
freep(&rect->ocr_text);
}
return str;
}
int main()
{
int select, size, *test;
while (select = menu())
{
size = get_integer("Array size");
while(size <= 0)
size = get_integer("Array size must bigger then zero");
test = init_array(test, size);
printf("Before sort:\n");
print_array(test, size);
switch (select) {
case 1:
insertion_sort(test,size);
break;
case 2:
shell_sort(test, size);
break;
case 3:
heap_sort(test, size);
break;
case 4:
merge_sort(test, size);
break;
case 5:
quick_sort(test, size);
break;
}
printf("After sort:\n");
print_array(test, size);
}
return 0;
}
void main()
{
int *array;
int i, N;
setlocale(LC_ALL, "Russian");
printf("Введите размер массива: ");
scanf("%d", &N);
array = (int *) malloc(N * sizeof(int));
filling_array(array, N);
printf("Исходный массив: ");
for (i=0; i<N; i++)
printf("%d ", array[i]);
shell_sort(array, N);
printf("\n\n");
printf("Отсортированный массив: ");
for (i=0; i<N; i++)
printf("%d ", array[i]);
free(array);
array = NULL;
_getch();
}
/**
* Put key and value to map
*/
void map_put(Map * ptr, const char * key, const char * value)
{
if (key == NULL || value == NULL)
return;
/* search for key */
#if 1
if (ptr->length != 0){
MapNode * keyNode = (MapNode *)New(sizeof(MapNode));
keyNode->key = string_new(key);
printf("search..%s\n", key);
int iret = binary_search(ptr->data, ptr->length, keyNode,
sizeof(MapNode), &MapNodeCmp);
printf("search..end %d\n", iret);
if (iret != -1) {
printf("copy..\n");
(ptr->data + iret)->value->copy((ptr->data + iret)->value, value);
printf("copy..end\n");
keyNode->key->destory(keyNode->key);
free(keyNode);
return;
}
keyNode->key->destory(keyNode->key);
free(keyNode);
}
#endif
/* put into map */
if (ptr->length >= ptr->capacity) {
ptr->data = (MapNode *)realloc(ptr->data, sizeof(MapNode) * ((ptr->capacity + 1) * 2));
ptr->capacity = (ptr->capacity + 1) * 2;
}
(ptr->data + ptr->length)->key = string_new(key);
(ptr->data + ptr->length)->value = string_new(value);
ptr->length += 1;
shell_sort(ptr->data, ptr->length, sizeof(MapNode), &MapNodeCmp);
}
void main()
{
int op;
clrscr();
do
{
printf("\n1:Insertion Sort\t2:Radix Sort\t3:Shell Sort\t4:Display\t5:Exit\n");
printf("Enter the option");
scanf("%d",&op);
switch(op)
{
case 1:insertion_sort();
break;
case 2:radix_sort();
break;
case 3:shell_sort();
break;
case 4:display();break;
case 5:exit();
break;
}
}
while(op);
getch();
}
int main() {
int v[11] = {1, 6, 39, 23, 56, 49, 50, 38, 10, 8, 66};
shell_sort(v, 10);
for(int i=0; i<10; i++) {
printf("%d", v[i]);
printf("%c", i == 9 ? '\n' : ',');
}
return 0;
}
void
sort ()
{
size_t *oldlist, i;
oldlist = xmalloc (msgset.count * sizeof (*oldlist));
memcpy (oldlist, msgset.list, msgset.count * sizeof (*oldlist));
switch (algorithm)
{
case ARG_QUICKSORT:
qsort(msgset.list, msgset.count, sizeof(msgset.list[0]),
comp);
break;
case ARG_SHELL:
shell_sort();
break;
}
switch (action)
{
case ACTION_LIST:
for (i = 0; i < msgset.count; i++)
list_message (msgset.list[i]);
break;
default:
/* Install signal handlers */
signal (SIGINT, sighandler);
signal (SIGQUIT, sighandler);
signal (SIGTERM, sighandler);
if (verbose)
fprintf (stderr, _("Transpositions:\n"));
for (i = 0, got_signal = 0; !got_signal && i < msgset.count; i++)
{
if (msgset.list[i] != oldlist[i])
{
size_t old_num, new_num;
mu_message_t msg;
mu_mailbox_get_message (mbox, oldlist[i], &msg);
mh_message_number (msg, &old_num);
mu_mailbox_get_message (mbox, msgset.list[i], &msg);
mh_message_number (msg, &new_num);
transpose (i, oldlist[i]);
if (verbose)
fprintf (stderr, "{%s, %s}\n",
mu_umaxtostr (0, old_num),
mu_umaxtostr (1, new_num));
if (action == ACTION_REORDER)
swap_message (old_num, new_num);
}
}
}
}
main()
{
int i;
int list[N] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
shell_sort(list, N);
printf("排序結果為：");
for(i = 0; i < N; i++)
printf("%d ", list[i]);
getchar();
}
int main( ) {
int a[] = {6, -2, 3, 5, 7, 4, 3, 10, -1, 8};
shell_sort(a, 10);
for (int i = 0; i < 10; i++)
std::cout << a[i] << " ";
return 0;
}
int main(){
int i;
int a[11] = {9, 20, 5, 4, 3, 55, 34, 4, 1, 11, 2};
shell_sort(a, 11);
for(i = 0; i < 11; i++){
printf("%d番目の値: %d\n", i, a[i]);
}
return 0;
}
int main() {
n=1000000;
printf("\n N= %d\n\n",n);
random();
time1=clock();
qsort(a, n, sizeof(int), cmpfunc);
time2=clock();
printf("\n qsort, standart:\n Time: %f s\n",(double)(time2-time1)/CLOCKS_PER_SEC);
random();
time1=clock();
shell_sort();
time2=clock();
printf("\n Shell sort:\n Time: %f s\n",(double)(time2-time1)/CLOCKS_PER_SEC);
// Medium Sort
n=100000;
printf("\n\n N= %d\n\n",n);
random();
time1=clock();
quickSort(a,0,n-1);
time2=clock();
printf("\n QuickSort:\n Time: %f s\n",(double)(time2-time1)/CLOCKS_PER_SEC);
// Slooooooooooooooow Sort
n=30000;
printf("\n\n N= %d\n\n",n);
random();
time1=clock();
bubble_sort();
time2=clock();
printf("\n Bubble sort:\n Time: %f s\n",(double)(time2-time1)/CLOCKS_PER_SEC);
random();
time1=clock();
insertion_sort();
time2=clock();
printf("\n Insertion sort:\n Time: %f s\n",(double)(time2-time1)/CLOCKS_PER_SEC);
random();
time1=clock();
selection_sort();
time2=clock();
printf("\n Selection sort:\n Time: %f s\n",(double)(time2-time1)/CLOCKS_PER_SEC);
printf("\n");
return 0;
}
int main (void)
{
int arr[10] = {4, 2, 1, 5, 9, 4, 0, 3, 8, 7};
int i;
shell_sort(arr, 10);
for (i = 0; i < 10; i++)
{
printf("%4d", arr[i]);
}
putchar('\n');
return 0;
}
int
main()
{
int nums[] = {2, 4, 3, 1, 5, 9, 10, 8, 7, 6};
int len = arr_len(nums);
print_arr(nums, len);
shell_sort(nums, len);
print_arr(nums, len);
return 0;
}
int main(int argc, char *argv[])
{
int i;
int a[] = {88, 6, 1, 9, 4, 1, 45, 21};
shell_sort(a, LEN(a));
for(i = 0; i < LEN(a); i++)
printf("%d ", a[i]);
printf("\n");
return 0;
}
int main(int argc, char** argv) {
if(argc != 3)
{
exit(INCORRECT_NUMBER_OF_COMMAND_LINE_ARGUMENTS);
}
FILE* fp1 = fopen(argv[1], "r+");
FILE* fp2 = fopen(argv[2], "r+");
/*Error check for a null file pointer*/
if(fp1 == NULL || fp2 == NULL)
{
exit(FILE_FAILED_TO_OPEN);
}
Vector vec1;
Vector vec2;
vec1 = parse_ints(fp1);
vec2 = parse_ints(fp2);
shell_sort(&vec1, vec1.size);
shell_sort(&vec2, vec2.size);
compare(vec1, vec2, vec1.size, vec2.size);
free(vec1.data);
free(vec2.data);
fclose(fp1);
fclose(fp2);
if(fp1->_ptr != NULL || fp2->_ptr != NULL)
{
exit(FILE_FAILED_TO_CLOSE);
}
return (EXIT_SUCCESS);
}
void Sort::insertSort_Shell(RecType *R, int n)
{
traverseArray(R,n);
//初始增量
int d = n/2;
//增量大于1
while (d >= 1)
{
shell_sort(R, d, n);
d = d/2;
}
traverseArray(R,n);
}
int main()
{
int a[MAXN];
int cnt;
rand_data(a, MAXN);
printf("befor:\n");
print(a, MAXN);
cnt = shell_sort(a, MAXN);
printf("after shell sort, %d times\n", cnt);
print(a, MAXN);
return 0;
}
void main()
{
int arr[size], i;
printf("Enter the elements to be sorted:");
for (i = 0;i < size;i++)
{
scanf("%d", &arr[i]);
}
shell_sort(arr);
printf("The array after sorting is:");
for (i = 0;i < size;i++)
{
printf("\n%d", arr[i]);
}
}
int main(int argc, char *argv[])
{
int i = 0;
int *a = NULL;
a = (int *)malloc((argc - 1) * sizeof(int));
for (i = 0; i < argc - 1; i++)
a[i] = atoi(argv[i + 1]);
shell_sort(a, argc);
for (i = 0; i < argc - 1; i++)
printf("%d ", a[i]);
printf("\n");
free(a);
return 0;
}
int main( int argc, char * argv[] )
{
int pid = getpid();
sprintf( fn, "/proc/%d/stat", pid );
data = malloc( 100000000LL * sizeof(int) );
FILE * fp = fopen( "in.dat", "r" );
int i;
//for ( i = 0; i < 1000000; ++i )
// fscanf( fp, "%d", &data[i] );
double t = shell_sort( data, 100000000 );
printf( "%f", t );
free(data);
return 0;
}
int main(void)
{
int arr[NUM_COUNT] = {0};
int i, count;
struct timeval start, end;
int used_time;
FILE *in_file, *out_file;
if((in_file = fopen("rand_num.txt","r")) == NULL)
{
printf("error:open the input file failed!\n");
exit(1);
}
if((out_file = fopen("sort_num.txt","w+")) == NULL)
{
printf("error:open the input file failed!\n");
exit(1);
}
count = NUM_COUNT;
for(i = 0; i < count; i++)
{
fscanf(in_file, "%d", &arr[i]);
}
gettimeofday(&start, NULL);
shell_sort(arr,count);
gettimeofday(&end, NULL);
used_time = 1000000 * (end.tv_sec - start.tv_sec) + end.tv_usec - start.tv_usec;
printf("The shell sort time: %d us\n",used_time);
for(i = 0; i < count; i++)
{
fprintf(out_file, "%d ", arr[i]);
}
fclose(in_file);
fclose(out_file);
return 0;
}
