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

将iter相关配置，包括成员函数的配置，都放在iter的初始化中

Browse Source
This commit is contained in:
建峰 2025-04-27 13:59:14 +08:00
parent 4aa966bb93
commit eb918955f5
7 changed files with 228 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/deque.c
View File

@ -295,25 +295,6 @@ static void deque_print(struct _deque* self)
}
}
iterator_t deque_iter(struct _deque* self, enum _deque_order order)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_order = order;
if(iter->_order == DEQUE_FORWARD)
{
iter->_node = self->_head;
}
else
{
iter->_node = self->_tail;
}
return iter;
}
bool deque_iter_hasnext(struct _iterator* iter)
{
assert(iter != NULL);
@ -355,6 +336,28 @@ const void* deque_iter_next(struct _iterator* iter)
return obj;
}
iterator_t deque_iter(struct _deque* self, enum _deque_order order)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_order = order;
if(iter->_order == DEQUE_FORWARD)
{
iter->_node = self->_head;
}
else
{
iter->_node = self->_tail;
}
iter->hasnext = deque_iter_hasnext;
iter->next = deque_iter_next;
return iter;
}
static bool deque_init(struct _deque* self, uint32_t obj_size)
{
assert(self != NULL);
@ -371,9 +374,6 @@ static bool deque_init(struct _deque* self, uint32_t obj_size)
self->_head = NULL;
self->_tail = NULL;
self->_iter.hasnext = deque_iter_hasnext;
self->_iter.next = deque_iter_next;
self->_destory = deque_destory;
// -------------------- public --------------------

98
src/graph.c
View File

@ -822,52 +822,6 @@ static struct _graph_node * graph_find_next_unvisited_target(struct _graph *self
return NULL;
}
iterator_t graph_iter(struct _graph *self, enum _graph_search search_type, void *start)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->_head->next;
struct _graph_node *start_node = find_node(self, start);
if (start_node == NULL)
{
goto done;
}
iter->_node = start_node;
struct _graph_node *node = self->_head->next;
while (node != NULL)
{
node->visited = false;
node = node->next;
}
self->_search = search_type;
switch (self->_search)
{
case GRAPH_BFS:
{
self->queue->push(self->queue, &iter->_node);
}
break;
case GRAPH_DFS:
{
// pass
}
break;
default:
{
}
break;
}
done:
return iter;
}
bool graph_iter_hasnext(struct _iterator *iter)
{
assert(iter != NULL);
@ -987,6 +941,55 @@ const void *graph_iter_next(struct _iterator *iter)
return obj;
}
iterator_t graph_iter(struct _graph *self, enum _graph_search search_type, void *start)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
// iter->_node = self->_head->next;
struct _graph_node *start_node = find_node(self, start);
if (start_node == NULL)
{
goto done;
}
iter->_node = start_node;
iter->hasnext = graph_iter_hasnext;
iter->next = graph_iter_next;
struct _graph_node *node = self->_head->next;
while (node != NULL)
{
node->visited = false;
node = node->next;
}
self->_search = search_type;
switch (self->_search)
{
case GRAPH_BFS:
{
self->queue->push(self->queue, &iter->_node);
}
break;
case GRAPH_DFS:
{
// pass
}
break;
default:
{
}
break;
}
done:
return iter;
}
static bool graph_init(struct _graph *self, uint32_t obj_size)
{
assert(self != NULL);
@ -1028,9 +1031,6 @@ static bool graph_init(struct _graph *self, uint32_t obj_size)
self->_type = GRAPH_UNDIRECTED;
// self->_type = GRAPH_DIRECTED;
self->_iter.hasnext = graph_iter_hasnext;
self->_iter.next = graph_iter_next;
self->_destory = graph_destory;
// -------------------- public --------------------

29
src/heap.c
View File

@ -249,18 +249,6 @@ static void heap_print(struct _heap* self)
}
}
iterator_t heap_iter(struct _heap* self)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->obj;
return iter;
}
bool heap_iter_hasnext(struct _iterator* iter)
{
assert(iter != NULL);
@ -289,6 +277,20 @@ const void* heap_iter_next(struct _iterator* iter)
return obj;
}
iterator_t heap_iter(struct _heap* self)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->obj;
iter->hasnext = heap_iter_hasnext;
iter->next = heap_iter_next;
return iter;
}
static bool heap_init2(struct _heap* self, uint32_t obj_size, uint32_t capacity)
{
assert(self != NULL);
@ -305,9 +307,6 @@ static bool heap_init2(struct _heap* self, uint32_t obj_size, uint32_t capacity)
return false;
}
self->_iter.hasnext = heap_iter_hasnext;
self->_iter.next = heap_iter_next;
self->_destory = heap_destory;
// -------------------- public --------------------

19
src/list.c
View File

@ -179,14 +179,6 @@ static void list_print(struct _list* self)
}
}
static const void* list_iter_next(struct _iterator* iter)
{
list_t self = (list_t)iter->_container;
void *obj = self->obj + iter->_index * self->_obj_size;
iter->_index += 1;
return obj;
}
static bool list_iter_hasnext(struct _iterator* iter)
{
list_t self = (list_t)iter->_container;
@ -198,6 +190,14 @@ static bool list_iter_hasnext(struct _iterator* iter)
return false;
}
static const void* list_iter_next(struct _iterator* iter)
{
list_t self = (list_t)iter->_container;
void *obj = self->obj + iter->_index * self->_obj_size;
iter->_index += 1;
return obj;
}
iterator_t list_iter(struct _list* self)
{
assert(self != NULL);
@ -205,6 +205,9 @@ iterator_t list_iter(struct _list* self)
iter->_container = self;
iter->_index = 0;
iter->hasnext = list_iter_hasnext;
iter->next = list_iter_next;
return iter;
}

45
src/queue.c
View File

@ -306,17 +306,6 @@ static void queue2_print(struct _queue* self)
}
}
static iterator_t queue_iter(struct _queue* self)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->_front;
return iter;
}
static bool queue_iter_hasnext(struct _iterator* iter)
{
assert(iter != NULL);
@ -349,6 +338,20 @@ static const void* queue_iter_next(struct _iterator* iter)
return obj;
}
static iterator_t queue_iter(struct _queue* self)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->_front;
iter->hasnext = queue_iter_hasnext;
iter->next = queue_iter_next;
return iter;
}
static const void* queue2_iter_next(struct _iterator* iter)
{
assert(iter != NULL);
@ -365,6 +368,20 @@ static const void* queue2_iter_next(struct _iterator* iter)
return obj;
}
static iterator_t queue2_iter(struct _queue* self)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->_front;
iter->hasnext = queue_iter_hasnext;
iter->next = queue2_iter_next;
return iter;
}
static bool queue_init(struct _queue * self, uint32_t obj_size)
{
assert(self != NULL);
@ -387,10 +404,6 @@ static bool queue_init(struct _queue * self, uint32_t obj_size)
// base
self->_destory = queue_destory;
// iter
self->_iter.hasnext = queue_iter_hasnext;
self->_iter.next = queue_iter_next;
// -------------------- public --------------------
// kernel
self->push = queue_push;
@ -471,7 +484,7 @@ static bool queue_init2(struct _queue * self, uint32_t obj_size, uint32_t capaci
self->clear = queue2_clear;
// iter
self->iter = queue_iter;
self->iter = queue2_iter;
// -------------------- debug --------------------
self->print = queue2_print;

38
src/stack.c
View File

@ -254,13 +254,22 @@ static void stack2_print(struct _stack* self)
}
}
bool stack_iter_hasnext(struct _iterator* iter)
{
assert(iter != NULL);
assert(iter->parent != NULL);
stack_t self = (stack_t)iter->_container;
if(iter->_index < self->size(self))
{
return true;
}
return false;
}
/**
* @brief iterator next
* @brief iter next
* from top to bottom
*
* @param iter
* @return const void*
* the value of return is const, so you can't modify it.
*/
const void* stack_iter_next(struct _iterator* iter)
{
@ -291,19 +300,6 @@ const void* stack_iter_next(struct _iterator* iter)
return obj;
}
bool stack_iter_hasnext(struct _iterator* iter)
{
assert(iter != NULL);
assert(iter->parent != NULL);
stack_t self = (stack_t)iter->_container;
if(iter->_index < self->size(self))
{
return true;
}
return false;
}
iterator_t stack_iter(struct _stack* self)
{
assert(self != NULL);
@ -312,6 +308,9 @@ iterator_t stack_iter(struct _stack* self)
iter->_container = self;
iter->_index = 0;
iter->_node = self->_head->next;
iter->hasnext = stack_iter_hasnext;
iter->next = stack_iter_next;
return iter;
}
@ -338,9 +337,6 @@ static bool stack_init(struct _stack* self, uint32_t obj_size)
self->_head->obj = NULL;
self->_head->next = NULL;
self->_iter.next = stack_iter_next;
self->_iter.hasnext = stack_iter_hasnext;
self->_destory = stack_destory;
// ---------- public ----------

175
src/tree.c
View File

@ -1151,88 +1151,9 @@ static bool tree_rb_delete(struct _tree* self, void* obj)
return true;
}
static iterator_t tree_iter(struct _tree* self, enum _tree_order order)
static uint32_t tree_height(struct _tree* self)
{
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->_root;
iter->_order = order;
self->stack->clear(self->stack);
self->queue->clear(self->queue);
switch (iter->_order)
{
case ORDER_PRE:
case ORDER_PRE_R:
{
// pass
}break;
case ORDER_IN:
case ORDER_IN_R:
{
// pass
}break;
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 (iter->_order == ORDER_POST)
{
while (!stack->empty(stack) || node != NULL)
{
if (node != NULL)
{
self->stack->push(self->stack, &node);
stack->push(stack, &node);
node = node->right;
}
else
{
stack->pop(stack, &node);
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);
}break;
case ORDER_BREADTH:
case ORDER_BREADTH_R:
{
// pass
self->queue->push(self->queue, &self->_root);
}break;
default:
{
}break;
}
return iter;
return tree_height_node(self, self->_root);
}
static bool tree_iter_hasnext(struct _iterator* iter)
@ -1398,9 +1319,91 @@ static const void* tree_iter_next(struct _iterator* iter)
return obj;
}
static uint32_t tree_height(struct _tree* self)
static iterator_t tree_iter(struct _tree* self, enum _tree_order order)
{
return tree_height_node(self, self->_root);
assert(self != NULL);
iterator_t iter = &self->_iter;
iter->_container = self;
iter->_index = 0;
iter->_node = self->_root;
iter->_order = order;
iter->hasnext = tree_iter_hasnext;
iter->next = tree_iter_next;
self->stack->clear(self->stack);
self->queue->clear(self->queue);
switch (iter->_order)
{
case ORDER_PRE:
case ORDER_PRE_R:
{
// pass
}break;
case ORDER_IN:
case ORDER_IN_R:
{
// pass
}break;
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 (iter->_order == ORDER_POST)
{
while (!stack->empty(stack) || node != NULL)
{
if (node != NULL)
{
self->stack->push(self->stack, &node);
stack->push(stack, &node);
node = node->right;
}
else
{
stack->pop(stack, &node);
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);
}break;
case ORDER_BREADTH:
case ORDER_BREADTH_R:
{
// pass
self->queue->push(self->queue, &self->_root);
}break;
default:
{
}break;
}
return iter;
}
static bool tree_avl_init(struct _tree* self, uint32_t obj_size)
@ -1427,9 +1430,6 @@ static bool tree_avl_init(struct _tree* self, uint32_t obj_size)
return false;
}
self->_iter.hasnext = tree_iter_hasnext;
self->_iter.next = tree_iter_next;
self->_rebalance = tree_avl_rebalance;
self->_destory = tree_destory;
@ -1478,9 +1478,6 @@ static bool tree_rb_init(struct _tree* self, uint32_t obj_size)
return false;
}
self->_iter.hasnext = tree_iter_hasnext;
self->_iter.next = tree_iter_next;
self->_rebalance = tree_rb_rebalance;
self->_destory = tree_destory;