/**
* 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;
}
/**
* 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));
}
}
}
/**
* Return iterator reference previous element.
*/
_avl_tree_iterator_t _avl_tree_iterator_prev(_avl_tree_iterator_t it_iter)
{
_avlnode_t* pt_prev = NULL;
_avlnode_t* pt_cur = (_avlnode_t*)_AVL_TREE_ITERATOR_COREPOS(it_iter);
assert(_avl_tree_iterator_belong_to_avl_tree(_AVL_TREE_ITERATOR_TREE(it_iter), it_iter));
assert(!_avl_tree_iterator_equal(it_iter, _avl_tree_begin(_AVL_TREE_ITERATOR_TREE(it_iter))));
/* previous end */
if (_avl_tree_iterator_equal(it_iter, _avl_tree_end(_AVL_TREE_ITERATOR_TREE(it_iter)))) {
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)_AVL_TREE_ITERATOR_TREE(it_iter)->_t_avlroot._pt_right;
} else {
if (pt_cur->_pt_left != NULL) {
/*
* A
* / \
* B C
* / \ \
* D E F
* /
* G
* current : A
* previous : E
*/
pt_prev = pt_cur->_pt_left;
while (pt_prev->_pt_right != NULL) {
pt_prev = pt_prev->_pt_right;
}
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev;
} else {
/*
* A
* / \
* B C
* / / \
* D E F
* /
* G
*
* current : G
* previous : A
*/
pt_prev = pt_cur->_pt_parent;
while (pt_cur == pt_prev->_pt_left) {
pt_cur = pt_prev;
pt_prev = pt_prev->_pt_parent;
}
/*
* there is no same special condition as next, because the begin
* iterator is the valid iterator
*/
_AVL_TREE_ITERATOR_COREPOS(it_iter) = (_byte_t*)pt_prev;
}
}
return 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;
}
/** exported function implementation section **/
void test_avl_tree(void)
{
avl_tree_t t_tree = _create_avl_tree(sizeof(int), "int");
avl_tree_t t_tree2 = _create_avl_tree(sizeof(int), "int");
int n_value = 900;
_avl_tree_init(&t_tree, NULL, NULL);
_avl_tree_insert_equal(&t_tree, &n_value);
printf("avl tree1 - size:%u, max_size:%u, empty:%d\n",
_avl_tree_size(&t_tree), _avl_tree_max_size(&t_tree), _avl_tree_empty(&t_tree));
/*_avl_tree_init_copy_range(*/
/*&t_tree2, _avl_tree_begin(&t_tree), _avl_tree_begin(&t_tree));*/
/*printf("avl tree2 - size:%u, max_size:%u, empty:%d\n",*/
/*_avl_tree_size(&t_tree2), _avl_tree_max_size(&t_tree2), _avl_tree_empty(&t_tree2));*/
_avl_tree_init_copy_range_cmp(
&t_tree2, _avl_tree_begin(&t_tree), _avl_tree_begin(&t_tree), NULL);
printf("avl tree2 - size:%u, max_size:%u, empty:%d\n",
_avl_tree_size(&t_tree2), _avl_tree_max_size(&t_tree2), _avl_tree_empty(&t_tree2));
_avl_tree_insert_equal_range(
&t_tree2, _avl_tree_begin(&t_tree), _avl_tree_begin(&t_tree));
printf("avl tree2 - size:%u, max_size:%u, empty:%d\n",
_avl_tree_size(&t_tree2), _avl_tree_max_size(&t_tree2), _avl_tree_empty(&t_tree2));
_avl_tree_insert_unique_range(
&t_tree2, _avl_tree_end(&t_tree), _avl_tree_end(&t_tree));
printf("avl tree2 - size:%u, max_size:%u, empty:%d\n",
_avl_tree_size(&t_tree2), _avl_tree_max_size(&t_tree2), _avl_tree_empty(&t_tree2));
_avl_tree_erase_range(&t_tree2, _avl_tree_begin(&t_tree2), _avl_tree_begin(&t_tree2));
printf("avl tree2 - size:%u, max_size:%u, empty:%d\n",
_avl_tree_size(&t_tree2), _avl_tree_max_size(&t_tree2), _avl_tree_empty(&t_tree2));
_avl_tree_destroy(&t_tree);
_avl_tree_destroy(&t_tree2);
}
multimap_iterator_t multimap_begin(const multimap_t* cpt_multimap)
{
multimap_iterator_t t_newiterator;
assert(cpt_multimap != NULL);
#ifdef CSTL_MULTIMAP_AVL_TREE
t_newiterator = _avl_tree_begin(_GET_MULTIMAP_AVL_TREE(cpt_multimap));
#else
t_newiterator = _rb_tree_begin(_GET_MULTIMAP_RB_TREE(cpt_multimap));
#endif
_GET_CONTAINER(&t_newiterator) = (multimap_t*)cpt_multimap;
_GET_MULTIMAP_CONTAINER_TYPE(&t_newiterator) = _MULTIMAP_CONTAINER;
_GET_MULTIMAP_ITERATOR_TYPE(&t_newiterator) = _BIDIRECTIONAL_ITERATOR;
return t_newiterator;
}
/**
* Return an iterator that addresses the first element in the set.
*/
set_iterator_t set_begin(const set_t* cpset_set)
{
set_iterator_t it_begin;
assert(cpset_set != NULL);
#ifdef CSTL_SET_AVL_TREE
it_begin = _avl_tree_begin(&cpset_set->_t_tree);
#else
it_begin = _rb_tree_begin(&cpset_set->_t_tree);
#endif
_ITERATOR_CONTAINER(it_begin) = (set_t*)cpset_set;
_SET_ITERATOR_CONTAINER_TYPE(it_begin) = _SET_CONTAINER;
_SET_ITERATOR_ITERATOR_TYPE(it_begin) = _BIDIRECTIONAL_ITERATOR;
return it_begin;
}
/**
* Return an iterator that addresses the first element in the map.
*/
map_iterator_t map_begin(const map_t* cpmap_map)
{
map_iterator_t it_begin;
assert(cpmap_map != NULL);
assert(_pair_is_inited(&cpmap_map->_pair_temp));
#ifdef CSTL_MAP_AVL_TREE
it_begin = _avl_tree_begin(&cpmap_map->_t_tree);
#else
it_begin = _rb_tree_begin(&cpmap_map->_t_tree);
#endif
_GET_CONTAINER(it_begin) = (map_t*)cpmap_map;
_GET_MAP_CONTAINER_TYPE(it_begin) = _MAP_CONTAINER;
_GET_MAP_ITERATOR_TYPE(it_begin) = _BIDIRECTIONAL_ITERATOR;
return it_begin;
}
/**
* 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));
}
}
