添加map的比较函数

.vscode/settings.json

@@ -30,6 +30,7 @@
         "assert.h": "c",
         "limits.h": "c",
         "cstdint": "c",
-        "unicstl_internal.h": "c"
+        "unicstl_internal.h": "c",
+        "map.h": "c"
     }
 }

demo/demo_tree.c

@@ -55,7 +55,7 @@ void demo_avltree_num(void)
         tree->print_obj(&temp);
         printf("size = %2d : ", tree->size(tree));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(int *)iter->next(iter);
@@ -88,7 +88,7 @@ void demo_avltree_num(void)
     }
 
     printf("----- preorder -----\n");
-    iter = tree->iter(tree, ORDER_PRE);
+    iter = tree->iter(tree, TREE_DFS_PRE);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -97,7 +97,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- inorder -----\n");
-    iter = tree->iter(tree, ORDER_IN);
+    iter = tree->iter(tree, TREE_DFS_IN);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -106,7 +106,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- postorder -----\n");
-    iter = tree->iter(tree, ORDER_POST);
+    iter = tree->iter(tree, TREE_DFS_POST);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -115,7 +115,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- breadth -----\n");
-    iter = tree->iter(tree, ORDER_BREADTH);
+    iter = tree->iter(tree, TREE_BFS);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -124,7 +124,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- preorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_PRE_R);
+    iter = tree->iter(tree, TREE_DFS_PRE_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -133,7 +133,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- inorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_IN_R);
+    iter = tree->iter(tree, TREE_DFS_IN_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -142,7 +142,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- postorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_POST_R);
+    iter = tree->iter(tree, TREE_DFS_POST_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -151,7 +151,7 @@ void demo_avltree_num(void)
     printf("\n");
 
     printf("----- breadth(right) -----\n");
-    iter = tree->iter(tree, ORDER_BREADTH_R);
+    iter = tree->iter(tree, TREE_BFS_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -161,7 +161,7 @@ void demo_avltree_num(void)
 
 
     printf("----- preorder(left) -----\n");
-    iter = tree->iter(tree, ORDER_PRE);
+    iter = tree->iter(tree, TREE_DFS_PRE);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -179,7 +179,7 @@ void demo_avltree_num(void)
         tree->print_obj(&temp);
         printf("size = %2d : ", tree->size(tree));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(int *)iter->next(iter);
@@ -279,7 +279,7 @@ void demo_rbtree_num(void)
         tree->print_obj(&temp);
         printf("size = %2d : ", tree->size(tree));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(int *)iter->next(iter);
@@ -318,7 +318,7 @@ void demo_rbtree_num(void)
     }
 
     printf("----- preorder -----\n");
-    iter = tree->iter(tree, ORDER_PRE);
+    iter = tree->iter(tree, TREE_DFS_PRE);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -327,7 +327,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- inorder -----\n");
-    iter = tree->iter(tree, ORDER_IN);
+    iter = tree->iter(tree, TREE_DFS_IN);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -336,7 +336,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- postorder -----\n");
-    iter = tree->iter(tree, ORDER_POST);
+    iter = tree->iter(tree, TREE_DFS_POST);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -345,7 +345,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- breadth -----\n");
-    iter = tree->iter(tree, ORDER_BREADTH);
+    iter = tree->iter(tree, TREE_BFS);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -354,7 +354,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- preorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_PRE_R);
+    iter = tree->iter(tree, TREE_DFS_PRE_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -363,7 +363,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- inorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_IN_R);
+    iter = tree->iter(tree, TREE_DFS_IN_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -372,7 +372,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- postorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_POST_R);
+    iter = tree->iter(tree, TREE_DFS_POST_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -381,7 +381,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- breadth(right) -----\n");
-    iter = tree->iter(tree, ORDER_BREADTH_R);
+    iter = tree->iter(tree, TREE_BFS_R);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -390,7 +390,7 @@ void demo_rbtree_num(void)
     printf("\n");
 
     printf("----- preorder -----\n");
-    iter = tree->iter(tree, ORDER_PRE);
+    iter = tree->iter(tree, TREE_DFS_PRE);
     while(iter->hasnext(iter))
     {
         temp = *(int *)iter->next(iter);
@@ -409,7 +409,7 @@ void demo_rbtree_num(void)
 
         printf("size = %2d : ", tree->size(tree));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(int *)iter->next(iter);
@@ -461,7 +461,7 @@ void demo_rbtree_struct(void)
         tree->print_obj(&temp);
         printf("size = %2d : ", tree->size(tree));
         
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(struct _student *)iter->next(iter);
@@ -500,7 +500,7 @@ void demo_rbtree_struct(void)
     }
 
     printf("----- preorder -----\n");
-    iter = tree->iter(tree, ORDER_PRE);
+    iter = tree->iter(tree, TREE_DFS_PRE);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -509,7 +509,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- inorder -----\n");
-    iter = tree->iter(tree, ORDER_IN);
+    iter = tree->iter(tree, TREE_DFS_IN);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -518,7 +518,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- postorder -----\n");
-    iter = tree->iter(tree, ORDER_POST);
+    iter = tree->iter(tree, TREE_DFS_POST);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -527,7 +527,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- breadth -----\n");
-    iter = tree->iter(tree, ORDER_BREADTH);
+    iter = tree->iter(tree, TREE_BFS);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -536,7 +536,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- preorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_PRE_R);
+    iter = tree->iter(tree, TREE_DFS_PRE_R);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -545,7 +545,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- inorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_IN_R);
+    iter = tree->iter(tree, TREE_DFS_IN_R);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -554,7 +554,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- postorder(right) -----\n");
-    iter = tree->iter(tree, ORDER_POST_R);
+    iter = tree->iter(tree, TREE_DFS_POST_R);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -563,7 +563,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- breadth(right) -----\n");
-    iter = tree->iter(tree, ORDER_BREADTH_R);
+    iter = tree->iter(tree, TREE_BFS_R);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -572,7 +572,7 @@ void demo_rbtree_struct(void)
     printf("\n");
 
     printf("----- preorder -----\n");
-    iter = tree->iter(tree, ORDER_PRE);
+    iter = tree->iter(tree, TREE_DFS_PRE);
     while(iter->hasnext(iter))
     {
         temp = *(struct _student *)iter->next(iter);
@@ -591,7 +591,7 @@ void demo_rbtree_struct(void)
 
         printf("size = %2d : ", tree->size(tree));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(struct _student *)iter->next(iter);

include/map.h

@@ -18,17 +18,16 @@ struct _map_node
 {
     char* key;
     void* value;
+    size_t key_sz;
+    size_t value_sz;
 };
+typedef struct _map_node * map_node_t;
 
 struct _map
 {
     // -------------------- private -------------------- 
     tree_t _tree;
-
-    // uint32_t _size;
     uint32_t _obj_size;
-    // uint32_t _capacity;
-    // uint32_t _ratio;
 
     // -------------------- public -------------------- 
     // kernel
@@ -46,9 +45,6 @@ struct _map
     // iter
     iterator_t(*iter)(struct _map* self, enum _tree_order);
 
-    // config 
-    compare_fun_t compare;  // !!! you have to implement this function
-
     // -------------------- debug -------------------- 
     void (*print_obj)(void* obj);
 };

include/tree.h

@@ -16,23 +16,22 @@
 #include "stack.h"
 #include "queue.h"
 
-
-typedef enum {
+typedef enum _rbt_color{
     RBT_RED,
     RBT_BLACK,
 }rbt_color;
 
 // dfs and bfs traversal order
 enum _tree_order{
-    ORDER_PRE,      // pre-order
-    ORDER_IN,       // in-order
-    ORDER_POST,     // post-order
-    ORDER_BREADTH,  // breadth-first search [BFS]
+    TREE_DFS_PRE,       // pre-order
+    TREE_DFS_IN,        // in-order
+    TREE_DFS_POST,      // post-order
+    TREE_BFS,           // breadth-first search [BFS]
 
-    ORDER_PRE_R,    // right-first pre-order
-    ORDER_IN_R,     // right-first in-order
-    ORDER_POST_R,   // right-first post-order
-    ORDER_BREADTH_R,// right-first breadth-first search [BFS]
+    TREE_DFS_PRE_R,     // right-first pre-order
+    TREE_DFS_IN_R,      // right-first in-order
+    TREE_DFS_POST_R,    // right-first post-order
+    TREE_BFS_R,         // right-first breadth-first search [BFS]
 };
 
 struct _tree_node
@@ -45,7 +44,7 @@ struct _tree_node
     union 
     {
         int32_t balance;
-        uint32_t color;
+        rbt_color color;
     };
 };
 

src/map.c

@@ -17,24 +17,22 @@ struct _map_node* map_node_new(struct _map *self, const char* key, void* value)
     {
         return NULL;
     }
-    uint32_t keylen = strlen(key) + 1;
-    node->key = (char*)malloc(sizeof(char) * keylen);
+
+    // Allocating memory for key and value only once can improve performance.
+    node->key_sz = strlen(key) + 1;
+    node->value_sz = self->_obj_size;
+    node->key = (char*)malloc(node->key_sz + node->value_sz);
     if (!node->key)
     {
         free(node);
         return NULL;
     }
+    node->value = node->key + node->key_sz;
 
-    node->value = malloc(self->_obj_size);
-    if (!node->value)
-    {
-        free(node->key);
-        free(node);
-        return NULL;
-    }
-    
-    memcpy(node->key, key, keylen);
-    memcpy(node->value, value, self->_obj_size);
+    // copy
+    memcpy(node->key, key, node->key_sz);
+    node->key[node->key_sz] = '\0';
+    memcpy(node->value, value, node->value_sz);
     return node;
 }
 
@@ -46,29 +44,11 @@ static void map_node_free(struct _map_node** node)
         {
             free((*node)->key);
         }
-        if ((*node)->value != NULL)
-        {
-            free((*node)->value);
-        }
         free(*node);
         *node = NULL;
     }
 }
 
-bool map_clear(struct _map* self)
-{
-    struct _map_node* node = NULL;
-    iterator_t iter = self->_tree->iter(self->_tree, ORDER_IN);
-    while(iter->hasnext(&iter))
-    {
-        // tree & map malloc memory independently, so free them one by one.
-        node = (struct _map_node*)iter->next(&iter);
-        map_node_free(&node);
-    }
-
-    return self->_tree->clear(self->_tree);
-}
-
 bool map_empty(struct _map* self)
 {
     return self->_tree->empty(self->_tree);
@@ -79,6 +59,20 @@ uint32_t map_size(struct _map* self)
     return self->_tree->size(self->_tree);
 }
 
+bool map_clear(struct _map* self)
+{
+    struct _map_node* node = NULL;
+    iterator_t iter = self->_tree->iter(self->_tree, TREE_DFS_IN);
+    while(iter->hasnext(iter))
+    {
+        // tree & map malloc memory independently, so free them one by one.
+        node = (struct _map_node*)iter->next(iter);
+        map_node_free(&node);
+    }
+
+    return self->_tree->clear(self->_tree);
+}
+
 bool map_insert(struct _map* self, const char* key, void* value)
 {
     struct _map_node* node = NULL;
@@ -92,8 +86,8 @@ bool map_insert(struct _map* self, const char* key, void* value)
 
 bool map_delete(struct _map* self, const char* key, void* value)
 {
-    struct _map_node node = {.key = key, .value = value};
-    return self->_tree->delete(self->_tree, &node);
+    // struct _map_node node = {.key = key, .value = value};
+    // return self->_tree->delete(self->_tree, &node);
 }
 
 void map_contains(struct _map* self, const char* key)
@@ -113,6 +107,15 @@ bool map_set(struct _map* self, const char* key, void* value)
     return false;
 }
 
+static int map_compare(void* obj1, void* obj2)
+{
+    assert(obj1 != NULL && obj2 != NULL);
+
+    map_node_t node1 = (map_node_t)obj1;
+    map_node_t node2 = (map_node_t)obj2;
+    return strcmp(node1->key, node2->key);
+}
+
 bool map_init(struct _map* self, uint32_t obj_size)
 {
     assert(self != NULL);
@@ -129,6 +132,7 @@ bool map_init(struct _map* self, uint32_t obj_size)
     {
         return false;
     }
+    self->_tree->compare = map_compare;
 
     // -------------------- public --------------------
     // kernel
@@ -145,9 +149,8 @@ bool map_init(struct _map* self, uint32_t obj_size)
     self->size = map_size;
 
     // -------------------- default --------------------
-    self->compare = default_compare;
+    // self->compare = default_compare;
     self->print_obj = default_print_obj;
-    self->_tree->compare = self->compare;
 
     return true;
 }
@@ -157,7 +160,7 @@ bool map_destory(struct _map* self)
     self->clear(self);
     if(self->_tree != NULL)
     {
-        tree_rb_free(self->_tree);
+        tree_free(&self->_tree);
         self->_tree = NULL;
     }
     return true;

src/tree.c

@@ -12,8 +12,7 @@
 #include "queue.h"
 #include "stack.h"
 
-// #define TREE_RECURSIVE_ENABLED 
-
+// #define TREE_RECURSIVE_ENABLED
 static struct _tree_node* tree_node_new(struct _tree* self, void* obj)
 {
     assert(self != NULL);
@@ -1151,11 +1150,11 @@ static const void* tree_iter_next(struct _iterator* iter)
     struct _tree_node* target_node = NULL;
     switch (iter->_order)
     {
-    case ORDER_PRE:
-    case ORDER_PRE_R:
+    case TREE_DFS_PRE:
+    case TREE_DFS_PRE_R:
     {
         struct _tree_node* node = NULL;
-        if (iter->_order == ORDER_PRE)
+        if (iter->_order == TREE_DFS_PRE)
         {
             while (!self->stack->empty(self->stack) || cur_node != NULL)
             {
@@ -1194,10 +1193,10 @@ static const void* tree_iter_next(struct _iterator* iter)
             }
         }
     }break;
-    case ORDER_IN:
-    case ORDER_IN_R:
+    case TREE_DFS_IN:
+    case TREE_DFS_IN_R:
     {
-        if (iter->_order == ORDER_IN)
+        if (iter->_order == TREE_DFS_IN)
         {
             while (!self->stack->empty(self->stack) || cur_node != NULL)
             {
@@ -1236,8 +1235,8 @@ static const void* tree_iter_next(struct _iterator* iter)
             }
         }
     }break;
-    case ORDER_POST:
-    case ORDER_POST_R:
+    case TREE_DFS_POST:
+    case TREE_DFS_POST_R:
     {
         if (!self->stack->empty(self->stack))
         {
@@ -1245,8 +1244,8 @@ static const void* tree_iter_next(struct _iterator* iter)
             target_node = cur_node;
         }
     }break;
-    case ORDER_BREADTH:
-    case ORDER_BREADTH_R:
+    case TREE_BFS:
+    case TREE_BFS_R:
     {
         queue_t queue = self->queue;
         if (!queue->empty(queue) && cur_node != NULL)
@@ -1254,7 +1253,7 @@ static const void* tree_iter_next(struct _iterator* iter)
             queue->pop(queue, &cur_node);
             target_node = cur_node;
 
-            if (iter->_order == ORDER_BREADTH)
+            if (iter->_order == TREE_BFS)
             {
                 if (cur_node->left != NULL)
                 {
@@ -1307,24 +1306,24 @@ static iterator_t tree_iter(struct _tree* self, enum _tree_order order)
 
     switch (iter->_order)
     {
-    case ORDER_PRE:
-    case ORDER_PRE_R:
+    case TREE_DFS_PRE:
+    case TREE_DFS_PRE_R:
     {
         // pass
     }break;
-    case ORDER_IN:
-    case ORDER_IN_R:
+    case TREE_DFS_IN:
+    case TREE_DFS_IN_R:
     {
         // pass
     }break;
-    case ORDER_POST:
-    case ORDER_POST_R:
+    case TREE_DFS_POST:
+    case TREE_DFS_POST_R:
     {
         struct _tree_node* node = self->_root;
         self->stack->clear(self->stack);
 
         stack_t stack = stack_new(sizeof(struct _tree_node*));
-        if (iter->_order == ORDER_POST)
+        if (iter->_order == TREE_DFS_POST)
         {
             while (!stack->empty(stack) || node != NULL)
             {
@@ -1362,8 +1361,8 @@ static iterator_t tree_iter(struct _tree* self, enum _tree_order order)
         }
         stack_free(&stack);
     }break;
-    case ORDER_BREADTH:
-    case ORDER_BREADTH_R:
+    case TREE_BFS:
+    case TREE_BFS_R:
     {
         // pass
         self->queue->push(self->queue, &self->_root);

test/test_tree.c

@@ -68,8 +68,8 @@ static const int expected_int_array_orderpre_delete[15][15] = {
 };
 
 static const enum _tree_order order[8] = { 
-    ORDER_PRE, ORDER_IN, ORDER_POST, ORDER_BREADTH,
-    ORDER_PRE_R, ORDER_IN_R, ORDER_POST_R, ORDER_BREADTH_R
+    TREE_DFS_PRE, TREE_DFS_IN, TREE_DFS_POST, TREE_BFS,
+    TREE_DFS_PRE_R, TREE_DFS_IN_R, TREE_DFS_POST_R, TREE_BFS_R
 };
 
 static uint32_t iter2array_num(iterator_t iter, int *data)
@@ -104,7 +104,7 @@ static void test_avltree_iter(void)
         temp = data[i];
         TEST_ASSERT_TRUE(tree->insert(tree, &temp));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_insert[i], buff, count);
     }
@@ -145,7 +145,7 @@ static void test_avltree_insert(void)
         temp = data[i];
         TEST_ASSERT_TRUE(tree->insert(tree, &temp));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_insert[i], buff, count);
     }
@@ -185,7 +185,7 @@ static void test_avltree_delete(void)
 
     for (i = 0; i < len; i++)
     {
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_delete[i], buff, count);
 
@@ -270,7 +270,7 @@ static void test_rbtree_iter(void)
         temp = data[i];
         TEST_ASSERT_TRUE(tree->insert(tree, &temp));
         
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_insert[i], buff, count);
     }
@@ -310,7 +310,7 @@ static void test_rbtree_insert(void)
         temp = data[i];
         TEST_ASSERT_TRUE(tree->insert(tree, &temp));
 
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_insert[i], buff, count);
     }
@@ -349,7 +349,7 @@ static void test_rbtree_delete(void)
 
     for (i = 0; i < len; i++)
     {
-        iter = tree->iter(tree, ORDER_PRE);
+        iter = tree->iter(tree, TREE_DFS_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_delete[i], buff, count);