diff --git a/README.md b/README.md
index ee29d9a..b1ad50b 100644
--- a/README.md
+++ b/README.md
@@ -13,8 +13,8 @@
 |数据结构 | 原理 |说明 |
 |---|---|---|
 | **stack**   | | **栈** |
-| stack_init  | 链表 | |
-| stack_init2 | 动态数组 | |
+| stack_new  | 链表 | |
+| stack_new2 | 动态数组 | |
 | **list**   | | **列表**
 | list_init2  | 动态数组 | |
 | **queue**   | | **队列**
diff --git a/demo/demo_stack.c b/demo/demo_stack.c
index 58823e7..3677948 100644
--- a/demo/demo_stack.c
+++ b/demo/demo_stack.c
@@ -17,8 +17,7 @@ static void demo_stack_num(void)
     int temp = 0;
     uint32_t len = sizeof(data) / sizeof(data[0]);
 
-    stack_t stack = stack_new();
-    stack_init(stack, sizeof(int));
+    stack_t stack = stack_new(sizeof(int));
     stack->print_obj = print_num;
 
     printf("\n\n----- demo_stack_num -----\n");
@@ -78,8 +77,7 @@ static void demo_stack_char(void)
     char temp = 0;
     uint32_t len = sizeof(data) / sizeof(data[0]) - 1;
 
-    stack_t stack = stack_new();
-    stack_init2(stack, sizeof(char), 64);
+    stack_t stack = stack_new2(sizeof(char), 64);
     stack->print_obj = print_char;
 
     printf("\n\n----- demo_stack_char -----\n");
@@ -141,8 +139,7 @@ static void demo_stack_struct(void)
     struct _student temp = { 0 };
     uint32_t len = sizeof(data) / sizeof(data[0]);
 
-    stack_t stack = stack_new();
-    stack_init(stack, sizeof(struct _student));
+    stack_t stack = stack_new(sizeof(struct _student));
     stack->print_obj = print_struct;
 
     printf("\n\n----- demo_stack_struct -----\n");
diff --git a/include/stack.h b/include/stack.h
index c3e5e5a..5e2edf2 100644
--- a/include/stack.h
+++ b/include/stack.h
@@ -48,10 +48,10 @@ struct _stack
 };
 typedef struct _stack* stack_t;
 
-bool stack_init(struct _stack* self, uint32_t obj_size);
-bool stack_init2(struct _stack* self, uint32_t obj_size, uint32_t capacity);
+// create and free stack
+stack_t stack_new(uint32_t obj_size);
+stack_t stack_new2(uint32_t obj_size, uint32_t capacity);
 
-stack_t stack_new(void);
 void stack_free(stack_t* stack);
 
 #endif // _STACK_H_
diff --git a/src/stack.c b/src/stack.c
index 00296bb..d695418 100644
--- a/src/stack.c
+++ b/src/stack.c
@@ -254,7 +254,7 @@ static void stack2_print(struct _stack* self)
 }
 
 
-bool stack_init(struct _stack* self, uint32_t obj_size)
+static bool stack_init(struct _stack* self, uint32_t obj_size)
 {
     assert(self != NULL);
     assert(obj_size != 0);
@@ -298,7 +298,7 @@ bool stack_init(struct _stack* self, uint32_t obj_size)
     return true;
 }
 
-bool stack_init2(struct _stack* self, uint32_t obj_size, uint32_t capacity)
+static bool stack_init2(struct _stack* self, uint32_t obj_size, uint32_t capacity)
 {
     assert(self != NULL);
 
@@ -343,9 +343,34 @@ bool stack_init2(struct _stack* self, uint32_t obj_size, uint32_t capacity)
     return true;
 }
 
-stack_t stack_new(void)
+stack_t stack_new(uint32_t obj_size)
 {
-    return (struct _stack*)calloc(1, sizeof(struct _stack));
+    stack_t stack = NULL;
+    stack = (struct _stack*)calloc(1, sizeof(struct _stack));
+    if (stack != NULL)
+    {
+        if(stack_init(stack, obj_size) != true)
+        {
+            free(stack);
+            stack = NULL;
+        }
+    }
+    return stack;
+}
+
+stack_t stack_new2(uint32_t obj_size, uint32_t capacity)
+{
+    stack_t stack = NULL;
+    stack = (struct _stack*)calloc(1, sizeof(struct _stack));
+    if (stack != NULL)
+    {
+        if(stack_init2(stack, obj_size, capacity) != true)
+        {
+            free(stack);
+            stack = NULL;
+        }
+    }
+    return stack;
 }
 
 void stack_free(stack_t *stack)
diff --git a/src/tree.c b/src/tree.c
index 11f0766..9251c2d 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -670,8 +670,7 @@ void tree_preorder(struct _tree* self, struct _tree_node* root)
     }
     struct _tree_node* node = root;
 
-    stack_t stack = stack_new();
-    stack_init(stack, sizeof(struct _tree_node*));
+    stack_t stack = stack_new(sizeof(struct _tree_node*));
 
     if (!self->_right_priority)          // left priority
     {
@@ -755,8 +754,7 @@ void tree_inorder(struct _tree* self, struct _tree_node* root)
 
     struct _tree_node* node = root;
 
-    stack_t stack = stack_new();
-    stack_init(stack, sizeof(struct _tree_node*));
+    stack_t stack = stack_new(sizeof(struct _tree_node*));
 
     if (!self->_right_priority)         // left priority
     {
@@ -839,12 +837,10 @@ void tree_postorder(struct _tree* self, struct _tree_node* root)
     }
     struct _tree_node* node = root;
 
-    stack_t stack2 = stack_new();
-    stack_init(stack2, sizeof(struct _tree_node*));
+    stack_t stack2 = stack_new(sizeof(struct _tree_node*));
 
     // because: left:postorder == right:the reverse of preorder 
-    stack_t stack = stack_new();
-    stack_init(stack, sizeof(struct _tree_node*));
+    stack_t stack = stack_new(sizeof(struct _tree_node*));
 
     if (!self->_right_priority)          // left priority
     {
@@ -1592,8 +1588,7 @@ void* tree_begin(struct _tree* self)
         struct _tree_node* node = self->_root;
         self->stack->clear(self->stack);
 
-        stack_t stack = stack_new();
-        stack_init(stack, sizeof(struct _tree_node*));
+        stack_t stack = stack_new(sizeof(struct _tree_node*));
         if (self->_order == ORDER_LEFT_POST)
         {
             while (!stack->empty(stack) || node != NULL)
@@ -1936,12 +1931,11 @@ bool tree_avl_init(struct _tree* self, uint32_t obj_size)
 
     self->_root = NULL;
 
-    self->stack = stack_new();
+    self->stack = stack_new(sizeof(struct _tree_node*));
     if (self->stack == NULL)
     {
         goto done;
     }
-    stack_init(self->stack, sizeof(struct _tree_node*));
     self->queue = queue_new();
     if (self->queue == NULL)
     {
@@ -1997,12 +1991,11 @@ bool tree_rb_init(struct _tree* self, uint32_t obj_size)
 
     self->_root = NULL;
 
-    self->stack = stack_new();
+    self->stack = stack_new(sizeof(struct _tree_node*));
     if (self->stack == NULL)
     {
         goto done;
     }
-    stack_init(self->stack, sizeof(struct _tree_node*));
     self->queue = queue_new();
     if (self->queue == NULL)
     {
diff --git a/test/test_stack.c b/test/test_stack.c
index 359ce76..98caa98 100644
--- a/test/test_stack.c
+++ b/test/test_stack.c
@@ -11,59 +11,24 @@
 #include "test.h"
 
 
-static void test_stack_init(void)
-{
-    struct _stack stack;
-
-    // ------------------------------
-#ifdef NDEBUG
-    TEST_ASSERT_FALSE(stack_init(NULL, sizeof(int)));
-    TEST_ASSERT_FALSE(stack_init(&stack, 0));
-#endif
-    TEST_ASSERT_TRUE(stack_init(&stack, sizeof(int)));
-    stack.destory(&stack);
-
-    // ------------------------------
-#ifdef NDEBUG
-    TEST_ASSERT_FALSE(stack_init2(NULL, sizeof(int), 1));
-    TEST_ASSERT_FALSE(stack_init2(&stack, 0, 1));
-    TEST_ASSERT_FALSE(stack_init2(&stack, sizeof(int), 0));
-#endif
-    TEST_ASSERT_TRUE(stack_init2(&stack, sizeof(int), 1));
-    stack.destory(&stack);
-}
-
 static void test_stack_new(void)
 {
     stack_t stack = NULL;
-    stack = stack_new();
-    stack_free(&stack);
-
     // ------------------------------
-    stack = stack_new();
+    stack = stack_new(sizeof(int));
     TEST_ASSERT_NOT_NULL(stack);
-
-#ifdef NDEBUG
-    TEST_ASSERT_FALSE(stack_init(NULL, sizeof(int)));
-    TEST_ASSERT_FALSE(stack_init(stack, 0));
-#endif
-    TEST_ASSERT_TRUE(stack_init(stack, sizeof(int)));
     stack_free(&stack);
-
-    // ------------------------------
-    stack = stack_new();
-    TEST_ASSERT_NOT_NULL(stack);
-
-#ifdef NDEBUG
-    TEST_ASSERT_FALSE(stack_init2(NULL, sizeof(int), 1));
-    TEST_ASSERT_FALSE(stack_init2(stack, 0, 1));
-    TEST_ASSERT_FALSE(stack_init2(stack, sizeof(int), 0));
-#endif
-    TEST_ASSERT_TRUE(stack_init2(stack, sizeof(int), 1));
-    stack_free(&stack);
-
     TEST_ASSERT_NULL(stack);
-    stack_free(&stack); // stack_free(NULL);
+
+    // ------------------------------
+    stack = stack_new2(sizeof(int), 10);
+    TEST_ASSERT_NOT_NULL(stack);
+    stack_free(&stack);
+    TEST_ASSERT_NULL(stack);
+
+    // ------------------------------
+    stack_free(&stack);
+    TEST_ASSERT_NULL(stack);
 }
 
 static void test_stack_push(void)
@@ -76,8 +41,7 @@ static void test_stack_push(void)
     stack_t stack = NULL;
 
     // ------------------------------
-    stack = stack_new();
-    stack_init(stack, sizeof(int));
+    stack = stack_new(sizeof(int));
     TEST_ASSERT_TRUE(stack->empty(stack));
     for(i = 0; i < len; i++)
     {
@@ -92,8 +56,7 @@ static void test_stack_push(void)
     stack_free(&stack);
 
     // ------------------------------
-    stack = stack_new();
-    stack_init2(stack, sizeof(int), len);
+    stack = stack_new2(sizeof(int), len);
     TEST_ASSERT_TRUE(stack->empty(stack));
     for(i = 0; i < len; i++)
     {
@@ -109,8 +72,7 @@ static void test_stack_push(void)
 
     // ------------------------------
     // if capacity is less than data len
-    stack = stack_new();
-    stack_init2(stack, sizeof(int), len - 2);
+    stack = stack_new2(sizeof(int), len - 2);
     for(i = 0; i < len; i++)
     {
         TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
@@ -129,8 +91,7 @@ static void test_stack_pop(void)
     stack_t stack = NULL;
 
     // ------------------------------
-    stack = stack_new();
-    stack_init(stack, sizeof(int));
+    stack = stack_new(sizeof(int));
     for(i = 0; i < len; i++)
     {
         stack->push(stack, &data[i]);
@@ -157,8 +118,7 @@ static void test_stack_pop(void)
     stack_free(&stack);
 
     // ------------------------------
-    stack = stack_new();
-    stack_init2(stack, sizeof(int), len);
+    stack = stack_new2(sizeof(int), len);
     for(i = 0; i < len; i++)
     {
         stack->push(stack, &data[i]);
@@ -186,8 +146,7 @@ static void test_stack_pop(void)
 
     // ------------------------------
     // if capacity is less than data len
-    stack = stack_new();
-    stack_init2(stack, sizeof(int), len - 2);
+    stack = stack_new2(sizeof(int), len - 2);
     for(i = 0; i < len; i++)
     {
         TEST_ASSERT_TRUE(stack->push(stack, &data[i]));
@@ -229,8 +188,7 @@ static void test_stack_clear(void)
     stack_t stack = NULL;
 
     // ------------------------------
-    stack = stack_new();
-    stack_init(stack, sizeof(int));
+    stack = stack_new(sizeof(int));
     for(i = 0; i < len; i++)
     {
         stack->push(stack, &data[i]);
@@ -247,8 +205,7 @@ static void test_stack_clear(void)
     stack_free(&stack);
 
     // ------------------------------
-    stack = stack_new();
-    stack_init2(stack, sizeof(int), len);
+    stack = stack_new2(sizeof(int), len);
     TEST_ASSERT_TRUE(stack->clear(stack));
     for(i = 0; i < len; i++)
     {
@@ -269,10 +226,8 @@ static void test_stack_num(void)
     uint32_t len = sizeof(data) / sizeof(data[0]);
 
     stack_t stack = NULL;
-    stack = stack_new();
+    stack = stack_new(sizeof(int));
     TEST_ASSERT_NOT_NULL(stack);
-
-    TEST_ASSERT_TRUE(stack_init(stack, sizeof(int)));
     stack->print_obj = print_num;
 
     TEST_ASSERT_FALSE(stack->peek(stack, &temp));
@@ -324,12 +279,10 @@ static void test_stack_struct(void)
     struct _student temp;
     uint32_t len = sizeof(data) / sizeof(data[0]) - 1;
 
-    stack_t stack = stack_new();
+    stack_t stack = stack_new(sizeof(struct _student));
     TEST_ASSERT_NOT_NULL(stack);
-
-    stack_init(stack, sizeof(struct _student));
     stack->print_obj = print_struct;
-
+ 
     TEST_ASSERT_FALSE(stack->peek(stack, &temp));
     TEST_ASSERT_TRUE(stack->clear(stack));
     for (i = 0; i < len; i++)
@@ -381,10 +334,8 @@ static void test_stack2_num(void)
     uint32_t capacity = len;
 
     stack_t stack = NULL;
-    stack = stack_new();
+    stack = stack_new2(sizeof(int), capacity);
     TEST_ASSERT_NOT_NULL(stack);
-    
-    TEST_ASSERT_TRUE(stack_init2(stack, sizeof(int), capacity));
     stack->print_obj = print_num;
 
     TEST_ASSERT_FALSE(stack->peek(stack, &temp));
@@ -438,10 +389,8 @@ static void test_stack2_struct(void)
     uint32_t capacity = len - 2;
 
     stack_t stack = NULL;
-    stack = stack_new();
+    stack = stack_new2(sizeof(struct _student), capacity);
     TEST_ASSERT_NOT_NULL(stack);
-
-    TEST_ASSERT_TRUE(stack_init2(stack, sizeof(struct _student), capacity));
     stack->print_obj = print_struct;
 
     TEST_ASSERT_FALSE(stack->peek(stack, &temp));
@@ -495,7 +444,6 @@ void test_stack(void)
 {
     UnitySetTestFile(__FILE__);
 
-    RUN_TEST(test_stack_init);
     RUN_TEST(test_stack_new);
     RUN_TEST(test_stack_push);
     RUN_TEST(test_stack_pop);