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