//pesquisa em largura - descobre o caminho mais curto void bfs(Grafo *G, int s) { No* t; int v, w; queue *q = new_queue(TAMQMAX); G->adj[s]->dist = 0; //dist do vertice inicial ao final G->adj[s]->color = GREY; enqueue(q, s); while (!isEmpty(q)) { v = dequeue(q); G->adj[v]->color = BLACK; //processado for (t = G->adj[v]; t != NULL; t = t->next) { w = t->v; if (G->adj[w]->color == WHITE) { G->adj[w]->color = GREY; // visitado G->adj[w]->dist = G->adj[v]->dist +1; enqueue(q, w); } } } queue_destroy(q); }
main() { Queue q; Stack s; Jval v; IS is; int i; q = new_queue(); s = new_stack(); i = 0; is = new_inputstruct(NULL); while (get_line(is) >= 0) { if (i % 2 == 0) { queue_enqueue(q, new_jval_s(strdup(is->fields[0]))); } else { stack_push(s, new_jval_s(strdup(is->fields[0]))); } i++; } while (!queue_empty(q)) { v = queue_dequeue(q); printf("%s\n", v.s); } while (!stack_empty(s)) { v = stack_pop(s); printf("%s\n", v.s); } }
/* populates rank lists of g. there are some key details: 1) the input graph ordering must be respected (in left to right initialization) 2) connected components are separated and marked with indices 3) series-parallel graphs (includes trees, obviously) must not have crossings */ static void build_ranks(Agraph_t *g, boolean down) { queue *q; component_t c; int r; Agnode_t *n; Agedge_t *e; c = build_components(g, down); /* process each each component */ q = new_queue(agnnodes(g)+1); for (r = 0; r < c.r; r++) { enqueue(q,c.root[r]); if ((r + 1 >= c.r)||(ND_component(c.root[r])!=ND_component(c.root[r+1]))) { while ((n = dequeue(q))) { install(g,n); if (down) { for (e = agfstout(g,n); e; e = agnxtout(g,e)) if (--ND_priority(e->head) == 0) enqueue(q,e->head); } else { for (e = agfstin(g,n); e; e = agnxtin(g,e)) if (--ND_priority(e->tail) == 0) enqueue(q,e->head); } } } } free_queue(q); }
int main (int argc, char **argv) { execname = basename (argv[0]); queue_ref queue = new_queue(); if (argc < 2) { putinqueue (queue, stdin, "-"); }else { for (int argi = 1; argi < argc; ++argi) { if (strcmp (argv[argi], "-") == 0) { putinqueue (queue, stdin, "-"); }else { putfileinqueue (queue, argv[argi]); } } } while (! isempty_queue (queue)) { char *oldstring = remove_queue(queue); printf ("%s\n", oldstring); free (oldstring); } free_queue(queue); return exit_status; }
void ringqueue_test(void) { int i; ringqueue_t *q; void *d; q = new_queue(1000, 500); /* -1- fill queue */ for (i = 0; i < 10000; ++i) { d = dequeue(q); DPRINTF( ("-1- dequeued val: %i\n", d) ); enqueue(q, (void *)123456789); enqueue(q, (void *)i); } /* -2- empty queue */ while (d) { d = dequeue(q); DPRINTF( ("-2- dequeued val: %i\n", d) ); } }
int main(int argc, const char *argv[]) { queue_t* a; int data; int i; a = (queue_t*)malloc(sizeof(queue_t)); new_queue(a, 10); print_queue(a); pushq(a, 2); print_queue(a); popq(a, &data); print_queue(a); pushq(a, 3); print_queue(a); for(i = 0; i < a->size + 3; i++) { pushq(a, i); print_queue(a); } for(i = 0; i < a->size + 3; i++) { popq(a, &data); print_queue(a); printf("data: %d\n", data); } del_queue(a); free(a); return 0; }
main() { IS is; Queue q; Stack s; Dllist l; int i; Jval j; is = new_inputstruct(NULL); while (get_line(is) > 0) { q = new_queue(); s = new_stack(); l = new_dllist(); for (i = 0; i < strlen(is->fields[0]); i++) { queue_enqueue(q, new_jval_c(is->fields[0][i])); stack_push(s, new_jval_c(is->fields[0][i])); dll_append(l, new_jval_c(is->fields[0][i])); dll_prepend(l, new_jval_c(is->fields[0][i])); } while (!queue_empty(q)) { j = queue_dequeue(q); printf("%c", j.c); j = stack_pop(s); printf("%c", j.c); printf("%c", l->flink->val.c); dll_delete_node(l->flink); printf("%c", l->flink->val.c); dll_delete_node(l->flink); printf(" "); } printf("\n"); free_queue(q); free_stack(s); free_dllist(l); } }
} END_TEST START_TEST(check_timeout) { Queue *q = new_queue(); Job *j = q_dequeue_or_wait(q, 1); mark_point(); assert_null(j); }
JNIEXPORT void JNICALL Java_com_yichou_test_jni_MainActivity_init(JNIEnv * env, jobject self) { mHandler = new Handler(handlerMsg); mQueue = new_queue(); pthread_create(&pid, NULL, main_loop, NULL); // timerStart(1000); }
static void wait_answer_queue(t_thread_handler *thread_handler, int port, char *scan, int id, char *host) { t_queue *queue = new_queue(port, IPPROTO_TCP, scan, id, host); if (queue) { add_queue(queue); } else { pthread_mutex_unlock(&globals->queue_lock); } }
void expect_new_queues_to_not_be_null() { Queue *q = new_queue(); assert(q != NULL); assert(q->in != NULL); assert(q->out != NULL); destroy_queue(q); }
void serio_init(uckernel_task handler) { serio_set_rx_handler(handler); new_queue(&tx_queue, tx_queue_data, QUEUE_SIZE, sizeof(uint8_t)); new_queue(&rx_queue, rx_queue_data, QUEUE_SIZE, sizeof(uint8_t)); iPPSInput(IN_FN_PPS_U2RX, IN_PIN_PPS_RP10); iPPSInput(IN_FN_PPS_U2CTS, IN_PIN_PPS_RPI32); iPPSOutput(OUT_PIN_PPS_RP17, OUT_FN_PPS_U2TX); iPPSOutput(OUT_PIN_PPS_RP31, OUT_FN_PPS_U2RTS); CloseUART2(); /*Enable UART intruupts*/ ConfigIntUART2(UART_RX_INT_EN | UART_RX_INT_PR6 | UART_TX_INT_EN | UART_TX_INT_PR6 | UART_INT_TX_BUF_EMPTY); /*UART initialized to 9600 baudrate @BRGH=0, 8bit,no parity and 1 stopbit*/ OpenUART2(UART_EN | UART_BRGH_FOUR, UART_TX_ENABLE, 34); serio_initialized = true; }
} END_TEST START_TEST (single_item) { Job job; Queue *q = new_queue(); assert_not_null(q); q_enqueue(q, &job); Job *d_job = q_dequeue(q); assert_equal(&job, d_job); free_queue(q); } END_TEST
} END_TEST START_TEST(check_queue_size) { Job job1, job2; Queue *q = new_queue(); assert_equal(0, q_size(q)); q_enqueue(q, &job1); assert_equal(1, q_size(q)); q_enqueue(q, &job2); assert_equal(2, q_size(q)); free_queue(q); } END_TEST
void test_enqueue() { Queue q = new_queue(10); QueueError e = new_queue_error(); QueueOpt opts[] = { { Enqueue, 10 }, }; test_queue(q, e, opts, 1, True); ASSERT(*e == QueueErrorNone); queue_free(q); queue_error_free(e); }
// tests void test_overflow() { Queue q = new_queue(20); QueueError e = new_queue_error(); QueueOpt opts[] = { { Enqueue, 21 }, }; test_queue(q, e, opts, 1, True); ASSERT(*e == QueueErrorOverflow); queue_free(q); queue_error_free(e); }
int main() { node* queue = new_queue(); int i; for (i=0; i<10; i++) { enqueue(queue, i); } assert(queue_peek(queue) == 0); assert(dequeue(queue) == 0); assert(queue_peek(queue) == 1); }
static cond_variable * cvinit(uint8_t * name){ cond_variable * cv = malloc(sizeof(cond_variable)); cv->q = new_queue(); cv->id = historic; cv->name = name; condvar_number ++; historic++; CVNode * n = malloc(sizeof(CVNode)); n->cv = cv; n->next = nodes; nodes = n; return cv; }
//----------------------------------------------------------------------------- NetworkType* new_tcp_client_state( char* ip, int port, uint32_t *ticks) { NetworkType *tcp = malloc(sizeof(NetworkType)); tcp->tick = tick; tcp->logic_tick = logic_tick; tcp->add_command = add_command; tcp->get_command = get_command; tcp->get_id = get_id; tcp->cleanup = cleanup; TcpClientState *state = (TcpClientState *) malloc(sizeof(TcpClientState)); memset(state, 0, sizeof(TcpClientState)); tcp->state = (void *)state; state->msg_size = 0; state->in = new_queue(1); state->out = new_queue(1); state->last_post_time = 0; state->post_delay = 0.12; state->waiting = 0; state->client_id = -1; state->ready = 0; state->read_buf = malloc(1); state->ticks = ticks; state->socket = new_tcpclient(); tcpclient_init(state->socket, port, ip); tcpclient_set_user_data(state->socket, tcp->state); printf("Connecting...\n"); tcpclient_set_handlers(state->socket, &client_read, &client_disconnect); tcpclient_connect(state->socket); return tcp; }
NetworkType *single_player_network(uint32_t *tickptr) { NetworkType *single = malloc(sizeof(NetworkType)); single->tick = noop; single->logic_tick = noop; single->add_command = add_command; single->get_command = get_command; single->get_id = get_id; single->cleanup = cleanup; ticks_ptr = tickptr; Queue *state = new_queue(0); single->state = (void *)state; return single; }
void test_rotation() { Queue q = new_queue(20); QueueError e = new_queue_error(); QueueOpt opts[] = { { Enqueue, 20 }, { Dequeue, 15 }, { Enqueue, 10 }, { Dequeue, 15 }, // size = 0 }; test_queue(q, e, opts, 4, True); ASSERT(*e == QueueErrorNone); queue_free(q); queue_error_free(e); }
void expect_queue_to_accept_many_elements(int n_elements) { int i; Queue *q = new_queue(); for (i = 0; i < n_elements; i++) { assert(push_queue(q, i) == 0); } for (i = 0; i < n_elements; i++) { assert(pop_queue(q) == i); } destroy_queue(q); }
} END_TEST START_TEST (multiple_items) { Job job1, job2; Queue *q = new_queue(); assert_not_null(q); q_enqueue(q, &job1); q_enqueue(q, &job2); assert_false(q_empty(q)); Job *d_job1 = q_dequeue(q); Job *d_job2 = q_dequeue(q); assert_equal(&job1, d_job1); assert_equal(&job2, d_job2); free_queue(q); } END_TEST
void create_table(cube *(*construct_cube)(cube*), hash_cube_t (*hash_cube)(cube*), cube *(*reconstruct_stickers)(hash_cube_t*), int total_count ) { hash_set_t hash_set = new_hash_set(hash_cube_index, hash_cube_equals); queue q = new_queue(); cube *c0 = construct_cube(init_cube()); hash_cube_t h0 = hash_cube(c0); delete_cube(c0); enqueue(&q, h0); insert(&hash_set, &h0); int count = 0; int depth = 0; while (queue_size(&q) != 0) { int n = queue_size(&q); for (int i = 0; i < n; ++i) { ++count; if (count % 1000 == 0) { fprintf(stderr, "%f\n", (float) count / total_count); } hash_cube_t val = dequeue(&q); cube *c1 = reconstruct_stickers(&val); print_cube_flat(c1); printf(",%d\n", depth); for (int i = 0; i < 18; ++i) { cube *c2 = cube_expand[i](c1); hash_cube_t h1 = hash_cube(c2); if (!contains(&hash_set, &h1)) { enqueue(&q, h1); insert(&hash_set, &h1); } delete_cube(c2); } delete_cube(c1); } ++depth; } free_queue(&q); free_hash_set(&hash_set); }
int mv_start(int npages, int nframes) { memory_size = nframes; memory = (int*) calloc(memory_size, sizeof(int)); frame_of = (int*) calloc(npages, sizeof(int)); fifo = new_queue(); int i; for(i = 0; i < memory_size; i++) { memory[i] = -1; } for(i = 0; i < npages; i++) { frame_of[i] = -1; } }
void expect_push_queue_and_pop_queue_to_work_consistently() { Queue *q = new_queue(); assert(push_queue(q, 1) == 0); assert(push_queue(q, 2) == 0); assert(push_queue(q, 3) == 0); assert(push_queue(q, 4) == 0); assert(push_queue(q, 5) == 0); assert(pop_queue(q) == 1); assert(pop_queue(q) == 2); assert(pop_queue(q) == 3); assert(pop_queue(q) == 4); assert(pop_queue(q) == 5); assert(pop_queue(q) == -1); destroy_queue(q); }
void test_stress() { time_t start, end; unsigned int queue_size = 2*0x0FFFFFFF; Queue q = new_queue(queue_size); QueueError e = new_queue_error(); QueueOpt opts[] = { { Enqueue, queue_size }, { Dequeue, queue_size }, }; time(&start); test_queue(q, e, opts, 2, False); time(&end); double time_diff = difftime(end, start); printf("500 Million int queue+dequeue stress test completed in %.21f seconds\n\n\n", time_diff); queue_free(q); queue_error_free(e); }
int main (int argc, char **argv) { execname = basename (argv[0]); queue *the_queue = new_queue(); if (argc < 2) { putinqueue (the_queue, stdin, "-"); }else { for (int argi = 1; argi < argc; ++argi) { if (strcmp (argv[argi], "-") == 0) { putinqueue (the_queue, stdin, "-"); }else { putfileinqueue (the_queue, argv[argi]); } } } while (! isempty_queue (the_queue)) { printf ("%s\n", remove_queue (the_queue)); } return exit_status; }
int main(int argc, char ** argv) { int n_items = (argc > 1 ? atoi(argv[1]) : 100000); /* 挿入/削除される要素数 */ int n_enq_threads = (argc > 2 ? atoi(argv[2]) : 1); /* 挿入役のスレッド数 */ int n_deq_threads = (argc > 3 ? atoi(argv[3]) : 1); /* 削除役のスレッド数 */ int n_threads = n_enq_threads + n_deq_threads; thread_arg_t args = malloc(sizeof(struct thread_arg) * n_threads); queue_t q = new_queue(); /* a : 答えのチェック用配列. (i) 最初はすべて0. (ii) deqするスレッドが値 x を取り出したら a[x] = 1 とする (iii) 全要素が1になっていたら正解 */ char * a = calloc(1, n_items); int i; double t0 = cur_time(); /* スレッドを n_threads 個作る */ for (i = 0; i < n_threads; i++) { args[i].idx = i; args[i].n_enq_threads = n_enq_threads; args[i].n_deq_threads = n_deq_threads; args[i].n_items = n_items; args[i].q = q; args[i].a = a; pthread_create(&args[i].tid, NULL, thread_func, (void *)&args[i]); } /* 終了待ち */ for (i = 0; i < n_threads; i++) { pthread_join(args[i].tid, NULL); } /* すべての要素が取り出されているかチェック */ for (i = 0; i < n_items; i++) { assert(a[i] == 1); } double t1 = cur_time(); printf("OK: elapsed time: %f\n", t1 - t0); return 0; }
size_t make_lists(struct list_node out[], struct tree_node *root) { if (root == NULL) { return 0; } Queue queue = new_queue(); if (queue == NULL) { return 0; } unsigned curr_level = 1; unsigned next_level = 0; size_t cursor = 0; enqueue(queue, root); while (!queue_is_empty(queue)) { list_init_head(&out[cursor]); size_t i; for (i = 0; i < curr_level; i++) { struct tree_node *node = dequeue(queue); next_level += enqueue_all_children(queue, node); struct list_node *list_el = &list_nodes[next_node++]; list_set_data(list_el, node); list_append(&out[cursor], list_el); } cursor++; curr_level = next_level; next_level = 0; } return cursor; }