/** * Tests if the two avl tree are equal. */ bool_t _avl_tree_equal(const _avl_tree_t* cpt_first, const _avl_tree_t* cpt_second) { _avl_tree_iterator_t it_first; _avl_tree_iterator_t it_first_begin; _avl_tree_iterator_t it_first_end; _avl_tree_iterator_t it_second; _avl_tree_iterator_t it_second_begin; _avl_tree_iterator_t it_second_end; bool_t b_less = false; bool_t b_greater = false; assert(cpt_first != NULL); assert(cpt_second != NULL); assert(_avl_tree_is_inited(cpt_first)); assert(_avl_tree_is_inited(cpt_second)); assert(_avl_tree_same_type_ex(cpt_first, cpt_second)); if (cpt_first == cpt_second) { return true; } /* test avl tree size */ if (_avl_tree_size(cpt_first) != _avl_tree_size(cpt_second)) { return false; } it_first_begin = _avl_tree_begin(cpt_first); it_first_end = _avl_tree_end(cpt_first); it_second_begin = _avl_tree_begin(cpt_second); it_second_end = _avl_tree_end(cpt_second); /* test each element */ for (it_first = it_first_begin, it_second = it_second_begin; !_avl_tree_iterator_equal(it_first, it_first_end) && !_avl_tree_iterator_equal(it_second, it_second_end); it_first = _avl_tree_iterator_next(it_first), it_second = _avl_tree_iterator_next(it_second)) { b_less = b_greater = _GET_AVL_TREE_TYPE_SIZE(cpt_first); _GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)( ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data, ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data, &b_less); _GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)( ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data, ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data, &b_greater); if (b_less || b_greater) { return false; } } assert(_avl_tree_iterator_equal(it_first, it_first_end) && _avl_tree_iterator_equal(it_second, it_second_end)); return true; }
/** * Test the first iterator is before the second. */ bool_t _avl_tree_iterator_before(_avl_tree_iterator_t it_first, _avl_tree_iterator_t it_second) { _avl_tree_iterator_t it_iter; _avl_tree_iterator_t it_end; _avl_tree_t* pt_avl_tree = NULL; assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_first), it_first)); assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_second), it_second)); assert(_AVL_TREE_ITERATOR_TREE(it_first) == _AVL_TREE_ITERATOR_TREE(it_second)); /* first iterator equal to second iterator */ if (_AVL_TREE_ITERATOR_COREPOS(it_first) == _AVL_TREE_ITERATOR_COREPOS(it_second)) { return false; } /* else travel subtree for search second iterator */ pt_avl_tree = _AVL_TREE_ITERATOR_TREE(it_first); it_end = _avl_tree_end(pt_avl_tree); for (it_iter = it_first; !_avl_tree_iterator_equal(it_iter, it_end); it_iter = _avl_tree_iterator_next(it_iter)) { if (_avl_tree_iterator_equal(it_iter, it_second)) { return true; } } return _avl_tree_iterator_equal(it_second, it_end) ? true : false; }
/** * Assign avl tree container. */ void _avl_tree_assign(_avl_tree_t* pt_dest, const _avl_tree_t* cpt_src) { assert(pt_dest != NULL); assert(cpt_src != NULL); assert(_avl_tree_is_inited(pt_dest)); assert(_avl_tree_is_inited(cpt_src)); assert(_avl_tree_same_type_ex(pt_dest, cpt_src)); if (!_avl_tree_equal(pt_dest, cpt_src)) { _avl_tree_iterator_t it_iter; _avl_tree_iterator_t it_begin; _avl_tree_iterator_t it_end; /* clear dest avl tree */ _avl_tree_clear(pt_dest); it_begin = _avl_tree_begin(cpt_src); it_end = _avl_tree_end(cpt_src); /* insert all elements of src into dest */ for (it_iter = it_begin; !_avl_tree_iterator_equal(it_iter, it_end); it_iter = _avl_tree_iterator_next(it_iter)) { _avl_tree_insert_equal(pt_dest, _avl_tree_iterator_get_pointer_ignore_cstr(it_iter)); } } }
/** * Tests if the first avl tree is less than the second avl tree. */ bool_t _avl_tree_less(const _avl_tree_t* cpt_first, const _avl_tree_t* cpt_second) { _avl_tree_iterator_t it_first; _avl_tree_iterator_t it_first_begin; _avl_tree_iterator_t it_first_end; _avl_tree_iterator_t it_second; _avl_tree_iterator_t it_second_begin; _avl_tree_iterator_t it_second_end; bool_t b_result = false; assert(cpt_first != NULL); assert(cpt_second != NULL); assert(_avl_tree_is_inited(cpt_first)); assert(_avl_tree_is_inited(cpt_second)); assert(_avl_tree_same_type_ex(cpt_first, cpt_second)); it_first_begin = _avl_tree_begin(cpt_first); it_first_end = _avl_tree_end(cpt_first); it_second_begin = _avl_tree_begin(cpt_second); it_second_end = _avl_tree_end(cpt_second); /* test each element */ for (it_first = it_first_begin, it_second = it_second_begin; !_avl_tree_iterator_equal(it_first, it_first_end) && !_avl_tree_iterator_equal(it_second, it_second_end); it_first = _avl_tree_iterator_next(it_first), it_second = _avl_tree_iterator_next(it_second)) { b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_first); _GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)( ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data, ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data, &b_result); if (b_result) { return true; } b_result = _GET_AVL_TREE_TYPE_SIZE(cpt_first); _GET_AVL_TREE_TYPE_LESS_FUNCTION(cpt_first)( ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_second))->_pby_data, ((_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_first))->_pby_data, &b_result); if (b_result) { return false; } } return _avl_tree_size(cpt_first) < _avl_tree_size(cpt_second) ? true : false; }
/** * Return iterator reference next element. */ set_iterator_t _set_iterator_next(set_iterator_t it_iter) { assert(_GET_SET_CONTAINER_TYPE(it_iter) == _SET_CONTAINER); assert(_GET_SET_ITERATOR_TYPE(it_iter) == _BIDIRECTIONAL_ITERATOR); #ifdef CSTL_SET_AVL_TREE return _avl_tree_iterator_next(it_iter); #else return _rb_tree_iterator_next(it_iter); #endif }
void _multimap_iterator_next( const struct _tagmultimap* cpt_multimap, multimap_iterator_t* pt_iterator) { assert(cpt_multimap != NULL && pt_iterator != NULL); assert( _GET_MULTIMAP_CONTAINER_TYPE(pt_iterator) == _MULTIMAP_CONTAINER && _GET_MULTIMAP_ITERATOR_TYPE(pt_iterator) == _BIDIRECTIONAL_ITERATOR && _GET_MULTIMAP_CONTAINER(pt_iterator) == cpt_multimap); #ifdef CSTL_MULTIMAP_AVL_TREE _avl_tree_iterator_next(_GET_MULTIMAP_AVL_TREE(cpt_multimap), pt_iterator); #else _rb_tree_iterator_next(_GET_MULTIMAP_RB_TREE(cpt_multimap), pt_iterator); #endif }
/* * Erase a range of element in an avl tree. */ void _avl_tree_erase_range(_avl_tree_t* pt_avl_tree, _avl_tree_iterator_t it_begin, _avl_tree_iterator_t it_end) { _avl_tree_iterator_t it_iter; _avl_tree_iterator_t it_next; assert(pt_avl_tree != NULL); assert(_avl_tree_is_inited(pt_avl_tree)); assert(_avl_tree_iterator_belong_to_avl_tree(pt_avl_tree, it_begin)); assert(_avl_tree_iterator_belong_to_avl_tree(pt_avl_tree, it_end)); assert(_avl_tree_iterator_equal(it_begin, it_end) || _avl_tree_iterator_before(it_begin, it_end)); it_iter = it_next = it_begin; if (!_avl_tree_iterator_equal(it_next, _avl_tree_end(pt_avl_tree))) { it_next = _avl_tree_iterator_next(it_next); } while (!_avl_tree_iterator_equal(it_iter, it_end)) { _avl_tree_erase_pos(pt_avl_tree, it_iter); it_iter = it_next; if (!_avl_tree_iterator_equal(it_next, _avl_tree_end(pt_avl_tree))) { it_next = _avl_tree_iterator_next(it_next); } } }
/** * Return an iterator to the first element that is equal to or greater than a specific element. */ _avl_tree_iterator_t _avl_tree_lower_bound(const _avl_tree_t* cpt_avl_tree, const void* cpv_value) { _avlnode_t* pt_cur = NULL; _avlnode_t* pt_prev = NULL; bool_t b_less = false; bool_t b_greater = false; _avl_tree_iterator_t it_iter; assert(cpt_avl_tree != NULL); assert(cpv_value != NULL); assert(_avl_tree_is_inited(cpt_avl_tree)); it_iter = _create_avl_tree_iterator(); _AVL_TREE_ITERATOR_TREE_POINTER(it_iter) = (void*)cpt_avl_tree; if (!_avl_tree_empty(cpt_avl_tree)) { pt_prev = cpt_avl_tree->_t_avlroot._pt_parent; b_less = b_greater = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree); _avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpv_value, pt_prev->_pby_data, &b_less); _avl_tree_elem_compare_auxiliary(cpt_avl_tree, pt_prev->_pby_data, cpv_value, &b_greater); pt_cur = (b_less || !b_greater) ? pt_prev->_pt_left : pt_prev->_pt_right; while (pt_cur != NULL) { pt_prev = pt_cur; b_less = b_greater = _GET_AVL_TREE_TYPE_SIZE(cpt_avl_tree); _avl_tree_elem_compare_auxiliary(cpt_avl_tree, cpv_value, pt_prev->_pby_data, &b_less); _avl_tree_elem_compare_auxiliary(cpt_avl_tree, pt_prev->_pby_data, cpv_value, &b_greater); pt_cur = (b_less || !b_greater) ? pt_prev->_pt_left : pt_prev->_pt_right; } if (b_less || !b_greater) { assert(pt_prev->_pt_left == NULL); _AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev; assert(_avl_tree_iterator_belong_to_avl_tree(cpt_avl_tree, it_iter)); } else { assert(pt_prev->_pt_right == NULL); _AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev; it_iter = _avl_tree_iterator_next(it_iter); } } else { it_iter = _avl_tree_end(cpt_avl_tree); } return it_iter; }
/** * Initialize avl tree container with avl tree. */ void _avl_tree_init_copy(_avl_tree_t* pt_dest, const _avl_tree_t* cpt_src) { _avl_tree_iterator_t it_iter; _avl_tree_iterator_t it_begin; _avl_tree_iterator_t it_end; assert(pt_dest != NULL); assert(cpt_src != NULL); assert(_avl_tree_is_created(pt_dest)); assert(_avl_tree_is_inited(cpt_src)); assert(_avl_tree_same_type(pt_dest, cpt_src)); /* init the avl tree with the src avl tree */ _avl_tree_init(pt_dest, cpt_src->_t_compare); it_begin = _avl_tree_begin(cpt_src); it_end = _avl_tree_end(cpt_src); /* insert all elements of src into dest */ for (it_iter = it_begin; !_avl_tree_iterator_equal(it_iter, it_end); it_iter = _avl_tree_iterator_next(it_iter)) { _avl_tree_insert_equal(pt_dest, _avl_tree_iterator_get_pointer_ignore_cstr(it_iter)); } }
/** * Calculate distance between two iterators. */ int _avl_tree_iterator_distance(_avl_tree_iterator_t it_first, _avl_tree_iterator_t it_second) { _avl_tree_iterator_t it_iter; int n_distance = 0; assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_first), it_first)); assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_second), it_second)); assert(_AVL_TREE_ITERATOR_TREE(it_first) == _AVL_TREE_ITERATOR_TREE(it_second)); if (_avl_tree_iterator_before(it_first, it_second)) { for (it_iter = it_first; !_avl_tree_iterator_equal(it_iter, it_second); it_iter = _avl_tree_iterator_next(it_iter)) { n_distance++; } return n_distance; } else if (_avl_tree_iterator_before(it_second, it_first)) { for (it_iter = it_second; !_avl_tree_iterator_equal(it_iter, it_first); it_iter = _avl_tree_iterator_next(it_iter)) { n_distance++; } return -n_distance; } else { return 0; } }