void AVLTree::insert_helper(const City& city, Node * & t) { if( t == NULL ) { t = new Node( city, NULL, NULL, 0 ); } else if( city < t->city ) { insert_helper( city, t->left ); if( height( t->left ) - height( t->right ) == 2 ) { if( city < t->left->city ) { rotateWithLeftChild( t ); } else { doubleWithLeftChild( t ); } } } else if( t->city < city ) { insert_helper( city, t->right ); if( height( t->right ) - height( t->left ) == 2 ) { if( t->right->city < city ) { rotateWithRightChild( t ); } else { doubleWithRightChild( t ); } } } else { // duplicate item so do nothing } t->height = MAX( height(t->left), height(t->right) ) + 1; }
void Binary_search_tree::insert_helper(int x, BST_node* t) { if (x >= t->get_data()) { if (!t->set_right_child(x)) insert_helper(x, t->get_right_child()); } else { if (!t->set_left_child(x)) insert_helper(x, t->get_left_child()); } }
bool minmaxheap::insert_helper(int x, int parent, int cur_loc) { if (isminlevel(cur_loc)) { if (x < heap[parent]) { heap[cur_loc] = heap[parent]; insert_helper(x, (parent-1)/2, parent); } else { heap[cur_loc] = x; } } else { if (x > heap[parent]) { heap[cur_loc] = heap[parent]; insert_helper(x, (parent-1)/2, parent); } else { heap[cur_loc] = x; } } }
void Binary_search_tree::insert(int x) { if (search(x) == nullptr) { if (root == nullptr) root = new BST_node(x); else insert_helper(x, root); num_nodes++; } }
int Q3ButtonGroup::insert(QAbstractButton *button, int id) { remove_helper(button); return insert_helper(button, id); }
void AVLTree::insert(const City& city) { insert_helper(city, root); }
list_t insert_list(list_t first, list_t second, unsigned int n) { return insert_helper(first, second, list_make(), n); }
static list_t insert_helper(list_t first, list_t second, list_t holder, unsigned int n) { if (!n) return append((append(reverse(holder), second)), first); return insert_helper(list_rest(first), second, list_make(list_first(first), holder), n-1); }
ATF_TC_BODY(rbt_remove, tc) { /* * This testcase checks that after node removal, the * binary-search tree is valid and all nodes that are supposed * to exist are present in the correct order. It mainly tests * DomainTree as a BST, and not particularly as a red-black * tree. This test checks node deletion when upper nodes have * data. */ isc_result_t result; size_t j; UNUSED(tc); isc_mem_debugging = ISC_MEM_DEBUGRECORD; result = dns_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); /* * Delete single nodes and check if the rest of the nodes exist. */ for (j = 0; j < ordered_names_count; j++) { dns_rbt_t *mytree = NULL; dns_rbtnode_t *node; size_t i; size_t *n; isc_boolean_t tree_ok; dns_rbtnodechain_t chain; size_t start_node; /* Create a tree. */ result = dns_rbt_create(mctx, delete_data, NULL, &mytree); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); /* Insert test data into the tree. */ for (i = 0; i < domain_names_count; i++) { node = NULL; result = insert_helper(mytree, domain_names[i], &node); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); } /* Check that all names exist in order. */ for (i = 0; i < ordered_names_count; i++) { dns_fixedname_t fname; dns_name_t *name; build_name_from_str(ordered_names[i], &fname); name = dns_fixedname_name(&fname); node = NULL; result = dns_rbt_findnode(mytree, name, NULL, &node, NULL, DNS_RBTFIND_EMPTYDATA, NULL, NULL); ATF_CHECK_EQ(result, ISC_R_SUCCESS); /* Add node data */ ATF_REQUIRE(node != NULL); ATF_REQUIRE_EQ(node->data, NULL); n = isc_mem_get(mctx, sizeof(size_t)); *n = i; node->data = n; } /* Now, delete the j'th node from the tree. */ { dns_fixedname_t fname; dns_name_t *name; build_name_from_str(ordered_names[j], &fname); name = dns_fixedname_name(&fname); result = dns_rbt_deletename(mytree, name, ISC_FALSE); ATF_CHECK_EQ(result, ISC_R_SUCCESS); } /* Check RB tree properties. */ tree_ok = dns__rbt_checkproperties(mytree); ATF_CHECK_EQ(tree_ok, ISC_TRUE); dns_rbtnodechain_init(&chain, mctx); /* Now, walk through nodes in order. */ if (j == 0) { /* * Node for ordered_names[0] was already deleted * above. We start from node 1. */ dns_fixedname_t fname; dns_name_t *name; build_name_from_str(ordered_names[0], &fname); name = dns_fixedname_name(&fname); node = NULL; result = dns_rbt_findnode(mytree, name, NULL, &node, NULL, 0, NULL, NULL); ATF_CHECK_EQ(result, ISC_R_NOTFOUND); build_name_from_str(ordered_names[1], &fname); name = dns_fixedname_name(&fname); node = NULL; result = dns_rbt_findnode(mytree, name, NULL, &node, &chain, 0, NULL, NULL); ATF_CHECK_EQ(result, ISC_R_SUCCESS); start_node = 1; } else { /* Start from node 0. */ dns_fixedname_t fname; dns_name_t *name; build_name_from_str(ordered_names[0], &fname); name = dns_fixedname_name(&fname); node = NULL; result = dns_rbt_findnode(mytree, name, NULL, &node, &chain, 0, NULL, NULL); ATF_CHECK_EQ(result, ISC_R_SUCCESS); start_node = 0; } /* * node and chain have been set by the code above at * this point. */ for (i = start_node; i < ordered_names_count; i++) { dns_fixedname_t fname_j, fname_i; dns_name_t *name_j, *name_i; build_name_from_str(ordered_names[j], &fname_j); name_j = dns_fixedname_name(&fname_j); build_name_from_str(ordered_names[i], &fname_i); name_i = dns_fixedname_name(&fname_i); if (dns_name_equal(name_i, name_j)) { /* * This may be true for the last node if * we seek ahead in the loop using * dns_rbtnodechain_next() below. */ if (node == NULL) { break; } /* All ordered nodes have data * initially. If any node is empty, it * means it was removed, but an empty * node exists because it is a * super-domain. Just skip it. */ if (node->data == NULL) { result = dns_rbtnodechain_next(&chain, NULL, NULL); if (result == ISC_R_NOMORE) { node = NULL; } else { dns_rbtnodechain_current(&chain, NULL, NULL, &node); } } continue; } ATF_REQUIRE(node != NULL); n = (size_t *) node->data; if (n != NULL) { /* printf("n=%zu, i=%zu\n", *n, i); */ ATF_CHECK_EQ(*n, i); } result = dns_rbtnodechain_next(&chain, NULL, NULL); if (result == ISC_R_NOMORE) { node = NULL; } else { dns_rbtnodechain_current(&chain, NULL, NULL, &node); } } /* We should have reached the end of the tree. */ ATF_REQUIRE_EQ(node, NULL); dns_rbt_destroy(&mytree); } dns_test_end(); }
ATF_TC_BODY(rbt_insert, tc) { isc_result_t result; test_context_t *ctx; dns_rbtnode_t *node; UNUSED(tc); isc_mem_debugging = ISC_MEM_DEBUGRECORD; result = dns_test_begin(NULL, ISC_TRUE); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ctx = test_context_setup(); /* Check node count before beginning. */ ATF_CHECK_EQ(15, dns_rbt_nodecount(ctx->rbt)); /* Try to insert a node that already exists. */ node = NULL; result = insert_helper(ctx->rbt, "d.e.f", &node); ATF_CHECK_EQ(result, ISC_R_EXISTS); /* Node count must not have changed. */ ATF_CHECK_EQ(15, dns_rbt_nodecount(ctx->rbt)); /* Try to insert a node that doesn't exist. */ node = NULL; result = insert_helper(ctx->rbt, "0", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(compare_labelsequences(node, "0"), ISC_TRUE); /* Node count must have increased. */ ATF_CHECK_EQ(16, dns_rbt_nodecount(ctx->rbt)); /* Another. */ node = NULL; result = insert_helper(ctx->rbt, "example.com", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_REQUIRE(node != NULL); ATF_CHECK_EQ(node->data, NULL); /* Node count must have increased. */ ATF_CHECK_EQ(17, dns_rbt_nodecount(ctx->rbt)); /* Re-adding it should return EXISTS */ node = NULL; result = insert_helper(ctx->rbt, "example.com", &node); ATF_CHECK_EQ(result, ISC_R_EXISTS); /* Node count must not have changed. */ ATF_CHECK_EQ(17, dns_rbt_nodecount(ctx->rbt)); /* Fission the node d.e.f */ node = NULL; result = insert_helper(ctx->rbt, "k.e.f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(compare_labelsequences(node, "k"), ISC_TRUE); /* Node count must have incremented twice ("d.e.f" fissioned to * "d" and "e.f", and the newly added "k"). */ ATF_CHECK_EQ(19, dns_rbt_nodecount(ctx->rbt)); /* Fission the node "g.h" */ node = NULL; result = insert_helper(ctx->rbt, "h", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(compare_labelsequences(node, "h"), ISC_TRUE); /* Node count must have incremented ("g.h" fissioned to "g" and * "h"). */ ATF_CHECK_EQ(20, dns_rbt_nodecount(ctx->rbt)); /* Add child domains */ node = NULL; result = insert_helper(ctx->rbt, "m.p.w.y.d.e.f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(compare_labelsequences(node, "m"), ISC_TRUE); ATF_CHECK_EQ(21, dns_rbt_nodecount(ctx->rbt)); node = NULL; result = insert_helper(ctx->rbt, "n.p.w.y.d.e.f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(compare_labelsequences(node, "n"), ISC_TRUE); ATF_CHECK_EQ(22, dns_rbt_nodecount(ctx->rbt)); node = NULL; result = insert_helper(ctx->rbt, "l.a", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(compare_labelsequences(node, "l"), ISC_TRUE); ATF_CHECK_EQ(23, dns_rbt_nodecount(ctx->rbt)); node = NULL; result = insert_helper(ctx->rbt, "r.d.e.f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "s.d.e.f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); ATF_CHECK_EQ(25, dns_rbt_nodecount(ctx->rbt)); node = NULL; result = insert_helper(ctx->rbt, "h.w.y.d.e.f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); /* Add more nodes one by one to cover left and right rotation * functions. */ node = NULL; result = insert_helper(ctx->rbt, "f", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "m", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "nm", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "om", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "k", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "l", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "fe", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "ge", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "i", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "ae", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); node = NULL; result = insert_helper(ctx->rbt, "n", &node); ATF_CHECK_EQ(result, ISC_R_SUCCESS); test_context_teardown(ctx); dns_test_end(); }
ATF_TC_BODY(benchmark, tc) { isc_result_t result; char namestr[sizeof("name18446744073709551616.example.org.")]; unsigned int r; dns_rbt_t *mytree; dns_rbtnode_t *node; unsigned int i; unsigned int maxvalue = 1000000; isc_time_t ts1, ts2; double t; unsigned int nthreads; isc_thread_t threads[32]; UNUSED(tc); srandom(time(NULL)); debug_mem_record = ISC_FALSE; result = dns_test_begin(NULL, ISC_TRUE); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); fnames = (dns_fixedname_t *) malloc(4000000 * sizeof(dns_fixedname_t)); names = (dns_name_t **) malloc(4000000 * sizeof(dns_name_t *)); values = (int *) malloc(4000000 * sizeof(int)); for (i = 0; i < 4000000; i++) { r = ((unsigned long) random()) % maxvalue; snprintf(namestr, sizeof(namestr), "name%u.example.org.", r); build_name_from_str(namestr, &fnames[i]); names[i] = dns_fixedname_name(&fnames[i]); values[i] = r; } /* Create a tree. */ mytree = NULL; result = dns_rbt_create(mctx, NULL, NULL, &mytree); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); /* Insert test data into the tree. */ for (i = 0; i < maxvalue; i++) { snprintf(namestr, sizeof(namestr), "name%u.example.org.", i); node = NULL; result = insert_helper(mytree, namestr, &node); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); node->data = (void *) (intptr_t) i; } result = isc_time_now(&ts1); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); nthreads = ISC_MIN(isc_os_ncpus(), 32); nthreads = ISC_MAX(nthreads, 1); for (i = 0; i < nthreads; i++) { result = isc_thread_create(find_thread, mytree, &threads[i]); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); } for (i = 0; i < nthreads; i++) { result = isc_thread_join(threads[i], NULL); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); } result = isc_time_now(&ts2); ATF_REQUIRE_EQ(result, ISC_R_SUCCESS); t = isc_time_microdiff(&ts2, &ts1); printf("%u findnode calls, %f seconds, %f calls/second\n", nthreads * 8 * 4000000, t / 1000000.0, (nthreads * 8 * 4000000) / (t / 1000000.0)); free(values); free(names); free(fnames); dns_rbt_destroy(&mytree); dns_test_end(); }
typename Map<T,H>::Iterator Map<T,H>::insert(const_value_type &obj) { //std::cout<<++i<<'\n'; Node *new_node = new Node(obj); return insert_helper(new_node); }