void test_tree() { TreeNode *tree = (TreeNode*)malloc(sizeof(TreeNode)); int key = 0; init_tree(key++, 0, 0, tree); add_left(key++, 0, tree); add_right(key++, 0, tree); add_left(key++, 0, tree->left); add_right(key++, 0, tree->left); add_left(key++, 0, tree->right); add_right(key++, 0, tree->right); add_left(key++, 0, tree->left->left); print_tree(tree); std::cout << std::endl; std::cout << "max depth: " << max_depth(tree, 0) << std::endl; std::cout << "min depth: " << min_depth(tree, 0) << std::endl; std::cout << "Is tree balanced? " << (is_tree_balanced(tree) == 1 ? "yes" : "no") << std::endl; free_tree(tree); }
void Tree<T> :: math_parse(char* exp,Node<T>** node) { if('\0' == *exp) { //cerr << "Wrong expression: math_parse" << endl; return; }else if('(' == *exp) { add_left(*exp,node); math_parse(exp+1, &(*node)->left); }else if('+' == *exp || '-' == *exp || '*' == *exp || '/'== *exp) { (*node)->data = *exp; add_right('n', node); math_parse(exp+1, &(*node)->right); }else if(*exp >= '0' && *exp <= '9') { (*node)->data = *exp; math_parse(exp+1, &(*node)->father); }else if(')' == *exp) math_parse(exp+1, &(*node)->father); else math_parse(exp+1, node); }
void add_right(struct node** ref_pnode, int data) { if(*ref_pnode != NULL) { struct node **ref_pnext = &((*ref_pnode)->next); add_left(ref_pnext, data); } else add_left(ref_pnode, data); }
//================================================================================ node* grow_from_file (FILE* base, FILE* logs) { node* leaf = NULL; node* tree = NULL; char ch = 0; ch = getc(base); switch (ch) { case '(': create_new_leaf(&tree, NULL); tree->info = (char*) calloc (MAX_STRING_LENG, sizeof(char)); fscanf(base, "'%[^']'", tree->info); fprintf(logs, "IN FUNCTION = %s\n", tree->info); leaf = grow_from_file(base, logs); if (leaf == NULL) return tree; fprintf(logs, "NEW LEFT LEAF %s OF %s\n", leaf->info, tree->info); add_left(tree, leaf); leaf = grow_from_file(base, logs); if (leaf == NULL) return tree; fprintf(logs, "NEW RIGHT LEAF %s OF %s\n", leaf->info, tree->info); add_rght(tree, leaf); ch = getc(base); if (ch == '(') { fprintf(logs, "ERROR, THIRD LEAF OF BINARY NODE\n"); return NULL; } ungetc(ch, base); break; case ')': fprintf(logs, "DEADLOCK\n"); return NULL; default: return NULL; } fprintf(logs, "EXIT FROM %s\n", tree->info); ch = getc(base); return tree; }
node *init_or_add_left(node *node_pointer, char value) { if (node_pointer == NULL) { node_pointer = create_node(value); } else { node_pointer = add_left(node_pointer, value); } return node_pointer; }
void append(struct node** ref_plist, int data) { struct node *pcurrent = *ref_plist; if (pcurrent == NULL) { // empty list, add left to it add_left(ref_plist, data); } else { // find the last node, add right to it while(pcurrent->next != NULL) pcurrent = pcurrent->next; add_right(&pcurrent, data); } }
int main(void) { char array[10]; int choice, size, i; printf("enter size:"); scanf("%d", &size); for(i = 0;i < size;i++) { scanf(" %c", &array[i]); } do { printf("press 1 to add left\n"); printf("press 2 to add right\n"); printf("press 3 to retrieve left\n"); printf("press 4 to retrieve right\n"); printf("press 5 to exit\n"); printf("enter your choice:"); scanf("%d", &choice); switch(choice) { case 1: size = add_left(array, size); break; case 2: size = add_right(array, size); break; case 3: size = retrieve_left(array, size); break; case 4: retrieve_right(array, size); break; case 5: printf("Exiting...\n"); return 0; } }while(choice != 5); }
void prepend(struct node** ref_plist, int data) { add_left(ref_plist, data); }
int main() { std::ifstream fin("castle.in", std::ios::in); fin>>M>>N; for( int i = 0; i < M * N; ++i ) fin >> room[i]; for( int i = 0; i < M * N; ++i ) room_state[i] = 0; #if 0 for( int i = 0; i < M * N; ++i ) { std::cout << room[i]; if( i % M == M-1 ) std::cout << std::endl; else std::cout << " "; } std::cout << M << " " << N << " " << M * N << std::endl; #endif for( int i = 0; i < M * N; ++i ){ if( room_state[i] == 0 ){ int temp_max_count = 0; q.push( i ); while( !q.empty() ){ int index = q.front(); temp_max_count++; room_state[index] = count; q.pop(); #if 0 std::cout << count << ":" << index/M + 1 << " " << index % M + 1 << std::endl; #endif switch( room[index] ){ case 0: add_left( index ); add_up( index ); add_right( index ); add_down( index ); break; case 1: { add_left_edge( index ); add_up( index ); add_right( index ); add_down( index ); } break; case 2: { add_left( index ); add_up_edge( index ); add_right( index ); add_down( index ); } break; case 3: { add_left_edge( index ); add_up_edge( index ); add_right( index ); add_down( index ); } break; case 4: { add_left( index ); add_up( index ); add_right_edge( index ); add_down( index ); } break; case 5: { add_left_edge( index ); add_up( index ); add_right_edge( index ); add_down( index ); } break; case 6: { add_left( index ); add_up_edge( index ); add_right_edge( index ); add_down( index ); } break; case 7: { add_left_edge( index ); add_up_edge( index ); add_right_edge( index ); add_down( index ); } break; case 8: { add_left( index ); add_up( index ); add_right( index ); add_down_edge( index ); } break; case 9: { add_left_edge( index ); add_up( index ); add_right( index ); add_down_edge( index ); } break; case 10: { add_left( index ); add_up_edge( index ); add_right( index ); add_down_edge( index ); } break; case 11: { add_left_edge( index ); add_up_edge( index ); add_right( index ); add_down_edge( index ); } break; case 12: { add_left( index ); add_up( index ); add_right_edge( index ); add_down_edge( index ); } break; case 13: { add_left_edge( index ); add_up( index ); add_right_edge( index ); add_down_edge( index ); } break; case 14: { add_left( index ); add_up_edge( index ); add_right_edge( index ); add_down_edge( index ); } break; case 15: { add_left_edge( index ); add_up_edge( index ); add_right_edge( index ); add_down_edge( index ); } break; default: break; } } room_num[count] = temp_max_count; max_count = std::max( max_count, temp_max_count ); count++; } } std::ofstream fout("castle.out", std::ios::out ); #if 0 std::cout << count - 1 << std::endl; std::cout << max_count << std::endl; #endif fout << count - 1 << std::endl; fout << max_count << std::endl; int a, b, c; a = N; b = M; c = 4; for( int i = 0; i < edge_count; ++i ){ #if 0 std::cout << edge1[i] / M + 1 << ":" << edge1[i] % M + 1 << " " << edge2[i] / M + 1 << ":" << edge2[i] %M + 1 << std::endl; #endif if( room_state[edge1[i]] != room_state[edge2[i]] ){ if( new_max_count < room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]] ){ new_max_count = room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]]; if( abs( edge2[i] - edge1[i] ) == 1 ) { int temp = std::min( edge1[i], edge2[i] ); a = temp / M + 1; b = temp % M + 1; c = 4; }else{ int temp = std::max( edge1[i], edge2[i] ); a = temp / M + 1; b = temp % M + 1; c = 2; } }else if( new_max_count == room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]] ) { if( abs( edge1[i] - edge2[i] ) == 1 ){ int temp = std::min( edge1[i], edge2[i] ); if( temp % M + 1< b || (temp % M + 1 == b && temp / M + 1 > a)){ a = temp / M + 1; b = temp % M + 1; c = 4; } }else { int temp = std::max( edge1[i], edge2[i] ); if( temp % M + 1 < b || ( temp % M + 1 == b && temp / M + 1 > a ) ){ a = temp / M + 1; b = temp % M + 1; c = 2; } } } // new_max_count = std::max( new_max_count, // room_num[room_state[edge1[i]]] + room_num[room_state[edge2[i]]] ); #if 0 std::cout << room_num[room_state[edge1[i]]] << ":" << room_num[room_state[edge2[i]]] << " " << new_max_count << std::endl; std::cout << a << " " << b << " " << c << std::endl; #endif } } fout << new_max_count << std::endl; fout << a << " "<< b << " "<< (c == 2? 'N' : 'E') << std::endl; return 0; }
node* node::operator-=(node* list) { $1 add_left(list); return this; };
static int process_filter(struct event_format *event, struct filter_arg **parg, char **error_str, int not) { enum event_type type; char *token = NULL; struct filter_arg *current_op = NULL; struct filter_arg *current_exp = NULL; struct filter_arg *left_item = NULL; struct filter_arg *arg = NULL; enum op_type op_type; enum filter_op_type btype; enum filter_exp_type etype; enum filter_cmp_type ctype; int ret; *parg = NULL; do { free(token); type = read_token(&token); switch (type) { case EVENT_SQUOTE: case EVENT_DQUOTE: case EVENT_ITEM: arg = create_arg_item(event, token, type, error_str); if (!arg) goto fail; if (!left_item) left_item = arg; else if (current_exp) { ret = add_right(current_exp, arg, error_str); if (ret < 0) goto fail; left_item = NULL; /* Not's only one one expression */ if (not) { arg = NULL; if (current_op) goto fail_print; free(token); *parg = current_exp; return 0; } } else goto fail_print; arg = NULL; break; case EVENT_DELIM: if (*token == ',') { show_error(error_str, "Illegal token ','"); goto fail; } if (*token == '(') { if (left_item) { show_error(error_str, "Open paren can not come after item"); goto fail; } if (current_exp) { show_error(error_str, "Open paren can not come after expression"); goto fail; } ret = process_filter(event, &arg, error_str, 0); if (ret != 1) { if (ret == 0) show_error(error_str, "Unbalanced number of '('"); goto fail; } ret = 0; /* A not wants just one expression */ if (not) { if (current_op) goto fail_print; *parg = arg; return 0; } if (current_op) ret = add_right(current_op, arg, error_str); else current_exp = arg; if (ret < 0) goto fail; } else { /* ')' */ if (!current_op && !current_exp) goto fail_print; /* Make sure everything is finished at this level */ if (current_exp && !check_op_done(current_exp)) goto fail_print; if (current_op && !check_op_done(current_op)) goto fail_print; if (current_op) *parg = current_op; else *parg = current_exp; return 1; } break; case EVENT_OP: op_type = process_op(token, &btype, &ctype, &etype); /* All expect a left arg except for NOT */ switch (op_type) { case OP_BOOL: /* Logic ops need a left expression */ if (!current_exp && !current_op) goto fail_print; /* fall through */ case OP_NOT: /* logic only processes ops and exp */ if (left_item) goto fail_print; break; case OP_EXP: case OP_CMP: if (!left_item) goto fail_print; break; case OP_NONE: show_error(error_str, "Unknown op token %s", token); goto fail; } ret = 0; switch (op_type) { case OP_BOOL: arg = create_arg_op(btype); if (current_op) ret = add_left(arg, current_op); else ret = add_left(arg, current_exp); current_op = arg; current_exp = NULL; break; case OP_NOT: arg = create_arg_op(btype); if (current_op) ret = add_right(current_op, arg, error_str); if (ret < 0) goto fail; current_exp = arg; ret = process_filter(event, &arg, error_str, 1); if (ret < 0) goto fail; ret = add_right(current_exp, arg, error_str); if (ret < 0) goto fail; break; case OP_EXP: case OP_CMP: if (op_type == OP_EXP) arg = create_arg_exp(etype); else arg = create_arg_cmp(ctype); if (current_op) ret = add_right(current_op, arg, error_str); if (ret < 0) goto fail; ret = add_left(arg, left_item); if (ret < 0) { arg = NULL; goto fail_print; } current_exp = arg; break; default: break; } arg = NULL; if (ret < 0) goto fail_print; break; case EVENT_NONE: break; default: goto fail_print; } } while (type != EVENT_NONE); if (!current_op && !current_exp) goto fail_print; if (!current_op) current_op = current_exp; current_op = collapse_tree(current_op); *parg = current_op; return 0; fail_print: show_error(error_str, "Syntax error"); fail: free_arg(current_op); free_arg(current_exp); free_arg(arg); free(token); return -1; }