将插入和删除测试独立出来

README.md

@@ -1,35 +1,35 @@
 # unicstl
 
-## 简介
+## 简介
-全称: Universal C standard library
+全称: Universal C standard library
 
-基于C语言实现的通用C库。包含常用数据结构和算法
+基于C语言实现的通用C库。包含常用数据结构和算法
 
-> 标准：--std=c99
+> 标准：--std=c99
 
-[数据结构详细说明](http://wenjianfeng.top)
+[数据结构详细说明](http://wenjianfeng.top)
 
-## 数据结构
+## 数据结构
-|数据结构 | 原理 |说明 |
+|数据结构 | 原理 |说明 |
 |---|---|---|
-| **stack**   | | **栈** |
+| **stack**   | | **栈** |
-| stack_init  | 链表 | |
+| stack_init  | 链表 | |
-| stack_init2 | 动态数组 | |
+| stack_init2 | 动态数组 | |
-| **list**   | | **列表**
+| **list**   | | **列表**
-| list_init2  | 动态数组 | |
+| list_init2  | 动态数组 | |
-| **queue**   | | **队列**
+| **queue**   | | **队列**
-| queue_init  | 单向链表 | |
+| queue_init  | 单向链表 | |
-| queue_init2 | 数组 | FIFO/空/满 |
+| queue_init2 | 数组 | FIFO/空/满 |
-| **deque**   | |**双端队列** |
+| **deque**   | |**双端队列** |
-| deque_init  | 双向循环链表 | |
+| deque_init  | 双向循环链表 | |
-| **tree**    | |**树** |
+| **tree**    | |**树** |
-| tree_avl_init | 二叉搜索树 | AVL树 |
+| tree_avl_init | 二叉搜索树 | AVL树 |
-| tree_rb_init  | 二叉搜索树 | 红黑树 |
+| tree_rb_init  | 二叉搜索树 | 红黑树 |
-| **heap**    | |**堆** |
+| **heap**    | |**堆** |
-| heap_init2   | 数组 | 最大堆/最小堆 |
+| heap_init2   | 数组 | 最大堆/最小堆 |
 
 
-## 版本
+## 版本
-| 版本 | 说明 |
+| 版本 | 说明 |
 |:----:|:----:|
-| 0.xx.xx  | 测试版本 |
+| 0.xx.xx  | 测试版本 |

src/tree.c

@@ -1482,10 +1482,14 @@ void* tree_begin(struct _tree* self)
     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)
@@ -1503,6 +1507,28 @@ void* tree_begin(struct _tree* self)
                     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;
@@ -1510,10 +1536,14 @@ void* tree_begin(struct _tree* self)
         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)
@@ -1530,6 +1560,26 @@ void* tree_begin(struct _tree* self)
                     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;
@@ -1537,10 +1587,15 @@ void* tree_begin(struct _tree* self)
         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();
         stack_init(stack, sizeof(struct _tree_node*));
+        if (self->_order == ORDER_LEFT_POST)
+        {
             while (!stack->empty(stack) || node != NULL)
             {
                 if (node != NULL)
@@ -1556,6 +1611,25 @@ void* tree_begin(struct _tree* self)
                     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))
@@ -1569,24 +1643,48 @@ void* tree_begin(struct _tree* self)
         return self->cur_node == NULL ? NULL : self->cur_node->obj;
     }break;
     case ORDER_LEFT_BREADTH:
-    {
-
-    }break;
-    case ORDER_RIGHT_PRE:
-    {
-
-    }break;
-    case ORDER_RIGHT_IN:
-    {
-
-    }break;
-    case ORDER_RIGHT_POST:
-    {
-
-    }break;
     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:
     {
@@ -1600,8 +1698,11 @@ void* tree_next(struct _tree* self)
     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)
@@ -1619,6 +1720,28 @@ void* tree_next(struct _tree* self)
                     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;
@@ -1626,8 +1749,11 @@ void* tree_next(struct _tree* self)
         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)
@@ -1638,12 +1764,32 @@ void* tree_next(struct _tree* self)
                 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);
+
+                    node = self->cur_node;
+                    self->cur_node = self->cur_node->left;
+                    break;
+                }
+            }
+        }
         if (node == NULL)
         {
             return NULL;
@@ -1651,6 +1797,7 @@ void* tree_next(struct _tree* self)
         return node->obj;
     }break;
     case ORDER_LEFT_POST:
+    case ORDER_RIGHT_POST:
     {
         if (!self->stack->empty(self->stack))
         {
@@ -1663,24 +1810,42 @@ void* tree_next(struct _tree* self)
         return self->cur_node == NULL ? NULL : self->cur_node->obj;
     }break;
     case ORDER_LEFT_BREADTH:
-    {
-
-    }break;
-    case ORDER_RIGHT_PRE:
-    {
-
-    }break;
-    case ORDER_RIGHT_IN:
-    {
-
-    }break;
-    case ORDER_RIGHT_POST:
-    {
-
-    }break;
     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:
     {

test/test_tree.c

@@ -545,7 +545,7 @@ static void test_tree_iter(void)
         TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_insert[i], buff, count);
     }
 
-    for(i = 1; i < 3; i++)
+    for(i = 1; i < 9; i++)
     {
         tree->set_order(tree, i);  //ORDER_LEFT_IN
         // printf("\n ----- iter test -----\n");
@@ -558,6 +558,8 @@ static void test_tree_iter(void)
         TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[i], buff, count);
     }
 
+#if 0
+    tree->order(tree, true);
     printf("\n\nactual data = \n");
     tree->postorder(tree, tree->_root);
     printf("\n");
@@ -565,7 +567,12 @@ static void test_tree_iter(void)
     // 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_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))
     {
@@ -573,7 +580,8 @@ static void test_tree_iter(void)
         buff[count++] = *iter;
     }
     printf("\n");
-    TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array[3], buff, count);
+    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));
@@ -583,11 +591,111 @@ static void test_tree_iter(void)
     TEST_ASSERT_NULL(tree);
 }
 
+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 temp = 0;
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+
+    int * iter = NULL;
+    int count = 0;
+
+    tree_t tree = tree_new();
+    TEST_ASSERT_NOT_NULL(tree);
+
+    tree_avl_init(tree, sizeof(int));
+    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));
+
+        for (count = 0, iter = tree->begin(tree); iter != tree->end(tree); iter = tree->next(tree))
+        {
+            buff[count++] = *iter;
+        }
+        TEST_ASSERT_EQUAL_INT_ARRAY(expected_int_array_orderpre_insert[i], buff, count);
+    }
+
+    for(i = 1; i < 9; 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);
+    }
+    
+    tree_free(&tree);
+    TEST_ASSERT_NULL(tree);
+}
+
+
+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 temp = 0;
+    uint32_t len = sizeof(data) / sizeof(data[0]);
+
+    int * iter = NULL;
+    int count = 0;
+
+    tree_t tree = tree_new();
+    TEST_ASSERT_NOT_NULL(tree);
+
+    tree_avl_init(tree, sizeof(int));
+    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));
+    }
+
+    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");
+        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);
+    TEST_ASSERT_NULL(tree);
+}
+
+
 void test_tree(void)
 {
+    RUN_TEST(test_tree_iter);
+
+    RUN_TEST(test_avltree_insert);
+    RUN_TEST(test_avltree_delete);
+
     // RUN_TEST(test_avltree_num);
     // RUN_TEST(test_rbtree_num);
     // RUN_TEST(test_rbtree_struct);
-
-    RUN_TEST(test_tree_iter);
 }