apaki/unicstl
1
0
Fork 0
mirror of https://gitee.com/apaki/unicstl.git synced 2025-05-17 19:41:36 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

tree删除旧版迭代器接口

Browse Source
This commit is contained in:
建峰 2025-04-24 23:35:31 +08:00
parent 5302206376
commit 461e32b430
3 changed files with 73 additions and 733 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/tree.h
View File

@ -95,15 +95,6 @@ struct _tree
// iter
iterator_t (*iter)(struct _tree* self, enum _order);
/**
* @brief
*
*/
void (*set_order)(struct _tree* self, enum _order order);
void* (*begin)(struct _tree* self);
void* (*next)(struct _tree* self);
void* (*end)(struct _tree* self);
/**
* @brief obj compare with obj2
*

436
src/tree.c
View File

@ -1463,432 +1463,6 @@ static bool tree_rb_delete(struct _tree* self, void* obj)
return true;
}
static void tree_set_order(struct _tree* self, enum _order order)
{
assert(self != NULL);
self->_order = order;
}
static void* tree_begin(struct _tree* self)
{
assert(self != NULL);
switch (self->_order)
{
case ORDER_LEFT_PRE:
case ORDER_RIGHT_PRE:
{
struct _tree_node* node = NULL;
self->cur_node = self->_root;
self->stack->clear(self->stack);
if (self->_order == ORDER_LEFT_PRE)
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
node = self->cur_node;
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->left;
break;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
self->cur_node = self->cur_node->right;
}
}
}
else
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
node = self->cur_node;
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->right;
break;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
self->cur_node = self->cur_node->left;
}
}
}
if (node == NULL)
{
return NULL;
}
return node->obj;
}break;
case ORDER_LEFT_IN:
case ORDER_RIGHT_IN:
{
struct _tree_node* node = NULL;
self->cur_node = self->_root;
self->stack->clear(self->stack);
if (self->_order == ORDER_LEFT_IN)
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->left;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
// self->print_obj(self->cur_node->obj);
node = self->cur_node;
self->cur_node = self->cur_node->right;
break;
}
}
}
else
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->right;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
// self->print_obj(self->cur_node->obj);
node = self->cur_node;
self->cur_node = self->cur_node->left;
break;
}
}
}
if (node == NULL)
{
return NULL;
}
return node->obj;
}break;
case ORDER_LEFT_POST:
case ORDER_RIGHT_POST:
{
struct _tree_node* node = self->_root;
self->stack->clear(self->stack);
stack_t stack = stack_new(sizeof(struct _tree_node*));
if (self->_order == ORDER_LEFT_POST)
{
while (!stack->empty(stack) || node != NULL)
{
if (node != NULL)
{
self->stack->push(self->stack, &node);
stack->push(stack, &node);
node = node->right;
}
else
{
stack->pop(stack, &node);
node = node->left;
}
}
}
else
{
while (!stack->empty(stack) || node != NULL)
{
if (node != NULL)
{
self->stack->push(self->stack, &node);
stack->push(stack, &node);
node = node->left;
}
else
{
stack->pop(stack, &node);
node = node->right;
}
}
}
stack_free(&stack);
if (!self->stack->empty(self->stack))
{
self->stack->pop(self->stack, &self->cur_node);
}
else
{
self->cur_node = NULL;
}
return self->cur_node == NULL ? NULL : self->cur_node->obj;
}break;
case ORDER_LEFT_BREADTH:
case ORDER_RIGHT_BREADTH:
{
struct _tree_node* node = self->_root;
self->queue->clear(self->queue);
queue_t queue = self->queue;
if (node != NULL)
{
queue->push(queue, &node);
if (!queue->empty(queue))
{
queue->pop(queue, &node);
if (self->_order == ORDER_LEFT_BREADTH)
{
if (node->left != NULL)
{
queue->push(queue, &node->left);
}
if (node->right != NULL)
{
queue->push(queue, &node->right);
}
}
else
{
if (node->right != NULL)
{
queue->push(queue, &node->right);
}
if (node->left != NULL)
{
queue->push(queue, &node->left);
}
}
self->cur_node = node;
}
else
{
self->cur_node = NULL;
}
}
return self->cur_node == NULL ? NULL : self->cur_node->obj;
}break;
default:
{
}break;
}
}
static void* tree_next(struct _tree* self)
{
assert(self != NULL);
switch (self->_order)
{
case ORDER_LEFT_PRE:
case ORDER_RIGHT_PRE:
{
struct _tree_node* node = NULL;
if (self->_order == ORDER_LEFT_PRE)
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
node = self->cur_node;
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->left;
break;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
self->cur_node = self->cur_node->right;
}
}
}
else
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
node = self->cur_node;
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->right;
break;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
self->cur_node = self->cur_node->left;
}
}
}
if (node == NULL)
{
return NULL;
}
return node->obj;
}break;
case ORDER_LEFT_IN:
case ORDER_RIGHT_IN:
{
struct _tree_node* node = NULL;
if (self->_order == ORDER_LEFT_IN)
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->left;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
node = self->cur_node;
self->cur_node = self->cur_node->right;
break;
}
}
}
else
{
while (!self->stack->empty(self->stack) || self->cur_node != NULL)
{
if (self->cur_node != NULL)
{
self->stack->push(self->stack, &self->cur_node);
self->cur_node = self->cur_node->right;
}
else
{
self->stack->pop(self->stack, &self->cur_node);
node = self->cur_node;
self->cur_node = self->cur_node->left;
break;
}
}
}
if (node == NULL)
{
return NULL;
}
return node->obj;
}break;
case ORDER_LEFT_POST:
case ORDER_RIGHT_POST:
{
if (!self->stack->empty(self->stack))
{
self->stack->pop(self->stack, &self->cur_node);
}
else
{
self->cur_node = NULL;
}
return self->cur_node == NULL ? NULL : self->cur_node->obj;
}break;
case ORDER_LEFT_BREADTH:
case ORDER_RIGHT_BREADTH:
{
struct _tree_node* node = self->cur_node;
queue_t queue = self->queue;
if (!queue->empty(queue) && node != NULL)
{
queue->pop(queue, &node);
if (self->_order == ORDER_LEFT_BREADTH)
{
if (node->left != NULL)
{
queue->push(queue, &node->left);
}
if (node->right != NULL)
{
queue->push(queue, &node->right);
}
}
else
{
if (node->right != NULL)
{
queue->push(queue, &node->right);
}
if (node->left != NULL)
{
queue->push(queue, &node->left);
}
}
self->cur_node = node;
}
else
{
self->cur_node = NULL;
}
return self->cur_node == NULL ? NULL : self->cur_node->obj;
}break;
default:
{
}break;
}
}
static void* tree_end(struct _tree* self)
{
assert(self != NULL);
switch (self->_order)
{
case ORDER_LEFT_PRE:
{
return NULL;
}break;
case ORDER_LEFT_IN:
{
return NULL;
}break;
case ORDER_LEFT_POST:
{
return NULL;
}break;
case ORDER_LEFT_BREADTH:
{
return NULL;
}break;
case ORDER_RIGHT_PRE:
{
return NULL;
}break;
case ORDER_RIGHT_IN:
{
return NULL;
}break;
case ORDER_RIGHT_POST:
{
return NULL;
}break;
case ORDER_RIGHT_BREADTH:
{
return NULL;
}break;
default:
{
}break;
}
}
iterator_t tree_iter(struct _tree* self, enum _order order)
{
assert(self != NULL);
@ -2197,11 +1771,6 @@ static bool tree_avl_init(struct _tree* self, uint32_t obj_size)
self->max = tree_max;
self->min = tree_min;
self->set_order = tree_set_order;
self->begin = tree_begin;
self->next = tree_next;
self->end = tree_end;
self->_root = NULL;
self->stack = stack_new(sizeof(struct _tree_node*));
@ -2260,11 +1829,6 @@ static bool tree_rb_init(struct _tree* self, uint32_t obj_size)
self->max = tree_max;
self->min = tree_min;
self->set_order = tree_set_order;
self->begin = tree_begin;
self->next = tree_next;
self->end = tree_end;
self->_root = NULL;
self->stack = stack_new(sizeof(struct _tree_node*));

361
test/test_tree.c
View File

@ -508,76 +508,55 @@ static const int expected_int_array_orderpre_delete[15][15] = {
{ 13, },
};
static const enum _order order[8] = {
ORDER_LEFT_PRE, ORDER_LEFT_IN, ORDER_LEFT_POST, ORDER_LEFT_BREADTH,
ORDER_RIGHT_PRE, ORDER_RIGHT_IN, ORDER_RIGHT_POST, ORDER_RIGHT_BREADTH
};
static uint32_t iter2array_num(iterator_t iter, int *data)
{
uint32_t count = 0;
while(iter->hasnext(iter))
{
data[count] = *(int *)iter->next(iter);
count++;
}
return count;
}
static void test_avltree_iter(void)
{
uint32_t i = 0;
// int data[] = { 2,1,3,4};
// int data[] = { 1,2,3,4,5,6};
// int data[] = { 5,2,3,1,7,8,6 };
// int data[] = { 5,2,3,1,7,8,6,4,9,10,12,11,15,14,13 };
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[15];
uint32_t len = sizeof(data) / sizeof(int);
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
int * iter = NULL;
int count = 0;
iterator_t iter = NULL;
tree_t tree = tree_avl_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
memcpy(data, expected_int_array[0], len);
for (i = 0; i < len; i++)
{
temp = data[i];
TEST_ASSERT_TRUE(tree->insert(tree, &temp));
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
buff[count++] = *iter;
}
iter = tree->iter(tree, ORDER_LEFT_PRE);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_insert[i], buff, count);
}
for(i = 1; i < 9; i++)
for(i = 0; i < 8; i++)
{
tree->set_order(tree, i); //ORDER_LEFT_IN
// printf("\n ----- iter test -----\n");
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
// printf("(%2d ) ", *iter);
buff[count++] = *iter;
}
// printf("\n");
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[i], buff, count);
iter = tree->iter(tree, order[i]);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[i + 1], buff, count);
}
#if 0
tree->order(tree, true);
printf("\n\nactual data = \n");
tree->postorder(tree, tree->_root);
printf("\n");
// set order
// tree->set_order(tree, ORDER_LEFT_PRE);
// tree->set_order(tree, ORDER_LEFT_IN);
// tree->set_order(tree, ORDER_LEFT_POST);
// tree->set_order(tree, ORDER_LEFT_BREADTH);
// tree->set_order(tree, ORDER_RIGHT_PRE);
// tree->set_order(tree, ORDER_RIGHT_IN);
tree->set_order(tree, ORDER_RIGHT_POST);
// tree->set_order(tree, ORDER_RIGHT_BREADTH);
printf("\n ----- iter data -----\n");
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
printf("(%2d ) ", *iter);
buff[count++] = *iter;
}
printf("\n");
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[tree->_order], buff, count);
#endif
TEST_ASSERT_FALSE(tree->empty(tree));
TEST_ASSERT_TRUE(tree->clear(tree));
TEST_ASSERT_TRUE(tree->empty(tree));
@ -589,46 +568,34 @@ static void test_avltree_iter(void)
static void test_avltree_insert(void)
{
uint32_t i = 0;
// int data[] = { 2,1,3,4};
// int data[] = { 1,2,3,4,5,6};
// int data[] = { 5,2,3,1,7,8,6 };
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int buff[15];
uint32_t len = sizeof(data) / sizeof(int);
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
int * iter = NULL;
int count = 0;
iterator_t iter = NULL;
tree_t tree = tree_avl_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
memcpy(data, expected_int_array[0], len);
for (i = 0; i < len; i++)
{
temp = data[i];
TEST_ASSERT_TRUE(tree->insert(tree, &temp));
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
buff[count++] = *iter;
}
iter = tree->iter(tree, ORDER_LEFT_PRE);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_insert[i], buff, count);
}
for(i = 1; i < 9; i++)
for(i = 0; i < 8; i++)
{
tree->set_order(tree, i); //ORDER_LEFT_IN
// printf("\n ----- iter test -----\n");
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
// printf("(%2d ) ", *iter);
buff[count++] = *iter;
}
// printf("\n");
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[i], buff, count);
iter = tree->iter(tree, order[i]);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[i + 1], buff, count);
}
tree_free(&tree);
@ -638,20 +605,19 @@ static void test_avltree_insert(void)
static void test_avltree_delete(void)
{
uint32_t i = 0;
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[15];
uint32_t len = sizeof(data) / sizeof(int);
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
int * iter = NULL;
int count = 0;
iterator_t iter = NULL;
tree_t tree = tree_avl_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
memcpy(data, expected_int_array[0], len);
for (i = 0; i < len; i++)
{
temp = data[i];
@ -660,19 +626,13 @@ static void test_avltree_delete(void)
for (i = 0; i < len; i++)
{
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
buff[count++] = *iter;
// printf("(%2d ) ", *iter);
}
// printf("\n");
iter = tree->iter(tree, ORDER_LEFT_PRE);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_delete[i], buff, count);
temp = data[i];
// delete
TEST_ASSERT_TRUE(tree->delete(tree, &temp));
}
//
TEST_ASSERT_FALSE(tree->delete(tree, &temp));
tree_free(&tree);
@ -734,21 +694,15 @@ static const int rbt_expected_int_array_orderpre_delete[15][15] = {
static void test_rbtree_iter(void)
{
uint32_t i = 0;
// int data[] = { 2,1,3,4};
// int data[] = { 1,2,3,4,5,6};
// int data[] = { 5,2,3,1,7,8,6 };
// int data[] = { 5,2,3,1,7,8,6,4,9,10,12,11,15,14,13 };
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[15];
uint32_t len = sizeof(data) / sizeof(int);
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
int * iter = NULL;
int count = 0;
iterator_t iter = NULL;
tree_t tree = tree_rb_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
@ -757,51 +711,18 @@ static void test_rbtree_iter(void)
temp = data[i];
TEST_ASSERT_TRUE(tree->insert(tree, &temp));
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
buff[count++] = *iter;
}
iter = tree->iter(tree, ORDER_LEFT_PRE);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_insert[i], buff, count);
}
for(i = 1; i < 9; i++)
for(i = 0; i < 8; i++)
{
tree->set_order(tree, i); //ORDER_LEFT_IN
// printf("\n ----- iter test -----\n");
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
// printf("(%2d ) ", *iter);
buff[count++] = *iter;
}
// printf("\n");
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[i], buff, count);
iter = tree->iter(tree, order[i]);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[i + 1], buff, count);
}
#if 0
tree->order(tree, true);
printf("\n\nactual data = \n");
tree->postorder(tree, tree->_root);
printf("\n");
// set order
// tree->set_order(tree, ORDER_LEFT_PRE);
// tree->set_order(tree, ORDER_LEFT_IN);
// tree->set_order(tree, ORDER_LEFT_POST);
// tree->set_order(tree, ORDER_LEFT_BREADTH);
// tree->set_order(tree, ORDER_RIGHT_PRE);
// tree->set_order(tree, ORDER_RIGHT_IN);
tree->set_order(tree, ORDER_RIGHT_POST);
// tree->set_order(tree, ORDER_RIGHT_BREADTH);
printf("\n ----- iter data -----\n");
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
printf("(%2d ) ", *iter);
buff[count++] = *iter;
}
printf("\n");
TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[tree->_order], buff, count);
#endif
TEST_ASSERT_FALSE(tree->empty(tree));
TEST_ASSERT_TRUE(tree->clear(tree));
TEST_ASSERT_TRUE(tree->empty(tree));
@ -813,20 +734,15 @@ static void test_rbtree_iter(void)
static void test_rbtree_insert(void)
{
uint32_t i = 0;
// int data[] = { 2,1,3,4};
// int data[] = { 1,2,3,4,5,6};
// int data[] = { 5,2,3,1,7,8,6 };
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int buff[15];
uint32_t len = sizeof(data) / sizeof(int);
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
int * iter = NULL;
int count = 0;
iterator_t iter = NULL;
tree_t tree = tree_rb_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
@ -835,24 +751,16 @@ static void test_rbtree_insert(void)
temp = data[i];
TEST_ASSERT_TRUE(tree->insert(tree, &temp));
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
buff[count++] = *iter;
}
iter = tree->iter(tree, ORDER_LEFT_PRE);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_insert[i], buff, count);
}
for(i = 1; i < 9; i++)
for(i = 0; i < 8; i++)
{
tree->set_order(tree, i); //ORDER_LEFT_IN
// printf("\n ----- iter test -----\n");
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
// printf("(%2d ) ", *iter);
buff[count++] = *iter;
}
// printf("\n");
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[i], buff, count);
iter = tree->iter(tree, order[i]);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[i + 1], buff, count);
}
tree_free(&tree);
@ -863,16 +771,18 @@ static void test_rbtree_delete(void)
{
uint32_t i = 0;
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int temp = 0;
int buff[15];
uint32_t len = sizeof(data) / sizeof(data[0]);
int * iter = NULL;
int temp = 0;
int count = 0;
iterator_t iter = NULL;
enum _order order[8] = {
ORDER_LEFT_PRE, ORDER_LEFT_IN, ORDER_LEFT_POST, ORDER_LEFT_BREADTH,
ORDER_RIGHT_PRE, ORDER_RIGHT_IN, ORDER_RIGHT_POST, ORDER_RIGHT_BREADTH
};
tree_t tree = tree_rb_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
@ -884,142 +794,19 @@ static void test_rbtree_delete(void)
for (i = 0; i < len; i++)
{
for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
{
buff[count++] = *iter;
// printf("(%2d ) ", *iter);
}
// printf("\n");
iter = tree->iter(tree, ORDER_LEFT_PRE);
count = iter2array_num(iter, buff);
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_delete[i], buff, count);
temp = data[i];
// delete
TEST_ASSERT_TRUE(tree->delete(tree, &temp));
}
//
TEST_ASSERT_FALSE(tree->delete(tree, &temp));
tree_free(&tree);
TEST_ASSERT_NULL(tree);
}
static void test_avltree_iter_2(void)
{
uint32_t i = 0;
int data[15] = { 5, 2, 3, 1, 7, 8, 6, 4, 9, 10, 12, 11, 15, 14, 13, };
int buff[32];
int temp = 0;
uint32_t len = sizeof(data) / sizeof(data[0]);
int count = 0;
tree_t tree = tree_avl_new(sizeof(int));
TEST_ASSERT_NOT_NULL(tree);
tree->print_obj = print_num;
tree->compare = compare_num;
for (i = 0; i < len; i++)
{
temp = data[i];
TEST_ASSERT_TRUE(tree->insert(tree, &temp));
}
iterator_t iter = tree->iter(tree, ORDER_LEFT_PRE);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[1], buff, count);
iter = tree->iter(tree, ORDER_LEFT_IN);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[2], buff, count);
iter = tree->iter(tree, ORDER_LEFT_POST);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[3], buff, count);
iter = tree->iter(tree, ORDER_LEFT_BREADTH);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[4], buff, count);
iter = tree->iter(tree, ORDER_RIGHT_PRE);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[5], buff, count);
iter = tree->iter(tree, ORDER_RIGHT_IN);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[6], buff, count);
iter = tree->iter(tree, ORDER_RIGHT_POST);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[7], buff, count);
iter = tree->iter(tree, ORDER_RIGHT_BREADTH);
count = 0;
while(iter->hasnext(iter))
{
temp = *(int *)iter->next(iter);
// tree->print_obj(&temp);
buff[count++] = temp;
}
TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array[8], buff, count);
TEST_ASSERT_TRUE(tree->clear(tree));
tree_free(&tree);
TEST_ASSERT_NULL(tree);
}
void test_tree(void)
{
UnitySetTestFile(__FILE__);
@ -1035,6 +822,4 @@ void test_tree(void)
// RUN_TEST(test_avltree_num);
// RUN_TEST(test_rbtree_num);
// RUN_TEST(test_rbtree_struct);
RUN_TEST(test_avltree_iter_2);
}