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

stack修改创建接口

Browse Source
This commit is contained in:
建峰 2025-04-22 23:04:01 +08:00
parent e53ef3f1a6
commit 769f7040d2
6 changed files with 68 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -13,8 +13,8 @@
|数据结构 | 原理 |说明 |
|---|---|---|
| **stack** | | **栈** |
| stack_init | 链表 | |
| stack_init2 | 动态数组 | |
| stack_new | 链表 | |
| stack_new2 | 动态数组 | |
| **list** | | **列表**
| list_init2 | 动态数组 | |
| **queue** | | **队列**

9
demo/demo_stack.c
View File

@ -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");

6
include/stack.h
View File

@ -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_

33
src/stack.c
View File

@ -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)

21
src/tree.c
View File

@ -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)
{

100
test/test_stack.c
View File

@ -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);