apaki/unicstl
1
0
Fork 0
mirror of https://gitee.com/apaki/unicstl.git synced 2025-07-05 00:16:53 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

给stack添加new和free接口

Browse Source
This commit is contained in:
建峰 2024-06-23 02:01:00 +08:00
parent 4f00844fa6
commit e778cfd7c4
5 changed files with 163 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.vscode/settings.json vendored
View File

@ -7,6 +7,7 @@
"test.h": "c", "test.h": "c",
"queue.h": "c", "queue.h": "c",
"stdbool.h": "c", "stdbool.h": "c",
"stdint.h": "c" "stdint.h": "c",
"stack.h": "c"
} }
} }

9
include/stack.h
View File

@ -33,9 +33,12 @@ struct _stack
void (*print_obj)(void* obj); void (*print_obj)(void* obj);
void (*print)(struct _stack* s); void (*print)(struct _stack* s);
}; };
typedef struct _stack* stack_t;
bool stack_init(struct _stack* s, uint32_t obj_size); // 链表 bool stack_init(struct _stack* self, uint32_t obj_size);
bool stack2_init(struct _stack* s, uint32_t obj_size); // 数组 bool stack_init2(struct _stack* self, uint32_t obj_size, uint32_t capacity);
stack_t stack_new(void);
void stack_free(stack_t stack);
#endif // _STACK_H_ #endif // _STACK_H_

250
src/stack.c
View File

@ -1,54 +1,54 @@
#include "stack.h" #include "stack.h"
static uint32_t stack_capacity(struct _stack* s) static uint32_t stack_capacity(struct _stack* self)
{ {
assert(s != NULL); assert(self != NULL);
return s->_capacity; return self->_capacity;
} }
static uint32_t stack_size(struct _stack* s) static uint32_t stack_size(struct _stack* self)
{ {
assert(s != NULL); assert(self != NULL);
return s->_size; return self->_size;
} }
static bool stack_empty(struct _stack* s) static bool stack_empty(struct _stack* self)
{ {
assert(s != NULL); assert(self != NULL);
// assert(s->_head != NULL); // assert(self->_head != NULL);
// return s->_head->next == NULL ? true : false; // return self->_head->next == NULL ? true : false;
return !stack_size(s); return !stack_size(self);
} }
static bool stack_peek(struct _stack* s, void* obj) static bool stack_peek(struct _stack* self, void* obj)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
assert(obj != NULL); assert(obj != NULL);
if (s->empty(s)) if (self->empty(self))
{ {
return false; return false;
} }
struct _stack_node * node = s->_head->next; struct _stack_node * node = self->_head->next;
memmove(obj, node->obj, s->_obj_size); memmove(obj, node->obj, self->_obj_size);
return true; return true;
} }
static bool stack_push(struct _stack* s, void* obj) static bool stack_push(struct _stack* self, void* obj)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
assert(obj != NULL); assert(obj != NULL);
void* new_obj = (void*)calloc(1, s->_obj_size); void* new_obj = (void*)calloc(1, self->_obj_size);
if (new_obj == NULL) if (new_obj == NULL)
{ {
return false; return false;
} }
memmove(new_obj, obj, s->_obj_size); memmove(new_obj, obj, self->_obj_size);
struct _stack_node* new_node = (struct _stack_node*)malloc(sizeof(struct _stack_node)); struct _stack_node* new_node = (struct _stack_node*)malloc(sizeof(struct _stack_node));
if (new_node == NULL) if (new_node == NULL)
@ -56,242 +56,254 @@ static bool stack_push(struct _stack* s, void* obj)
return false; return false;
} }
new_node->obj = new_obj; new_node->obj = new_obj;
new_node->next = s->_head->next; new_node->next = self->_head->next;
s->_head->next = new_node; self->_head->next = new_node;
s->_size += 1; self->_size += 1;
return true; return true;
} }
static bool stack_pop(struct _stack* s, void* obj) static bool stack_pop(struct _stack* self, void* obj)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
// assert(obj != NULL); // assert(obj != NULL);
if (s->empty(s)) if (self->empty(self))
{ {
return false; return false;
} }
struct _stack_node* node = s->_head->next; struct _stack_node* node = self->_head->next;
if (obj != NULL) if (obj != NULL)
{ {
// 将弹出的数据输出 // 将弹出的数据输出
memmove(obj, node->obj, s->_obj_size); memmove(obj, node->obj, self->_obj_size);
} }
// 更新指针 // 更新指针
s->_head->next = node->next; self->_head->next = node->next;
// 释放数据和节点 // 释放数据和节点
free(node->obj); free(node->obj);
free(node); free(node);
s->_size -= 1; self->_size -= 1;
return true; return true;
} }
static bool stack_clear(struct _stack* s) static bool stack_clear(struct _stack* self)
{ {
assert(s != NULL); assert(self != NULL);
if (s->empty(s)) if (self->empty(self))
{ {
return false; return false;
} }
struct _stack_node* node = s->_head->next; struct _stack_node* node = self->_head->next;
while (node != NULL) while (node != NULL)
{ {
// 更新指针 // 更新指针
s->_head->next = node->next; self->_head->next = node->next;
// 释放数据和节点 // 释放数据和节点
free(node->obj); free(node->obj);
free(node); free(node);
node = s->_head->next; node = self->_head->next;
} }
s->_size = 0; self->_size = 0;
return true; return true;
} }
static void stack_destory(struct _stack* s) static void stack_destory(struct _stack* self)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
s->clear(s); self->clear(self);
free(s->_head); free(self->_head);
s->_head = NULL; self->_head = NULL;
} }
static void stack_print(struct _stack* s) static void stack_print(struct _stack* self)
{ {
uint32_t i = 0; uint32_t i = 0;
struct _stack_node* node = s->_head->next; struct _stack_node* node = self->_head->next;
while (node != NULL) while (node != NULL)
{ {
s->print_obj(node->obj); self->print_obj(node->obj);
node = node->next; node = node->next;
} }
} }
bool stack_init(struct _stack* s, uint32_t obj_size) bool stack_init(struct _stack* self, uint32_t obj_size)
{ {
assert(s != NULL); assert(self != NULL);
// 1. set attr // 1. set attr
s->_obj_size = obj_size; self->_obj_size = obj_size;
s->_size = 0; self->_size = 0;
// s->_capacity = 64; // ÎÞЧ // self->_capacity = 64; // ÎÞЧ
// s->_ratio = 2; // ÎÞЧ // self->_ratio = 2; // ÎÞЧ
// 2. set function // 2. set function
// kernel // kernel
s->peek = stack_peek; self->peek = stack_peek;
s->pop = stack_pop; self->pop = stack_pop;
s->push = stack_push; self->push = stack_push;
// others // others
s->clear = stack_clear; self->clear = stack_clear;
s->empty = stack_empty; self->empty = stack_empty;
s->size = stack_size; self->size = stack_size;
s->destory = stack_destory; self->destory = stack_destory;
s->print = stack_print; self->print = stack_print;
// 3. set node // 3. set node
s->_head = (struct _stack_node *)malloc(sizeof(struct _stack_node)); self->_head = (struct _stack_node *)malloc(sizeof(struct _stack_node));
if (s->_head == NULL) if (self->_head == NULL)
{ {
return false; return false;
} }
s->_head->obj = NULL; self->_head->obj = NULL;
s->_head->next = NULL; self->_head->next = NULL;
return true; return true;
} }
static bool stack2_peek(struct _stack* s, void* obj) static bool stack2_peek(struct _stack* self, void* obj)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
assert(obj != NULL); assert(obj != NULL);
if (s->empty(s)) if (self->empty(self))
{ {
return false; return false;
} }
uint32_t top = s->size(s) - 1; uint32_t top = self->size(self) - 1;
uint32_t offset = top * s->_obj_size; uint32_t offset = top * self->_obj_size;
memmove(obj, (char *)s->_head->obj + offset, s->_obj_size); memmove(obj, (char *)self->_head->obj + offset, self->_obj_size);
return true; return true;
} }
static bool stack2_push(struct _stack* s, void* obj) static bool stack2_push(struct _stack* self, void* obj)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
assert(obj != NULL); assert(obj != NULL);
if (s->size(s) == s->_capacity) if (self->size(self) == self->_capacity)
{ {
void* obj_new = (void*)realloc(s->_head->obj, s->_capacity * s->_obj_size * s->_ratio); void* obj_new = (void*)realloc(self->_head->obj, self->_capacity * self->_obj_size * self->_ratio);
if (obj_new == NULL) if (obj_new == NULL)
{ {
return false; return false;
} }
s->_head->obj = obj_new; self->_head->obj = obj_new;
} }
uint32_t top = s->size(s); uint32_t top = self->size(self);
uint32_t offset = top * s->_obj_size; uint32_t offset = top * self->_obj_size;
memmove((char*)s->_head->obj + offset, obj, s->_obj_size); memmove((char*)self->_head->obj + offset, obj, self->_obj_size);
s->_size += 1; self->_size += 1;
return true; return true;
} }
static bool stack2_pop(struct _stack* s, void* obj) static bool stack2_pop(struct _stack* self, void* obj)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
// assert(obj != NULL); // assert(obj != NULL);
if (s->empty(s)) if (self->empty(self))
{ {
return false; return false;
} }
if (obj != NULL) if (obj != NULL)
{ {
uint32_t top = s->size(s) - 1; uint32_t top = self->size(self) - 1;
uint32_t offset = top * s->_obj_size; uint32_t offset = top * self->_obj_size;
memmove(obj, (char*)s->_head->obj + offset, s->_obj_size); memmove(obj, (char*)self->_head->obj + offset, self->_obj_size);
} }
s->_size -= 1; self->_size -= 1;
return true; return true;
} }
static void stack2_print(struct _stack* s) static void stack2_print(struct _stack* self)
{ {
assert(s != NULL); assert(self != NULL);
assert(s->_head != NULL); assert(self->_head != NULL);
void* obj = NULL; void* obj = NULL;
uint32_t offset = 0; uint32_t offset = 0;
for (int i = s->size(s) - 1; i >= 0; i--) for (int i = self->size(self) - 1; i >= 0; i--)
{ {
offset = s->_obj_size * i; offset = self->_obj_size * i;
obj = (char*)s->_head->obj + offset; obj = (char*)self->_head->obj + offset;
s->print_obj(obj); self->print_obj(obj);
} }
} }
bool stack2_init(struct _stack* s, uint32_t obj_size) bool stack_init2(struct _stack* self, uint32_t obj_size, uint32_t capacity)
{ {
assert(s != NULL); assert(self != NULL);
// 1. set attr // 1. set attr
s->_obj_size = obj_size; self->_obj_size = obj_size;
s->_size = 0; self->_size = 0;
s->_capacity = 64; self->_capacity = capacity;
s->_ratio = 2; self->_ratio = 2;
// 2. set function // 2. set function
// kernel // kernel
s->peek = stack2_peek; self->peek = stack2_peek;
s->pop = stack2_pop; self->pop = stack2_pop;
s->push = stack2_push; self->push = stack2_push;
// others // others
s->clear = stack_clear; self->clear = stack_clear;
s->empty = stack_empty; self->empty = stack_empty;
s->size = stack_size; self->size = stack_size;
s->destory = stack_destory; self->destory = stack_destory;
s->print = stack2_print; self->print = stack2_print;
// 3. set node // 3. set node
s->_head = (struct _stack_node*)malloc(sizeof(struct _stack_node)); self->_head = (struct _stack_node*)malloc(sizeof(struct _stack_node));
if (s->_head == NULL) if (self->_head == NULL)
{ {
return false; return false;
} }
// s->_head->obj = NULL; // self->_head->obj = NULL;
s->_head->next = NULL; // ÎÞЧ²ÎÊý self->_head->next = NULL; // ÎÞЧ²ÎÊý
// 4. set array // 4. set array
s->_head->obj = (void *)calloc(s->_capacity, s->_obj_size); self->_head->obj = (void *)calloc(self->_capacity, self->_obj_size);
if (s->_head->obj == NULL) if (self->_head->obj == NULL)
{ {
return false; return false;
} }
return true; return true;
} }
stack_t stack_new(void)
{
return (struct _stack*)malloc(sizeof(struct _stack));
}
void stack_free(stack_t stack)
{
if(stack)
{
free(stack);
}
}

4
test/test.c
View File

@ -28,9 +28,9 @@ int main()
// while (1) // while (1)
{ {
// list_test(); // list_test();
// stack_test(); stack_test();
// deque_test(); // deque_test();
queue_test(); // queue_test();
// tree_test(); // tree_test();
// rbtree_test(); // rbtree_test();

42
test/test_stack.c
View File

@ -79,7 +79,7 @@ static void stack_test_char(void)
uint32_t len = sizeof(data) / sizeof(data[0]) - 1; uint32_t len = sizeof(data) / sizeof(data[0]) - 1;
struct _stack s; struct _stack s;
stack2_init(&s, sizeof(char)); stack_init2(&s, sizeof(char), 64);
s.print_obj = print_char; s.print_obj = print_char;
printf("\n\n----- stack_test_char -----\n"); printf("\n\n----- stack_test_char -----\n");
@ -154,69 +154,71 @@ static void stack_test_struct(void)
struct _student temp = { 0 }; struct _student temp = { 0 };
uint32_t len = sizeof(data) / sizeof(data[0]); uint32_t len = sizeof(data) / sizeof(data[0]);
struct _stack s; stack_t stack;
stack_init(&s, sizeof(struct _student)); stack = stack_new();
s.print_obj = print_struct; stack_init(stack, sizeof(struct _student));
stack->print_obj = print_struct;
printf("\n\n----- stack_test_struct -----\n"); printf("\n\n----- stack_test_struct -----\n");
// get top if stack is empty // get top if stack is empty
s.peek(&s, &temp); stack->peek(stack, &temp);
printf("----- push -----\n"); printf("----- push -----\n");
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
{ {
s.push(&s, &data[i]); stack->push(stack, &data[i]);
s.peek(&s, &temp); stack->peek(stack, &temp);
printf("top = "); printf("top = ");
s.print_obj(&temp); stack->print_obj(&temp);
printf("size = %2d\n", s.size(&s)); printf("size = %2d\n", stack->size(stack));
} }
printf("----- print -----\n"); printf("----- print -----\n");
s.print(&s); stack->print(stack);
printf("\n"); printf("\n");
printf("----- clear -----\n"); printf("----- clear -----\n");
s.clear(&s); stack->clear(stack);
printf("----- print -----\n"); printf("----- print -----\n");
s.print(&s); stack->print(stack);
printf("\n"); printf("\n");
printf("----- push -----\n"); printf("----- push -----\n");
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
{ {
s.push(&s, &data[i]); stack->push(stack, &data[i]);
} }
printf("----- pop -----\n"); printf("----- pop -----\n");
for (i = 0; i < len + 1; i++) for (i = 0; i < len + 1; i++)
{ {
if (true == s.pop(&s, &temp)) if (true == stack->pop(stack, &temp))
{ {
printf("pop = "); printf("pop = ");
s.print_obj(&temp); stack->print_obj(&temp);
if (s.peek(&s, &temp)) if (stack->peek(stack, &temp))
{ {
printf("top = "); printf("top = ");
s.print_obj(&temp); stack->print_obj(&temp);
} }
printf("size = %2d\n", s.size(&s)); printf("size = %2d\n", stack->size(stack));
} }
else else
{ {
printf("pop failed! because it is empty\n"); printf("pop failed! because it is empty\n");
} }
if (s.empty(&s)) if (stack->empty(stack))
{ {
printf("----- empty -----\n"); printf("----- empty -----\n");
} }
} }
s.destory(&s); stack->destory(stack);
stack_free(stack);
} }
void stack_test(void) void stack_test(void)