static inline s_splay_tree_t * splay_tree_find_i(s_splay_tree_t **tree, sint64 nice) { s_splay_tree_t **iterator; s_splay_tree_t *splay_node; s_array_stack_t *path_stack; assert_exit(NON_NULL_PTR_P(tree)); assert_exit(splay_tree_structure_legal_ip(*tree)); iterator = tree; splay_node = *tree; path_stack = array_stack_create(); while (splay_node) { if (nice < splay_node->nice) { array_stack_push(path_stack, TREE_PATH_L_ENCODE(iterator)); iterator = &splay_node->left; } else if (nice > splay_node->nice) { array_stack_push(path_stack, TREE_PATH_R_ENCODE(iterator)); iterator = &splay_node->right; } else { splay_tree_splaying(path_stack); assert_exit(*tree = splay_node); break; } splay_node = *iterator; } array_stack_destroy(&path_stack); return splay_node; }
static inline s_splay_tree_t * splay_tree_find_max_i(s_splay_tree_t **tree) { s_splay_tree_t *max_node; s_splay_tree_t **iterator; s_array_stack_t *path_stack; assert_exit(NON_NULL_PTR_P(tree)); assert_exit(splay_tree_structure_legal_ip(*tree)); iterator = tree; max_node = *tree; path_stack = array_stack_create(); while (max_node->right) { array_stack_push(path_stack, TREE_PATH_R_ENCODE(iterator)); iterator = &max_node->right; max_node = *iterator; } splay_tree_splaying(path_stack); array_stack_destroy(&path_stack); assert_exit(*tree == max_node); return max_node; }
boolean check_parantheses_match(const char *expr) { int i = 0; array_stack_t pstack; boolean valid = TRUE; array_stack_init(&pstack, MAX_EXPR_SIZE); for (i=0; expr[i]; i++) { if (is_opening_parantheses(expr[i])) { array_stack_push(&pstack, expr[i]); } else if (is_closing_parantheses(expr[i])) { if (array_stack_isEmpty(&pstack)) { valid = FALSE; break; } int symb = array_stack_pop(&pstack); /** 'symb' must be matching opener for expr[i] */ if (! is_matching_parantheses(symb, expr[i]) ) { valid = FALSE; break; } } } if (!array_stack_isEmpty(&pstack)) { valid = FALSE; } array_stack_destroy(&pstack); return valid; }
static inline s_splay_tree_t * splay_tree_insert_i(s_splay_tree_t **tree, s_splay_tree_t *node) { s_array_stack_t *path_stack; s_splay_tree_t *splay_node, **iterator; assert_exit(NON_NULL_PTR_P(tree)); assert_exit(splay_tree_structure_legal_ip(node)); assert_exit(splay_tree_structure_legal_ip(*tree)); assert_exit(splay_tree_ordered_p(*tree)); iterator = tree; splay_node = *iterator; path_stack = array_stack_create(); while (splay_node) { if (node == splay_node) { pr_log_warn("Insert node exist, nothing will be done.\n"); array_stack_destroy(&path_stack); return splay_node; } else if (node->nice < splay_node->nice) { array_stack_push(path_stack, TREE_PATH_L_ENCODE(iterator)); iterator = &splay_node->left; } else if (node->nice > splay_node->nice) { array_stack_push(path_stack, TREE_PATH_R_ENCODE(iterator)); iterator = &splay_node->right; } else { splay_tree_node_merge(splay_node, node); splay_tree_splaying(path_stack); array_stack_destroy(&path_stack); return splay_node; } splay_node = *iterator; } *iterator = node; splay_tree_splaying(path_stack); array_stack_destroy(&path_stack); assert_exit(*tree == node); assert_exit(splay_tree_ordered_p(*tree)); return node; }
static inline void stacked_queue_stack_dump(s_array_stack_t *from, s_array_stack_t *to) { assert_exit(array_stack_structure_legal_p(to)); assert_exit(array_stack_structure_legal_p(from)); assert_exit(array_stack_empty_p(to)); assert_exit(array_stack_capacity(from) == array_stack_capacity(to)); while (!array_stack_empty_p(from)) { array_stack_push(to, array_stack_pop(from)); } }
int main (void) { array_stack_t mystack; int i; assert(array_stack_init(&mystack, MAX_STACK_SIZE) == 0); assert(array_stack_isEmpty(&mystack) == TRUE); array_stack_print(&mystack, printAsInt); for(i=0; i<MAX_STACK_SIZE; i++) { assert(array_stack_push(&mystack, (void *)(i+1)) == 0); array_stack_print(&mystack, printAsInt); assert((int)array_stack_peek(&mystack) == (i+1)); assert(array_stack_len(&mystack) == (i+1)); } assert(array_stack_isFull(&mystack) == TRUE); assert(array_stack_isEmpty(&mystack) == FALSE); assert(array_stack_push(&mystack, (void *)(11)) == -EINVAL); for(i=0; i<MAX_STACK_SIZE; i++) { assert((int)array_stack_peek(&mystack) == (MAX_STACK_SIZE-i)); assert(array_stack_len(&mystack) == (MAX_STACK_SIZE-i)); assert(array_stack_pop(&mystack) == (MAX_STACK_SIZE-i)); array_stack_print(&mystack, printAsInt); } assert(array_stack_isFull(&mystack) == FALSE); assert(array_stack_isEmpty(&mystack) == TRUE); array_stack_destroy(&mystack); printf("All tests succeed!\n"); return 0; }
void stacked_queue_enter(s_stacked_queue_t *queue, void *member) { if (stacked_queue_structure_legal_p(queue) && !NULL_PTR_P(member)) { if (array_stack_full_p(queue->enter) && array_stack_empty_p(queue->leave)) { pr_log_info("Empty leave stack, will dump enter stack to leave.\n"); stacked_queue_stack_dump(queue->enter, queue->leave); } else if (array_stack_full_p(queue->enter)) { pr_log_info("Fail to dump enter stack, will expand enter space.\n"); stacked_queue_resize_i(queue, queue->dim * 2); } array_stack_push(queue->enter, member); } }
static inline void trie_tree_sequence_remove_i(s_trie_tree_t *trie, uint32 *sequence, uint32 len) { uint32 *seq; s_array_stack_t *stack; s_trie_tree_t *trie_node; assert_exit(!complain_zero_size_p(len)); assert_exit(trie_tree_root_node_p(trie)); assert_exit(trie_tree_structure_legal_p(trie)); assert_exit(!NULL_PTR_P(sequence)); seq = sequence; trie_node = trie; stack = array_stack_create(); while (seq < sequence + len) { trie_node = trie_tree_sub_queue_find(trie_node, *seq); if (trie_node == NULL) { array_stack_destroy(&stack); return; } else { array_stack_push(stack, trie_node); seq++; } } while (!array_stack_empty_p(stack)) { trie_node = array_stack_pop(stack); if (trie_tree_sub_queue_empty_p(trie_node)) { trie_node->is_deleted = true; } } array_stack_destroy(&stack); }