int main() { Queue myQueue; queue_init(&myQueue); assert(queue_isempty(&myQueue)); queue_enqueue(&myQueue, 9); assert(!queue_isempty(&myQueue)); printf("%d is top\n", queue_first(&myQueue)); queue_enqueue(&myQueue, 1); queue_enqueue(&myQueue, 2); queue_enqueue(&myQueue, 3); queue_enqueue(&myQueue, 4); queue_enqueue(&myQueue, 5); queue_enqueue(&myQueue, 6); queue_enqueue(&myQueue, 7); queue_print(&myQueue); printf("%d dequeued\n", queue_dequeue(&myQueue)); printf("%d dequeued\n", queue_dequeue(&myQueue)); printf("%d dequeued\n", queue_dequeue(&myQueue)); printf("%d dequeued\n", queue_dequeue(&myQueue)); queue_print(&myQueue); queue_destroy(&myQueue); queue_print(&myQueue); }
int main (int argc, const char * argv[]) { //Stack int numbers[NUMLEN] = { 15, 10, 5, 100 }; int i; Stack *stack = stack_create(); for(i = 0; i < NUMLEN; i++) { printf("pushing: %u\n", numbers[i]); stack_push(stack, numbers[i]); } printf("\n"); stack_print(stack); while(i--) { unsigned int result = stack_pop(stack); if(UINT_MAX == result) { break; } printf("popping: %u\n", result); } stack_destroy(stack); //Queue Queue *queue = queue_create(); for(i = 0; i < NUMLEN; i++) { printf("\nenqueueing: %u", numbers[i]); queue_enqueue(queue, numbers[i]); } queue_print(queue); while(i--) { unsigned int result = queue_dequeue(queue); if(UINT_MAX == result) { break; } printf("dequeuing: %u\n", result); } queue_print(queue); queue_destroy(queue); return 0; }
void queue_test_print(void) { queue_t* q = queue_init(q_compare, q_print, q_clone, q_destroy); CU_ASSERT (q != NULL); CU_ASSERT (queue_push(q, queue_test_s1) != NULL); CU_ASSERT (queue_push(q, queue_test_s2) != NULL); CU_ASSERT (queue_push(q, queue_test_s3) != NULL); CU_ASSERT (queue_push(q, queue_test_s4) != NULL); queue_print(NULL, stdout); queue_print(q, stdout); CU_ASSERT (queue_destroy(q) == 0); }
/* return no of items in control queue, including the newly inserted one, or -1 upon trouble. */ int queue_insert(pthread_t tid) { struct queue_item *ii, *tmp; int qd; tmp=queue_create_item(tid); if(!tmp) { diag(SS_MAIN|ERR,"Could not create control queue item"); return -1; } pthread_mutex_lock(&queue_mtx); if(!queue_head) { queue_head=tmp; thread_in_control=tid; } else { ii=queue_head; while(ii->next) ii=ii->next; ii->next=tmp; } qd=++queue_depth; #if DEBUG_DUMP_QUEUE queue_print(); #endif pthread_mutex_unlock(&queue_mtx); diag(SS_MAIN|DEBUG,"control queue depth %d after insertion\n",queue_depth); return qd; }
int main(void) { user_tests(); queue_tests(); user_t user1 = user_new(1); user_t user2 = user_new(2); queue_t pQueue = queue_new(); clock_t start; fflush(stdout); char c = 'f'; while(c != '-') { start = clock(); while(clock() - start < CLOCKS_PER_SEC/30) { user_checkComm(user1, user2, pQueue); } queue_print(pQueue); printf("\n"); queue_countNull(pQueue); c = getch(); } user_delete(user1); user_delete(user2); queue_delete(pQueue); return 0; }
int reaction(queue_t * self){ if (compare(self)==1){ for(int i = getHead(self); i < getTail(self)-1;i++) queue_remove(self); queue_print(self); } return 0; }
void printQueue(queue_t * self, int sum) { system("cls"); printf("Queue: \n"); queue_print(self); printf("\nSum : %d", sum); Sleep(500); }
int main() { Item array[] = {1,2,3,4,5,6,7,8,9,0}; const uint32_t size = sizeof(array)/sizeof(Item); Queue *queue = queue_init(); queue_create(queue, array, size); queue_print(queue); queue_destroy(queue); return 0; }
int main() { // initialize queue_t testQ; queue_init(&testQ); // add some items queue_enqueue(&testQ, "item 1"); queue_enqueue(&testQ, "item 2"); queue_enqueue(&testQ, "item 3"); // print the queue queue_print(&testQ); // dequeue queue_dequeue(&testQ); // print the queue printf("After dequeueing once:\n"); queue_print(&testQ); printf("The size of the queue: %d\n", queue_size(&testQ)); // the front of the queue printf("The front of the queue: %s\n", (char *)queue_front(&testQ)); // the back of the queue printf("The back of the queue: %s\n", (char *)queue_back(&testQ)); // add some more items queue_enqueue(&testQ, "item4"); queue_enqueue(&testQ, "item5"); printf("After queueing twice more:\n"); queue_print(&testQ); // free up the queue's memory queue_destroy(&testQ); return 0; }
int main(void){ fprintf(stdout, "Test Case 1\n===========================\n"); Queue *empty_queue = queue_new_empty_queue(); queue_print(empty_queue); queue_destroy(empty_queue); Queue *queue_a = queue_new_empty_queue(); for (int i=1; i<=10; i++){ int *value = (int *)malloc(sizeof(int)); *value = i; queue_enqueue(queue_a, value); } queue_print(queue_a); fprintf(stdout, "\nTest Case 3\n===========================\n"); for (int i=1; i<=5; i++){ void *data = NULL; queue_dequeue(queue_a, &data); fprintf(stdout, "dequeued: %d\n", *(int *)data); // Here, using free() is not a good idea. free(data); } queue_print(queue_a); fprintf(stdout, "\nTest Case 4\n===========================\n"); for (int i=1; i<=5; i++){ void *data = NULL; queue_dequeue(queue_a, &data); fprintf(stdout, "dequeued: %d\n", *(int *)data); // Here, using free() is not a good idea. free(data); } queue_print(queue_a); fprintf(stdout, "\nTest Case 5\n===========================\n"); queue_destroy(queue_a); queue_print(queue_a); return 0; }
int main(void) { A* a = malloc(sizeof(A)), *b = malloc(sizeof(A)), *c = NULL; List* l = list_init(); Stack* s = stack_init(); Queue* q = queue_init(); DoubleLinkedList* d = dll_init(); printf("a: %d\nB: %d\nc: %d\n", (int)a, (int)b, (int)c); a->a1 = 1; a->a2 = 'c'; b->a1 = 2; b->a2 = 'a'; printf("\n=== LIST TEST ===\n"); list_add(l, a, 0); list_append(l, b); list_remove(l, 0); list_print(l); c = list_get(l, 0); printf("c: %d\n", (int)c); list_delete(l); printf("\n=== STACK TEST ===\n"); stack_push(s, b); stack_push(s, a); stack_pop(s); stack_print(s); c = stack_peek(s); printf("c: %d\n", (int)c); stack_delete(s); printf("\n=== QUEUE TEST ===\n"); queue_push(q, a); queue_push(q, b); queue_pop(q); queue_print(q); c = queue_peek(q); printf("c: %d\n", (int)c); queue_delete(q); printf("\n=== DOUBLE LINKED LIST TEST ===\n"); dll_add(d, b, 0); dll_prepend(d, a); dll_remove(d, 1); dll_print(d); c = dll_get(d, 0); printf("c: %d\n", (int)c); dll_delete(d); free(a); free(b); return 0; }
int main() { const int SIZE = 6; QUEUE queue; queue.size = SIZE; queue_init(&queue); char isRunning = 1; while (isRunning) { int choice; char * data; printf("\n1. 삽입\n2. 꺼내기\n3. 출력\n4. 전부 삭제\n5. 끝\n입력: "); scanf("%d", &choice); getchar(); switch (choice) { case 1: if (queue_isFull(&queue)) { printf("큐가 꽉 찼습니다\n"); break; } printf("데이터를 입력해주세요: "); data = (char *) malloc(256); gets(data); queue_add(&queue, data); break; case 2: if (queue_isEmpty(&queue)) { printf("큐가 비었습니다\n"); break; } data = queue_remove(&queue); printf("읽은 데이터: %s\n", data); free(data); break; case 3: queue_print(&queue); break; case 4: // This doesn't free the queue, but whatever. queue_reset(&queue); break; case 5: isRunning = 0; break; } } }
void queue_remove(pthread_t tid) { struct queue_item *prev, *ii; int found=0; pthread_mutex_lock(&queue_mtx); ii=prev=queue_head; while(ii && !pthread_equal(tid,ii->tid)) { prev=ii; ii=ii->next; } if(pthread_equal(tid,ii->tid)) { found=1; if(ii==queue_head) { queue_head=queue_head->next; free(ii); /* note: we used to set thread_in_control to a special value (0) if queue_head==0 (empty queue), to make the "Am I in control?" test in http threads fail for sure. However, that test is only executed in the C_PENDING state, which implies that the queue is non-empty - so there's no point in that assignment. (Besides, it's not elegant to make assumption about allowed and available values for an opaque type.) */ if(queue_head) thread_in_control=queue_head->tid; } else { prev->next=ii->next; free(ii); } queue_depth--; } diag(SS_MAIN|DEBUG,"control queue depth %d after removal\n",queue_depth); #if DEBUG_DUMP_QUEUE queue_print(); #endif pthread_mutex_unlock(&queue_mtx); if(!found) diag(SS_MAIN|ERROR,"inconsistent control queue (dequeue)"); }
void bro_link(struct node *n) { struct node *now, *last = NULL; queue_clear(); n->level = 1; enqueue(n); while (q_num != 0) { printf("queue: "); queue_print(); now = dequeue(); if (now == NULL) break; if (last) { if (last->level == now->level) last->next_brother = now; else last->next_brother = NULL; } printf("now: %d\n", now->val); if (now->left) { now->left->level = now->level + 1; enqueue(now->left); } if (now->right) { now->right->level = now->level + 1; enqueue(now->right); } last = now; //sleep(1); } }
void *threadBody (void *id){ // LIVRE queue_t_int *novo,*velho; while (1){ velho=queue_integer; queue_remove ((queue_t **)&queue_integer, (queue_t *)velho); // Remove primeiro elemento novo=(queue_t_int*) malloc (sizeof (queue_t_int)); // Aloca espaço para nova variável novo->item = random() % 100; novo->prev= NULL; novo->next=NULL; queue_append ((queue_t **)&queue_integer, (queue_t *)novo); printf("thread %ld: tira %d , poe %d",(long)id,velho->item,novo->item); queue_print (" Fila: ", (queue_t*) queue_integer, print_elem) ; qtd++; if(qtd == PREC){ printf("Realizou %f operações por segundo\n",( PREC/((float)(clock() - start)/CLOCKS_PER_SEC) ) ); exit(0); } } }
int main(){ queue_osnova * q = new_queue_osnova(); char * file = malloc(sizeof(char)*10); UserChoose(file); dynamic_t * dll = dynamic_init(file); if (NULL == dll) { printf("Can't load dynamic!\n"); return 1; } if (NULL == dll->inspection_f) { printf("Can't get compare function!\n"); return 1; } if (NULL == dll->react_f) { printf("Can't get reaction function!\n"); return 1; } printf("Dynamic loaded!"); Sleep(2000); queue_t * arr; while(1){ system("cls"); arr = queue_new(q, rand()%20-5); queue_print(q); if(dll->inspection_f(q)) dll->react_f(); Sleep(2000); //system("cls"); } //dynamic_clean(dll); return 0; }
void scan(player_t ** players, int numbOfPlayers, queue_t * queue){ clock_t start; char * moves; char index; struct command com; while(index != '+') { start = clock(); if (kbhit()){ index = getch(); for (int i = 0; i < numbOfPlayers; i++) { moves = player_get_moves(players[i]); if(i == 0) printf("\nplayer 1:"); else printf("\nplayer 2:"); for (int i = 0; i < 5; i++) if (moves[i] == index) { i++; com.command = i; com.players = players[i]; queue_add(queue, com); if (i == 1) printf("up"); if (i == 2) printf("down"); if (i == 3) printf("left"); if (i == 4) printf("right"); if (i == 5) printf("fire"); } } } while(clock() - start < CLOCKS_PER_SEC/30); } puts(""); queue_print(queue); }
int main(int argc, char *argv[]) { /*unsigned int m = -1; printf("%ud\n", m);*/ if (argc < 2) { printf("Usage: ./cpusched in.txt out.txt SCHEDULE_ALGORITHM [quantum]"); exit(1); } //get the algorithm indicator SCHEDULER method; if (strcmp("FCFS", argv[3]) == 0) method = FCFS; else if (strcmp("RR", argv[3]) == 0) method = RR; else if (strcmp("SJF", argv[3]) == 0) method = SJF; else { printf("THE ALGORITHM DOESN'T EXISTS\n"); exit(1); } //default by 5 int quantum = 5; if (argc == 5) quantum = atoi(argv[4]); queue_init(); //open the input text file FILE *f_in; if ((f_in = fopen(argv[1], "r+")) == NULL) { printf("THE INPUT FILE DOESN'T EXISTS"); } int pid, atime, burst; while (fscanf(f_in, "%d\t%d\t%d", &pid, &atime, &burst) != -1) { printf("%d:%d:%d\n", pid, atime, burst); priority_queue *queue = malloc(sizeof(priority_queue)); process p; p.pid = pid; p.arrival_time = atime; p.cpu_burst = burst; p.process_status = PENDING; p.consume_time = 0; p.last_exec_tick = 0; p.done_print = 0; p.exec_times = 0; queue->current_process = p; queue->next_ptr = NULL; queue_insert(queue, method); } printf("out of the castle\n"); if ((f_out = fopen(argv[2], "w+")) == NULL) { printf("THE OUTPUT FILE CREATED FAILED!\n"); } queue_process(method, quantum); if (method == FCFS) queue_print(f_out); fclose(f_in); fclose(f_out); return 0; }
int main() { int i = 0; char c; queue_t* firstQueue = queue_create(); queue_t* secondQueue = queue_create(); while (1) { scanf("%c", &c); if (c == '+') { scanf("%c", &c); if (c == '1') { firstQueue = queue_add(firstQueue); } if (c == '2') { secondQueue = queue_add(secondQueue); } } if (c == '-') { scanf("%c", &c); if (c == '1') { firstQueue = queue_del(firstQueue); } if (c == '2') { secondQueue = queue_del(secondQueue); } } if (c == 'c') { firstQueue = queue_concat(firstQueue, secondQueue); /** WARNING: ???? * Возможно тут имелось ввиду освобождение памяти? */ secondQueue = NULL; secondQueue = queue_create(); } if (c == 's') { scanf("%c", &c); if (c == '1') { firstQueue = queue_sort(firstQueue); } if (c == '2') { secondQueue = queue_sort(secondQueue); } } if (c == 'q') { printf("Bye\n"); break; } if (c == 'p') { scanf("%c", &c); if (c == '1') queue_print(firstQueue); if (c == '2') queue_print(secondQueue); } } return 0; }
void vtimer_print_short_queue(){ queue_print(&shortterm_queue_root); }
int main(int argc, char *argv[]) { char command[32]; int eventsNr, eventId, procId, priority; int i, iteration; TStack **eventsStacks; TQueue *procQ; // Daca nu exista destule argumente la rularea programului, atunci opreste executia if (argc < 3) { printf("Argumente insuficiente!\n"); return -1; } // Seteaza fisierele de intrare si de iesire freopen(argv[1], "r", stdin); freopen(argv[2], "w", stdout); // Citeste numarul de event-uri si creeaza stivele lor fscanf(stdin, "%d", &eventsNr); eventsStacks = calloc(eventsNr, sizeof(TStack*)); for (i = 0; i < eventsNr; i++) { eventsStacks[i] = stack_new(sizeof(TProcess)); } // Creeaza coada de prioritati procQ = queue_new(sizeof(TProcess), compare_process); // Citeste si executa comenzile din fisierul de intrare iteration = 0; while (fscanf(stdin, "%s", command) != EOF) { iteration++; if (strcmp(command, "start") == 0) { fscanf(stdin, "%d", &procId); fscanf(stdin, "%d", &priority); // Creeaza un proces TProcess p; p.id = procId; p.priority = priority; p.iteration = iteration; // Introduce procesul creat in coada de prioritati queue_push(procQ, &p); } else if (strcmp(command, "wait") == 0) { fscanf(stdin, "%d", &eventId); fscanf(stdin, "%d", &procId); // Creaza o stiva auxiliara TStack *aux = stack_new(sizeof(TProcess)); // Muta procesele in stiva auxiliara pana cand procesul // cautat este gasit si mutat in stiva evenimentului TProcess *p; while (!queue_isEmpty(procQ)) { p = queue_pop(procQ); if (p->id == procId) { stack_push(eventsStacks[eventId], p); free_process(p); break; } stack_push(aux, p); free_process(p); } // Muta procesele din stiva auxiliara inapoi in coada // de prioritati while (!stack_isEmpty(aux)) { p = stack_pop(aux); queue_push(procQ, p); free_process(p); } // Distruge stiva auxiliara stack_destroy(&aux, free_process); } else if (strcmp(command, "event") == 0) { fscanf(stdin, "%d", &eventId); // Muta procesele din stiva evenimentului in coada // de prioritati TProcess *p; while (!stack_isEmpty(eventsStacks[eventId])) { p = stack_pop(eventsStacks[eventId]); queue_push(procQ, p); free_process(p); } } else if (strcmp(command, "end") == 0) { fscanf(stdin, "%d", &procId); // Creaza o stiva auxiliara TStack *aux = stack_new(sizeof(TProcess)); // Muta procesele in stiva auxiliara pana cand procesul // cautat este gasit si sters TProcess *p; while (!queue_isEmpty(procQ)) { p = queue_pop(procQ); if (p->id == procId) { free_process(p); break; } stack_push(aux, p); free_process(p); } // Muta procesele din stiva auxiliara inapoi in coada // de prioritati while (!stack_isEmpty(aux)) { p = stack_pop(aux); queue_push(procQ, p); free_process(p); } // Distruge stiva auxiliara stack_destroy(&aux, free_process); } // Afiseaza iteratia printf("%d\n", iteration); // Afiseaza coada de prioritati if (!queue_isEmpty(procQ)) { queue_print(procQ, print_process); } else { printf("\n"); } // Afiseaza stivele for (i = 0; i < eventsNr; i++) { if (!stack_isEmpty(eventsStacks[i])) { printf("%d: ", i); stack_print(eventsStacks[i], print_process); } } printf("\n"); } // Elibereaza memoria queue_destroy(&procQ, free_process); for (i = 0; i < eventsNr; i++) { stack_destroy(&eventsStacks[i], free_process); } free(eventsStacks); return 0; }
int main(void) { printf("-----------------------\n"); p_queue_t queue = NULL; int i; int *a = (int *)malloc(sizeof(int) * 10); for (i = 0; i < 10; i++) { a[i] = i; } for (i = 0; i < 10; i++) { printf("%4d", a[i]); } putchar('\n'); printf("-----------------------\n"); queue = queue_create(); if (NULL == queue) err_exit("create error"); queue_print(queue, show); printf("-----------------------\n"); if (queue_empty(queue)) printf("empty\n"); for (i = 0; i < 10; i++) { if (!queue_put(queue, &a[i])) err_exit("put error"); } if (!queue_empty(queue)) printf("full\n"); queue_print(queue, show); printf("\n%d\n", queue->size); printf("%d\n", *(int*)queue->head->data); printf("%d\n", *(int*)queue_gethead(queue)); int *c = (int *)malloc(sizeof(int)); *c = 4; if (queue_put(queue, c)) printf("%d\n", queue->size); queue_print(queue, show); if (queue_delete(queue)) printf("\n%d\n", queue->size); printf("\n%d\n", *(int*)queue->head->data); printf("%d\n", *(int*)queue_gethead(queue)); queue_print(queue, show); putchar('\n'); printf("****************************************************\n"); p_queue_t queue_test = NULL; queue_test = queue_create(); for (i = 0; i < 10; i++) { if (queue_insert_maxsize(queue_test, &a[i], compare) == false) err_exit("put error"); } queue_print(queue_test, show); putchar('\n'); printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&\n"); // p_queue_t test = NULL; // test = queue_create(); // if (NULL == test) // err_exit("create error"); // for (i = 0; i < 10; i++) { if (queue_insert_minsize(queue_test, &a[i], compare) == false) err_exit("put error"); } queue_print(queue_test, show); printf("\n\n"); for (i = 0; i < 10; i++) { if (queue_insert_minsize(queue_test, &a[i], compare) == false) err_exit("put error"); } queue_print(queue_test, show); putchar('\n'); printf("############################################################\n"); int *p = (int *)malloc(sizeof(int)* 10); for (i = 0; i < 10; i++) { p[i] = i % 3; } for (i = 0; i < 10; i++) { printf("%4d", p[i]); } putchar('\n'); p_queue_t test = NULL; test = queue_create(); if (NULL == test) err_exit("create error"); for (i = 0; i < 10; i++) { if (queue_insert_minsize(test, p + i, compare) == false) err_exit("put error"); } queue_print(test, show); putchar('\n'); printf("%4d\n", test->size); printf("%4d\n",*((int *)test->head->data)); printf("%4d\n", *((int *)test->head->next->data)); queue_destroy(test); putchar('\n'); return 0; }
void vtimer_print_long_queue(){ queue_print(&longterm_queue_root); }
/** * Handler to check user input, and see if it matches any avaible commands. * Will call the right methods for executing commands */ void handle_keyboard(sp_session *session, struct play_queue* node) { char buffer[1024]; fgets(buffer, sizeof(buffer), stdin); strtok(buffer, "\n"); if (strcmp(buffer, "search") == 0) { player_reset(); run_search(session); } else if ((strcmp(buffer, "list") == 0) || (strcmp(buffer, "ls") == 0 )) { print_playlists(session, pc); } else if(strcmp(buffer, "qshuffle") == 0) { queue_shuffle(); } else if (strcmp(buffer, "queueadd") == 0) { sp_playlist* pl = parse_play_command(session, buffer, node); printf("done finding playlist \n"); if(pl != NULL) printf("queueadd: %s\n", sp_playlist_name(pl)); else { printf("no playlist\n"); return; } int index; char input[10]; fputs("Song number: ", stdout); fgets(input, sizeof(input) - 1, stdin); sscanf(input, "%d", &index); if(sp_playlist_num_tracks(pl) < index) { printf("index too high!\n"); return; } sp_track* track = pl_find_song_by_id(pl, index); if(track != NULL) queue_add_first(track); } else if (strcmp(buffer, "list songs") == 0 ) { //release all threads sp_playlist* pl = playlist_find_by_num(session, pc); print_tracks_in_playlist(session, pl); } else if (strcmp(buffer, "help") == 0) { print_commands(); } else if (strcmp(buffer, "queue") == 0) { queue_print(node); } else if (strcmp(buffer, "shuffle mode") == 0) { print_commands(); } else if(strncmp(buffer, "play", strlen("play")) == 0) { player_reset(); sp_playlist* pl = parse_play_command(session, buffer, node); if(pl!=NULL) queue_add_playlist(pl); else { printf("ERROR playlist is null\n"); return; } queue_go_next(session); } else if(strncmp(buffer, "shuffle", strlen("shuffle")) == 0) { player_reset(); shuffle_mode = TRUE; sp_playlist* pl = parse_play_command(session, buffer, node); if(pl!=NULL) queue_add_playlist(pl); else { printf("ERROR playlist is null\n"); return; } queue_shuffle(); queue_go_next(session); } else if(strcmp(buffer, "pause") == 0 || strcmp(buffer, "p") == 0) { player_pause(session); play_info(); } else if (strcmp(buffer, "next") == 0 || strcmp(buffer, "n") == 0) { end_track(session); } else if (strcmp(buffer, "stop") == 0) { } else if (strcmp(buffer, "info") == 0) { play_info(); } else if (strcmp(buffer, "quit") == 0) { queue_free(); quit_program(session); } else { printf("Unkown command!\n"); } printf("> "); fflush(stdout); return; }