diff --git a/demo/demo_tree.c b/demo/demo_tree.c
index 58cd3dc..79822e4 100644
--- a/demo/demo_tree.c
+++ b/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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+    iter = tree->iter(tree, ORDER_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_LEFT_IN);
+    iter = tree->iter(tree, ORDER_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_LEFT_POST);
+    iter = tree->iter(tree, ORDER_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_LEFT_BREADTH);
+    iter = tree->iter(tree, ORDER_BREADTH);
     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_RIGHT_PRE);
+    iter = tree->iter(tree, ORDER_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_RIGHT_IN);
+    iter = tree->iter(tree, ORDER_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_RIGHT_POST);
+    iter = tree->iter(tree, ORDER_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_RIGHT_BREADTH);
+    iter = tree->iter(tree, ORDER_BREADTH_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_LEFT_PRE);
+    iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+    iter = tree->iter(tree, ORDER_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_LEFT_IN);
+    iter = tree->iter(tree, ORDER_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_LEFT_POST);
+    iter = tree->iter(tree, ORDER_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_LEFT_BREADTH);
+    iter = tree->iter(tree, ORDER_BREADTH);
     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_RIGHT_PRE);
+    iter = tree->iter(tree, ORDER_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_RIGHT_IN);
+    iter = tree->iter(tree, ORDER_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_RIGHT_POST);
+    iter = tree->iter(tree, ORDER_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_RIGHT_BREADTH);
+    iter = tree->iter(tree, ORDER_BREADTH_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_LEFT_PRE);
+    iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+    iter = tree->iter(tree, ORDER_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_LEFT_IN);
+    iter = tree->iter(tree, ORDER_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_LEFT_POST);
+    iter = tree->iter(tree, ORDER_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_LEFT_BREADTH);
+    iter = tree->iter(tree, ORDER_BREADTH);
     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_RIGHT_PRE);
+    iter = tree->iter(tree, ORDER_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_RIGHT_IN);
+    iter = tree->iter(tree, ORDER_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_RIGHT_POST);
+    iter = tree->iter(tree, ORDER_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_RIGHT_BREADTH);
+    iter = tree->iter(tree, ORDER_BREADTH_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_LEFT_PRE);
+    iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_PRE);
         while(iter->hasnext(iter))
         {
             temp = *(struct _student *)iter->next(iter);
diff --git a/include/tree.h b/include/tree.h
index 6237402..c0f1c52 100644
--- a/include/tree.h
+++ b/include/tree.h
@@ -18,25 +18,33 @@
 
 
 typedef enum {
-    RBT_RED = 0x00,
-    RBT_BLACK = 0x01,
+    RBT_RED,
+    RBT_BLACK,
 }rbt_color;
 
+/**
+ * @brief dfs amd bfs traversal order
+ * 
+ *  pre-order traversal
+ *   in-order traversal
+ *  post-order traversal
+ *  breadth-first search traversal [BFS]
+ * 
+ *  right-first pre-order traversal
+ *  right-first in-order traversal
+ *  right-first post-order traversal
+ *  breadth-first search traversal [BFS]
+ */
 enum _order{
-    ORDER_LEFT_PRE = 0x01,
-    ORDER_LEFT_IN = 0x02,
-    ORDER_LEFT_POST = 0x03,
-    ORDER_LEFT_BREADTH = 0x04,
+    ORDER_PRE,
+    ORDER_IN,
+    ORDER_POST,
+    ORDER_BREADTH,
 
-    ORDER_RIGHT_PRE = 0x05,
-    ORDER_RIGHT_IN = 0x06,
-    ORDER_RIGHT_POST = 0x07,
-    ORDER_RIGHT_BREADTH = 0x08,
-
-    ORDER_PRE = ORDER_LEFT_PRE,
-    ORDER_IN = ORDER_LEFT_IN,
-    ORDER_POST = ORDER_LEFT_POST,
-    ORDER_BREADTH = ORDER_LEFT_BREADTH,
+    ORDER_PRE_R,
+    ORDER_IN_R,
+    ORDER_POST_R,
+    ORDER_BREADTH_R,
 };
 
 struct _tree_node
diff --git a/src/tree.c b/src/tree.c
index 719310b..a1f0431 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -1165,24 +1165,24 @@ static iterator_t tree_iter(struct _tree* self, enum _order order)
 
     switch (self->_order)
     {
-    case ORDER_LEFT_PRE:
-    case ORDER_RIGHT_PRE:
+    case ORDER_PRE:
+    case ORDER_PRE_R:
     {
         // pass
     }break;
-    case ORDER_LEFT_IN:
-    case ORDER_RIGHT_IN:
+    case ORDER_IN:
+    case ORDER_IN_R:
     {
         // pass
     }break;
-    case ORDER_LEFT_POST:
-    case ORDER_RIGHT_POST:
+    case ORDER_POST:
+    case ORDER_POST_R:
     {
         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)
+        if (self->_order == ORDER_POST)
         {
             while (!stack->empty(stack) || node != NULL)
             {
@@ -1220,8 +1220,8 @@ static iterator_t tree_iter(struct _tree* self, enum _order order)
         }
         stack_free(&stack);
     }break;
-    case ORDER_LEFT_BREADTH:
-    case ORDER_RIGHT_BREADTH:
+    case ORDER_BREADTH:
+    case ORDER_BREADTH_R:
     {
         // pass
         self->queue->push(self->queue, &self->_root);
@@ -1260,11 +1260,11 @@ static const void* tree_iter_next(struct _iterator* iter)
     struct _tree_node* cur_node = self->_iter._cur_node;
     switch (self->_order)
     {
-    case ORDER_LEFT_PRE:
-    case ORDER_RIGHT_PRE:
+    case ORDER_PRE:
+    case ORDER_PRE_R:
     {
         struct _tree_node* node = NULL;
-        if (self->_order == ORDER_LEFT_PRE)
+        if (self->_order == ORDER_PRE)
         {
             while (!self->stack->empty(self->stack) || cur_node != NULL)
             {
@@ -1313,11 +1313,11 @@ static const void* tree_iter_next(struct _iterator* iter)
         self->_iter._cur_node = cur_node;
         obj = node->obj;
     }break;
-    case ORDER_LEFT_IN:
-    case ORDER_RIGHT_IN:
+    case ORDER_IN:
+    case ORDER_IN_R:
     {
         struct _tree_node* node = NULL;
-        if (self->_order == ORDER_LEFT_IN)
+        if (self->_order == ORDER_IN)
         {
             while (!self->stack->empty(self->stack) || cur_node != NULL)
             {
@@ -1363,8 +1363,8 @@ static const void* tree_iter_next(struct _iterator* iter)
         self->_iter._cur_node = cur_node;
         obj = node->obj;
     }break;
-    case ORDER_LEFT_POST:
-    case ORDER_RIGHT_POST:
+    case ORDER_POST:
+    case ORDER_POST_R:
     {
         if (!self->stack->empty(self->stack))
         {
@@ -1381,15 +1381,15 @@ static const void* tree_iter_next(struct _iterator* iter)
             obj = cur_node->obj;
         }
     }break;
-    case ORDER_LEFT_BREADTH:
-    case ORDER_RIGHT_BREADTH:
+    case ORDER_BREADTH:
+    case ORDER_BREADTH_R:
     {
         struct _tree_node* node = cur_node;
         queue_t queue = self->queue;
         if (!queue->empty(queue) && node != NULL)
         {
             queue->pop(queue, &node);
-            if (self->_order == ORDER_LEFT_BREADTH)
+            if (self->_order == ORDER_BREADTH)
             {
                 if (node->left != NULL)
                 {
diff --git a/test/test_tree.c b/test/test_tree.c
index 6177eea..25bebef 100644
--- a/test/test_tree.c
+++ b/test/test_tree.c
@@ -68,8 +68,8 @@ static const int expected_int_array_orderpre_delete[15][15] = {
 };
 
 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
+    ORDER_PRE, ORDER_IN, ORDER_POST, ORDER_BREADTH,
+    ORDER_PRE_R, ORDER_IN_R, ORDER_POST_R, ORDER_BREADTH_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_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_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_insert[i], buff, count);
     }
@@ -336,8 +336,8 @@ static void test_rbtree_delete(void)
     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
+        ORDER_PRE, ORDER_IN, ORDER_POST, ORDER_BREADTH,
+        ORDER_PRE_R, ORDER_IN_R, ORDER_POST_R, ORDER_BREADTH_R
     };
 
     tree_t tree = tree_rb_new(sizeof(int));
@@ -353,7 +353,7 @@ static void test_rbtree_delete(void)
 
     for (i = 0; i < len; i++)
     {
-        iter = tree->iter(tree, ORDER_LEFT_PRE);
+        iter = tree->iter(tree, ORDER_PRE);
         count = iter2array_num(iter, buff);
         TEST_ASSERT_EQUAL_INT_ARRAY(rbt_expected_int_array_orderpre_delete[i], buff, count);