void BTree<T>::split(int p_id, int n_id) { BNode<T>& n = get_node(n_id); BNode<T>& t = manager.new_node(); int pos = n.ascendpos(); T& newkey = n.keys[pos]; t.leaf = n.leaf; t.sibling = n.sibling; t.numkeys = n.numkeys - pos - 1; memcpy(t.keys, &(n.keys[pos+1]), sizeof(T)*(t.numkeys)); if (!n.leaf) { n.numkeys = pos; // key ascended memcpy(t.next, &(n.next[pos+1]), sizeof(int)*(t.numkeys+1)); } else { n.numkeys = pos + 1; // key copied n.sibling = t.id; memcpy(t.next, &(n.next[pos+1]), sizeof(int)*(t.numkeys)); } if (p_id == -1) { // root splits BNode<T>& pp = manager.new_root(); pp.leaf = 0; pp.sibling = -1; p_id = pp.id; return_node(pp.id); } BNode<T>& p = get_node(p_id); int newpos = p.findkey(newkey); p.addkey(newkey, newpos); p.addnext(n.id, t.id, newpos); p.numkeys++; update_node(n.id); return_node(n.id); update_node(t.id); return_node(t.id); update_node(p.id); return_node(p.id); return; }
void remove_tree(tree_node_t *tree) { tree_node_t *current_node, *tmp; if( tree->left == NULL ) return_node( tree ); else { current_node = tree; while(current_node->right != NULL ) { if( current_node->left->right == NULL ) { return_node( current_node->left ); tmp = current_node->right; return_node( current_node ); current_node = tmp; } else { tmp = current_node->left; current_node->left = tmp->right; tmp->right = current_node; current_node = tmp; } } return_node( current_node ); } }
void BTree<T>::insert(int p_id, int n_id, T& key, void *data, int length) { BNode<T> &n = get_node(n_id); int pos = n.findkey(key), sz = n.numkeys; if (pos < sz && key == n.keys[pos]) { // duplicated return_node(n_id); return; } if (n.leaf && n.addkey(key, pos) >= 0) { n.adddata(manager.new_data(data,length), pos); n.numkeys++; update_node(n_id); return_node(n_id); } else { int m_id = n.next[pos]; return_node(n_id); insert(n_id, m_id, key, data, length); } BNode<T> &nn = get_node(n_id); if (nn.numkeys >= CHUNK_SIZE) { return_node(n_id); split(p_id, n_id); } else { return_node(n_id); } }
object_t *_delete(tree_node_t *tree, key_t delete_key) { tree_node_t *tmp_node, *upper_node, *other_node; object_t *deleted_object; if( tree->left == NULL ) return( NULL ); else if( tree->right == NULL ) { if( tree->key == delete_key ) { deleted_object = (object_t *) tree->left; tree->left = NULL; return( deleted_object ); } else return( NULL ); } else { tmp_node = tree; while( tmp_node->right != NULL ) { upper_node = tmp_node; if( delete_key < tmp_node->key ) { tmp_node = upper_node->left; other_node = upper_node->right; } else { tmp_node = upper_node->right; other_node = upper_node->left; } } if( tmp_node->key != delete_key ) return( NULL ); else { upper_node->key = other_node->key; upper_node->left = other_node->left; upper_node->right = other_node->right; deleted_object = (object_t *) tmp_node->left; return_node( tmp_node ); return_node( other_node ); return( deleted_object ); } } }
void remove_list(list* the_list){ list* temp; do{ temp = the_list->next; return_node(the_list); the_list = temp; } while (temp != NULL); }
int BTree<T>::search(T& key, bool force=false) { int ret, cur_id = manager.get_root().id; while (true) { BNode<T>& cur = manager.get_node(cur_id); int i = cur.findkey(key); if (cur.leaf) { if (i >= cur.numkeys) { ret = force ? cur_id : -1; } else { ret = cur_id; } return_node(cur.id); return ret; } cur_id = cur.next[i]; return_node(cur.id); } }
region pop_region(list* the_list){ list* temp; region temp_region; temp = the_list->next; the_list->next = temp->next; temp_region = temp->the_region; return_node(temp); return(temp_region); }
void affiche_chemin_ricochet (Case *courant,int x_dep, int y_dep) { cout << " ----- CHEMIN A L'ENVERS-------" << endl; Case test = return_node(courant->x,courant->y); int x; int y; while(1) { if(test.ancienne_direction == HAUT) { cout << "HAUT " << endl; chemin_ricochet.push_back(HAUT); y = -1; x= 0; } if(test.ancienne_direction == DROITE) { cout << "DROITE " << endl; chemin_ricochet.push_back(DROITE); x = - 1; y = 0; } if(test.ancienne_direction == BAS) { cout << "BAS " << endl; chemin_ricochet.push_back(BAS); x = 0; y = 1; } if(test.ancienne_direction == GAUCHE) { cout << "GAUCHE " << endl; chemin_ricochet.push_back(GAUCHE); x = 1; y = 0; } if(test.x == x_dep && test.y == y_dep) { break; } test = return_node(test.x + x,test.y + y); } }
int BTree<T>::search_data(T& key) { int nodeid; if ((nodeid = search_node(key)) < 0) return -1; BNode<T> &node = get_node(nodeid); int pos = node.findkey(key); assert(pos >= 0); int dataid = node.next[pos]; return_node(nodeid); return dataid; }
void BTree<T>::preorder(BNode<T>& n) { T tkeys[CHUNK_SIZE+1]; int tnext[CHUNK_SIZE+2]; int sz=n.numkeys; if (n.leaf) { for (int i = 0; i < sz; ++i) cout << n.keys[i] << endl; return_node(n.id); return; } memcpy(tkeys, n.keys, sizeof(T) * (CHUNK_SIZE+1)); memcpy(tnext, n.next, sizeof(int) * (CHUNK_SIZE+2)); return_node(n.id); for (int i = 0; i < sz; ++i) { preorder(get_node(tnext[i])); // cout << tkeys[i] << endl; } preorder(get_node(tnext[sz])); }
void BManager<T>::optimize_data() { string data_path = prefix+".data"; string tmp_path = prefix+".data.tmp"; FILE *tmp_file = fopen(tmp_path.c_str(), "w"); if (!tmp_file || !data_file || !node_file) { cerr << "WARNING::BManager::no file to optimize" << endl; return; } char *buf = new char[1024]; int buf_len = 1024; int cur_node; vector<pair<long long, int> > backup; backup.swap(data_zone); cur_node = first_leaf_id; while (cur_node != -1) { BNode<T> &n = get_node(cur_node); for (int i = 0; i < n.numkeys; ++i) { if (n.next[i] < 0) continue; int dataid = n.next[i]; int newlen = backup[dataid].second; long long oldfp = backup[dataid].first; long long newfp = ftell(tmp_file); fseek(data_file, oldfp, SEEK_SET); if (buf_len < newlen) { delete []buf; buf = new char[newlen]; buf_len = newlen; } int r = fread(buf, newlen, 1, data_file); assert(r > 0); fwrite(buf, 1, newlen, tmp_file); n.next[i] = data_zone.size(); data_zone.push_back(make_pair(newfp, newlen)); } cur_node = n.sibling; update_node(n.id); return_node(n.id); } optimized = 1; cerr << "[0]" << endl; fclose(tmp_file); cerr << "[1]" << endl; fclose(data_file); cerr << "[2]" << endl; remove(data_path.c_str()); rename(tmp_path.c_str(), data_path.c_str()); data_file = fopen(data_path.c_str(), "rb+"); delete []buf; }
void BTree<T>::inorder(BNode<T>& n) { if (n.id == manager.get_root().id) cout << "*"; cout << "" << n.id << "["; for (int i = 0; i < n.numkeys-1; ++i) cout << n.keys[i] << " "; for (int i = n.numkeys-1; i >= 0 && i < n.numkeys; ++i) cout << n.keys[i]; cout << "] "; int tmp[CHUNK_SIZE+2]; int sz = n.numkeys; if (!n.leaf) { memcpy(tmp, n.next, sizeof(int) * (CHUNK_SIZE+2)); return_node(n.id); cout << "( "; for (int i = 0; i < sz + 1; ++i) inorder(get_node(tmp[i])); cout << ") "; } else { return_node(n.id); } }
int main() { int i,j; mirror_1(); printf_MATRIX(); init_node(); calculate_node(); return_node(); // print_NODE(); mirror_2(); printf_MATRIX(); return 0; }
tree_node_t *make_tree(tree_node_t *list) { typedef struct { tree_node_t *node1; tree_node_t *node2; list_node_t *intv_list; int number; } st_item; st_item current, left, right; st_item stack[100]; int st_p = 0; tree_node_t *tmp, *root; int length = 0; for( tmp = list; tmp != NULL; tmp = tmp->right ) length += 1; /* find length of list */ root = get_node(); current.node1 = root; /* put root node on stack */ current.node2 = NULL; current.number = length;/* root expands to length leaves */ stack[ st_p++ ] = current; while( st_p >0 )/* there is still unexpanded node */ { current = stack[ --st_p ]; if( current.number > 1 ) /* create (empty) tree nodes */ { left.node1 = get_node(); left.node2 = current.node2; left.number = current.number / 2; right.node1 = get_node(); right.node2 = current.node1; right.number = current.number - left.number; (current.node1)->left = left.node1; (current.node1)->right = right.node1; stack[ st_p++ ] = right; stack[ st_p++ ] = left; } else /* reached a leaf, must be filled with list item */ { (current.node1)->left = list->left; /* fill leaf */ (current.node1)->key = list->key; /* from list */ // (current.node1)->intv_list = list->intv_list; (current.node1)->right = NULL; if( current.node2 != NULL ){ /* insert comparison key in interior node */ (current.node2)->key = list->key; // (current.node2)->intv_list = list->intv_list; } tmp = list; /* unlink first item from list */ list = list->right; /* content has been copied to */ return_node(tmp); /* leaf, so node is returned */ } } return( root ); }
void stmt(Token *tk) {// statement make_empty(); if (tk->id == If) if_node(tk); else if (tk->id == While) while_node(tk); else if (tk->id == For) for_node(tk); else if (tk->id == Int) int_node(tk); else if (tk->id == Ret) return_node(tk); else if (tk->id == Prtf) printf_node(tk); else if (tk->id == Stru) struct_dec(tk); else if (tk->id == ';') next(tk); else if (tk->id == '}') return ; else { expr(tk); assembly(pop()); } }
void BTree<T>::search_key_between(T& akey, T& bkey, pair<int, int>& node, pair<int, int>& pos) { int fnid = search(akey, true); int tnid = search(bkey, true); int fpos, tpos; int num, next; assert(fnid >= 0); BNode<T> &fnode = get_node(fnid); fpos = fnode.findkey(akey); num = fnode.numkeys; next = fnode.sibling; return_node(fnode.id); if (fpos >= num) { fnid = next; fpos = 0; } BNode<T> &tnode = get_node(tnid); tpos = tnode.findkey(bkey); return_node(tnode.id); node.first = fnid; node.second = tnid; pos.first = fpos; pos.second = tpos; }
// remove from tail region tail_pull(list* the_list){ list* temp; region temp_region; temp = the_list->next; // while you're not the one before the end while (temp->next->next != NULL){ temp = temp->next; } // get the last region temp_region = temp->next->the_region; // tell this penulatimate region it's now the end // ditch the end return_node(temp->next->next); temp->next = NULL; return(temp_region); }
char *delete_line(text_t *txt, int index) { text_t *tmp_node, *upper_node, *other_node; object_t *deleted_object; int finished; text_t * path_stack[100]; int path_st_p; int tmp_height, old_height; if(txt == NULL) { return NULL; } if(index > txt->key) { return NULL; } if(txt->right == NULL) { if(txt->key == index){ deleted_object = (object_t *)txt->left; txt->left = NULL; txt->key = 0; return (deleted_object); } }else{ path_st_p = 0; tmp_node = txt; while(tmp_node->right != NULL){ path_stack[path_st_p++] = tmp_node; upper_node = tmp_node; if(tmp_node->left->key >= index) { tmp_node = tmp_node->left; other_node = upper_node->right; }else { index -= tmp_node->left->key; tmp_node = tmp_node->right; other_node = upper_node->left; } } { upper_node->key = other_node->key; upper_node->left = other_node->left; upper_node->right = other_node->right; upper_node->height = other_node->height; deleted_object = (object_t *) tmp_node->left; return_node(tmp_node); return_node(other_node); } //rebalance finished = 0; path_st_p -= 1; while(path_st_p > 0 && !finished){ tmp_node = path_stack[--path_st_p]; tmp_node->key = tmp_node->left->key + tmp_node->right->key; old_height = tmp_node->height; if(tmp_node->left->height - tmp_node->right->height == 2 ){ if(tmp_node->left->left->height - tmp_node->right->height == 1 ){ right_rotation(tmp_node); tmp_node->key = tmp_node->right->key; tmp_node->right->key = tmp_node->right->left->key + tmp_node->right->right->key; tmp_node->right->height = tmp_node->right->left->height + 1; tmp_node->height = tmp_node->right->height + 1; }else{ left_rotation(tmp_node->left); right_rotation(tmp_node); tmp_node->key = tmp_node->right->key; tmp_node->right->key = tmp_node->right->left->key + tmp_node->right->right->key; tmp_height = tmp_node->left->left->height; tmp_node->left->height = tmp_height + 1; tmp_node->right->height = tmp_height + 1; tmp_node->height = tmp_height + 2; } }else if (tmp_node->left->height - tmp_node->right->height == -2 ){ if( tmp_node->right->right->height - tmp_node->left->height == 1 ){ left_rotation(tmp_node); //add line to update key. tmp_node->key = tmp_node->left->key; tmp_node->left->key = tmp_node->left->left->key + tmp_node->left->right->key; tmp_node->left->height = tmp_node->left->right->height + 1; tmp_node->height = tmp_node->left->height + 1; }else{ right_rotation(tmp_node->right); left_rotation(tmp_node); tmp_node->key = tmp_node->left->key; tmp_node->left->key = tmp_node->left->left->key + tmp_node->left->right->key; tmp_height = tmp_node->right->right->height; tmp_node->left->height = tmp_height + 1; tmp_node->right->height = tmp_height + 1; tmp_node->height = tmp_height + 2; } }else{ if(tmp_node->left->height > tmp_node->right->height) tmp_node->height = tmp_node->left->height + 1; else tmp_node->height = tmp_node->right->height + 1; } if(tmp_node->height == old_height) finished = 1; } while( path_st_p > 0){ tmp_node = path_stack[--path_st_p]; // add new line update key tmp_node->key = tmp_node->left->key + tmp_node->right->key; } return (deleted_object); } return NULL; }
void return_uf_node (uf_node_t * node) { return_node ((tree_node_t *) node); }
object_t *_delete_balanced(tree_node_t *tree, key_t delete_key) { tree_node_t *tmp_node, *upper_node, *other_node; //int finished; stack_t *stack; object_t *deleted_object; if( tree->left == NULL ) return( NULL ); else if( tree->right == NULL ) { if( tree->key == delete_key ) { deleted_object = (object_t *) tree->left; tree->left = NULL; return( deleted_object ); } else return( NULL ); } else { stack = create_stack(); tmp_node = tree; while( tmp_node->right != NULL ) { push(tmp_node,stack); upper_node = tmp_node; if( delete_key <= tmp_node->left->key ) { tmp_node = upper_node->left; other_node = upper_node->right; } else { delete_key = delete_key - tmp_node->left->key; tmp_node = upper_node->right; other_node = upper_node->left; } } if( tmp_node->key != delete_key ) return( NULL ); else { upper_node->key = other_node->key; upper_node->left = other_node->left; upper_node->right = other_node->right; upper_node->height = 0; deleted_object = (object_t *) tmp_node->left; return_node( tmp_node ); return_node( other_node ); update_leafcount(upper_node); } /* rebalance */ //finished = 0; /*if (!stack_empty(stack)) { print_stack(stack); }*/ //Throw out the top of stack. pop(stack); while( !stack_empty(stack))// && !finished ) { int tmp_height, old_height; tmp_node = pop(stack); tmp_node->key = tmp_node->left->key + tmp_node->right->key; old_height= tmp_node->height; if( tmp_node->left->height - tmp_node->right->height == 2 ) { if( tmp_node->left->left->height - tmp_node->right->height == 1 ) { right_rotation(tmp_node); tmp_node->right->height = tmp_node->right->left->height + 1; tmp_node->height = tmp_node->right->height + 1; } else { left_rotation(tmp_node->left); right_rotation(tmp_node); tmp_height = tmp_node->left->left->height; tmp_node->left->height = tmp_height + 1; tmp_node->right->height = tmp_height + 1; tmp_node->height = tmp_height + 2; } } else if( tmp_node->left->height - tmp_node->right->height == -2 ) { if( tmp_node->right->right->height - tmp_node->left->height == 1 ) { left_rotation( tmp_node ); tmp_node->left->height = tmp_node->left->right->height + 1; tmp_node->height = tmp_node->left->height + 1; } else { right_rotation( tmp_node->right ); left_rotation( tmp_node ); tmp_height = tmp_node->right->right->height; tmp_node->left->height = tmp_height + 1; tmp_node->right->height = tmp_height + 1; tmp_node->height = tmp_height + 2; } } else /* update height even if there was no rotation */ { if( tmp_node->left->height > tmp_node->right->height ) tmp_node->height = tmp_node->left->height + 1; else tmp_node->height = tmp_node->right->height + 1; } update_leafcount(tmp_node); /*if( tmp_node->height == old_height ) finished = 1;*/ } remove_stack(stack); } return( deleted_object ); }
char * delete_line(text_t *txt, int index) { char *deleted_object; text_t *path_stack[100]; int path_st_p = 0; text_t *tmp_node, *upper_node, *other_node; tmp_node = txt; while (index != 1 || tmp_node->weight != 1) { path_stack[path_st_p++] = tmp_node; upper_node = tmp_node; if (index <= tmp_node->left->weight) { //printf("goes to the left <----\n"); tmp_node = tmp_node->left; tmp_node = upper_node->left; other_node = upper_node->right; } else { //printf("goes to the right---->\n"); index = index - tmp_node->left->weight; tmp_node = tmp_node->right; tmp_node = upper_node->right; other_node = upper_node->left; } } upper_node->key = other_node->key; upper_node->left = other_node->left; upper_node->right = other_node->right; upper_node->weight = other_node->weight; deleted_object = (char *) tmp_node->left; return_node(tmp_node); return_node(other_node); /*start rebalance*/ path_st_p -= 1; while (path_st_p > 0) { tmp_node = path_stack[--path_st_p]; tmp_node->weight = tmp_node->left->weight + tmp_node->right->weight; if (tmp_node->right->weight < ALPHA * tmp_node->weight) { if (tmp_node->left->left->weight > (ALPHA + EPSILON) * tmp_node->weight) { right_rotation(tmp_node); tmp_node->right->weight = tmp_node->right->left->weight + tmp_node->right->right->weight; } else { left_rotation(tmp_node->left); right_rotation(tmp_node); tmp_node->right->weight = tmp_node->right->left->weight + tmp_node->right->right->weight; tmp_node->left->weight = tmp_node->left->left->weight + tmp_node->left->right->weight; } } else if (tmp_node->left->weight < ALPHA * tmp_node->weight) { if (tmp_node->right->right->weight > (ALPHA + EPSILON) * tmp_node->weight) { left_rotation(tmp_node); tmp_node->left->weight = tmp_node->left->left->weight + tmp_node->left->right->weight; } else { right_rotation(tmp_node->right); left_rotation(tmp_node); tmp_node->right->weight = tmp_node->right->left->weight + tmp_node->right->right->weight; tmp_node->left->weight = tmp_node->left->left->weight + tmp_node->left->right->weight; } } } /*end rebalance*/ return (deleted_object); }
object_t * find (tree_node_t * tree, key_t query_key) { int finished = 0; if (tree->object == NULL) return (NULL); /* tree empty */ else { tree_node_t *current_node, *stack_top, *tmp_stack; stack_top = NULL; current_node = tree; while (!finished) { tmp_stack = get_node (); tmp_stack->right = stack_top; tmp_stack->left = current_node; stack_top = tmp_stack; if (query_key < current_node->key && current_node->left != NULL) current_node = current_node->left; else if (query_key > current_node->key && current_node->right != NULL) current_node = current_node->right; else finished = 1; } if (current_node->key != query_key) return (NULL); else { tree_node_t *upper, *upper2; tmp_stack = stack_top; stack_top = stack_top->right; return_node (tmp_stack); while (current_node != tree) { upper = stack_top->left; tmp_stack = stack_top; stack_top = stack_top->right; return_node (tmp_stack); if (upper == tree) { if (upper->left == current_node) right_rotation (upper); else left_rotation (upper); current_node = upper; } else { upper2 = stack_top->left; tmp_stack = stack_top; stack_top = stack_top->right; return_node (tmp_stack); if (upper == upper2->left) { if (current_node == upper->left) right_rotation (upper2); else left_rotation (upper); right_rotation (upper2); } else { if (current_node == upper->right) left_rotation (upper2); else right_rotation (upper); left_rotation (upper2); } current_node = upper2; } } return (current_node->object); } } }
void BTree<T>::insert(T& key, void *data=NULL, int length=0) { int rootid = manager.get_root().id; return_node(rootid); insert(-1, rootid, key, data, length); }
/* This function deletes the line of number index, renumbering all lines after that line, and returns a pointer to the deleted line */ char * delete_line(text_t *txt, int index) { text_t *tmp_node, *upper_node, *other_node; object_t *deleted_object; int count = index; int finished; tmp_node = txt; if (txt->left == NULL || length_text(txt) < index) { return NULL; } else if (txt->right == NULL) { deleted_object = (object_t *)txt->left; txt->left = NULL; txt->parent = NULL; txt->key = -1; txt->height = -1; return (deleted_object); } else { while(tmp_node->right != NULL) { upper_node = tmp_node; (tmp_node->key)--; if (count <= tmp_node->left->key) { tmp_node = tmp_node->left; tmp_node = upper_node->left; other_node = upper_node->right; } else { count -= tmp_node->left->key; tmp_node = tmp_node->right; tmp_node = upper_node->right; other_node = upper_node->left; } } upper_node->key = other_node->key; upper_node->left = other_node->left; upper_node->right = other_node->right; upper_node->height = other_node->height; if (upper_node->right != NULL) { upper_node->left->parent = upper_node; upper_node->right->parent = upper_node; } deleted_object = (object_t *) tmp_node->left; return_node(tmp_node); return_node(other_node); upper_node = upper_node->parent; tmp_node = upper_node; finished = 0; while(!finished && tmp_node!=NULL) { int tmp_height, old_height; old_height = tmp_node->height; if (tmp_node->left->height - tmp_node->right->height == 2) { if (tmp_node->left->left->height - tmp_node->right->height == 1) { right_rotation(tmp_node); tmp_node->right->height = tmp_node->right->left->height + 1; tmp_node->height = tmp_node->right->height + 1; tmp_node->right->key = tmp_node->right->left->key + tmp_node->right->right->key; tmp_node->key = tmp_node->left->key + tmp_node->right->key; } else { left_rotation(tmp_node->left); right_rotation(tmp_node); tmp_height = tmp_node->left->left->height; tmp_node->left->height = tmp_height + 1; tmp_node->right->height = tmp_height + 1; tmp_node->height = tmp_height + 2; tmp_node->left->key = tmp_node->left->left->key + tmp_node->left->right->key; tmp_node->right->key = tmp_node->right->left->key + tmp_node->right->right->key; tmp_node->key = tmp_node->left->key + tmp_node->right->key; } } else if (tmp_node->left->height - tmp_node->right->height == -2) { if( tmp_node->right->right->height - tmp_node->left->height == 1) { left_rotation(tmp_node); tmp_node->left->height = tmp_node->left->right->height + 1; tmp_node->height = tmp_node->left->height + 1; tmp_node->left->key = tmp_node->left->left->key + tmp_node->left->right->key; tmp_node->key = tmp_node->left->key + tmp_node->right->key; } else { right_rotation(tmp_node->right); left_rotation(tmp_node); tmp_height = tmp_node->right->right->height; tmp_node->left->height = tmp_height + 1; tmp_node->right->height = tmp_height + 1; tmp_node->height = tmp_height + 2; tmp_node->right->key = tmp_node->right->left->key + tmp_node->right->right->key; tmp_node->left->key = tmp_node->left->left->key + tmp_node->left->right->key; tmp_node->key = tmp_node->left->key + tmp_node->right->key; } } else { if(tmp_node->left->height > tmp_node->right->height) { tmp_node->height = tmp_node->left->height + 1; } else { tmp_node->height = tmp_node->right->height + 1; } } if (tmp_node->height == old_height) { finished = 1; } tmp_node = tmp_node->parent; } return (deleted_object); } }