int suffix_cal(char exp[]) { stack temp; stack s; stack s2; init_stack(&temp, 100); init_stack(&s, 100); init_stack(&s2, 100); while(*exp != '\0') { push(&temp, *exp); exp++; } while(stack_length(&temp) != 0) push(&s, pop(&temp)); while(stack_length(&s) != 0) { push(&s2, pop(&s)); if(gettop(&s2) == '+' ||gettop(&s2) == '-'||gettop(&s2)=='*'||gettop(&s2) == '/') { char ch3 = pop(&s2); char ch2 = pop(&s2); char ch1 = pop(&s2); int r = calculate(ch1, ch2, ch3); char ch = r + 48; push(&s2, ch); } } return gettop(&s2) - 48; }
float process_data(STACK *pst1) { float d; STACK integ,deci; init_stack(&integ);init_stack(&deci); filter(pst1,&integ,&deci); return process_integral(&integ)+process_decimal(&deci); }
PCIPHEREXP __INTERNAL_FUNC__ ReverseCipherExpression(PCIPHEREXP pCipherExp) { /* * 再压入操作符号与操作节点时 * 链中第一个节点不压入栈 * 最后一个操作符号不压入栈 * * 逆向式中的第一个节点肯定没有操作符号 */ __bool bIsFirst = TRUE; LOGIC_OPT *pOpt = NULL; PCIPHEREXP pReverseCipherExp = NULL, *pReverseCipherExpPoint = NULL; PCIPHEREXP pCurrCipherExp = pCipherExp; PSTACK pOptStack = init_stack(0); __integer i = 0, iCipherNodeCount = CountCipherNode(pCipherExp); PSTACK pCipherExpNodeStack = init_stack(sizeof(CIPHEREXP) * iCipherNodeCount); for (i = 0; i < iCipherNodeCount; i++) { if (i == 0) {//舍弃第一个节点 push_stack(pOptStack, &(pCurrCipherExp->Opt), sizeof(LOGIC_OPT)); } else if (i == iCipherNodeCount-1) { push_stack(pCipherExpNodeStack, pCurrCipherExp, sizeof(CIPHEREXP)); } else { push_stack(pOptStack, &(pCurrCipherExp->Opt), sizeof(LOGIC_OPT)); push_stack(pCipherExpNodeStack, pCurrCipherExp, sizeof(CIPHEREXP)); } pCurrCipherExp = pCurrCipherExp->pNextExp; } /* * 首先扩充第一个节点(变量) */ pReverseCipherExpPoint = &pReverseCipherExp; do { pOpt = (LOGIC_OPT *)pop_stack(pOptStack, sizeof(LOGIC_OPT)); (*pReverseCipherExpPoint) = CreateCipherExp(); // 如果是第一个节点 if (bIsFirst) { (*pReverseCipherExpPoint)->bNot = pCipherExp->bNot;//第一个变量是否拥有NOT操作 (*pReverseCipherExpPoint)->Opt = GenerateReverseLogicOpt(*pOpt); bIsFirst = FALSE; } else { if (!pOpt) (*pReverseCipherExpPoint)->Opt = LOGIC_NONE; else (*pReverseCipherExpPoint)->Opt = *pOpt; pCurrCipherExp = (PCIPHEREXP)pop_stack(pCipherExpNodeStack, sizeof(CIPHEREXP)); (*pReverseCipherExpPoint)->bKey = pCurrCipherExp->bKey; (*pReverseCipherExpPoint)->bNot = pCurrCipherExp->bNot; (*pReverseCipherExpPoint)->dwVal = pCurrCipherExp->dwVal; }/* end else */ pReverseCipherExpPoint = &((*pReverseCipherExpPoint)->pNextExp); } while (pOpt); free_stack(pOptStack); free_stack(pCipherExpNodeStack); return pReverseCipherExp; }
int EvaluateExpression(){ int n; int flag; int c; char x,theta; int a,b; char OP[]="+-*/()#"; SqStack OPTR; SqStack OPND; init_stack(&OPTR); push(&OPTR,'#'); init_stack(&OPND); flag=getNext(&c); get_top(OPTR, &x); while(c!='#' || x != '#') { if(flag == 0) { push(&OPND,c); flag = getNext(&c); } else { get_top(OPTR, &x); switch(Precede(x, c)) { case '<'://栈顶元素优先级低 push(&OPTR,c); flag = getNext(&c); break; case '='://脱括号并接受下一字符 pop(&OPTR,&x); flag = getNext(&c); break; case '>':// 退栈并将运算结果入栈 pop(&OPTR, &theta); pop(&OPND,&b); pop(&OPND,&a); push(&OPND, Operate(a, theta, b)); break; } } get_top(OPTR, &x); } get_top(OPND, &c); return c; }
int user_main(int argc, char **argv) { int i; int *param; unsigned int in_sum = 0, out_sum = 0; atomic_init(&x[1], 0); atomic_init(&x[2], 0); stack = (stack_t*) calloc(1, sizeof(*stack)); num_threads = procs; threads = (thrd_t*) malloc(num_threads * sizeof(thrd_t)); param = (int*) malloc(num_threads * sizeof(*param)); init_stack(stack, num_threads); for (i = 0; i < num_threads; i++) { param[i] = i; thrd_create(&threads[i], main_task, ¶m[i]); } for (i = 0; i < num_threads; i++) thrd_join(threads[i]); bool correct = false; //correct |= (a == 17 || a == 37 || a == 0); //MODEL_ASSERT(correct); free(param); free(threads); free(stack); return 0; }
int main() { unsigned int i; int tmp; Stack s; int test_data[SIZE] = {7,8,6,10,5,4,12,3,13,12}; init_stack(&s); for(i = 0; i < SIZE; i++) { stack_push(&s, test_data[i]); } printf(">>>>>>start to pop\n"); while(!stack_is_empty(&s)) { if(get_min(&s, &tmp)) printf("min is %d\n", tmp); stack_pop(&s, &tmp); printf("%d\n", tmp); } return 0; }
int main() { int n; stack tmp = { 0, 0 }; stack *s = &tmp; init_stack(s); printf("input int:"); while (scanf("%d", &n) != EOF) { if (n < 0) { int v = pop_stack(s); printf("pop() -> v:%d,num:%d,size:%d\n", v, get_stack_datanum(s), get_stack_size(s)); } else if (n > 0) { push_stack(s, n); printf("push() -> num:%d,size:%d\n", get_stack_datanum(s), get_stack_size(s)); } else { break; } printf("input int:"); } printf("over...\n"); release_stack(s); //释放内存 return 0; }
int balance(unsigned char *p){ unsigned char c; init_stack(); for( ; (c = *p) != '\0'; p++){ switch(c){ case '(': case '[': case '{': push(c); break; case ')': if(pop(c) != '(') return(0); break; case '}': if(pop(c) != '{') return(0); break; case ']': if(pop(c) != '[') return(0); break; default: break; } } if(depth() == NULL) return(1); else return(0); }
void quick_sort1(void *base, size_t nelem, size_t width, FCMP fcmp) { /* remove recursion & median & small subfile insert*/ void *v, *u; int i, j, t; int l, r; init_stack(); v = malloc(width); u = malloc(width); l = 0; r = nelem-1; push(r); push(l); while (!is_stack_empty()) { l = pop(); r = pop(); if (r-l+1 > 100) /* terminal condition */ { t = (r+l) >> 1; /* t is middle */ if (fcmp(BASE(l), BASE(t)) > 0) /* sort left, middle, right */ { memcpy(v, BASE(l), width); memcpy(BASE(l), BASE(t), width); memcpy(BASE(t), v, width); } if (fcmp(BASE(l), BASE(r)) > 0) /* sort left, middle, right */ { memcpy(v, BASE(l), width); memcpy(BASE(l), BASE(r), width); memcpy(BASE(r), v, width); } if (fcmp(BASE(t), BASE(r)) > 0) /* sort left, middle, right */ { memcpy(v, BASE(t), width); memcpy(BASE(t), BASE(r), width); memcpy(BASE(r), v, width); } memcpy(v, BASE(t), width); /* exchange middle with a[r-1] */ memcpy(BASE(t), BASE(r-1), width); memcpy(BASE(r-1), v, width); i = l; /* partition l+1 to r-2 */ j = r-1; while (1) /* partition */ { while (fcmp(BASE(++i), v) < 0); while (fcmp(BASE(--j), v) > 0); if (i >= j) break; memcpy(u, BASE(i), width); memcpy(BASE(i), BASE(j), width); memcpy(BASE(j), u, width); } memcpy(u, BASE(i), width); memcpy(BASE(i), BASE(r-1), width); memcpy(BASE(r-1), u, width); push(r); push(i+1); push(i-1); push(l); } else
void post_order_iterative(struct Tnode *root) { if (root == NULL) return; struct stack st; init_stack(&st, 1); push(&st, root); struct Tnode *prev = NULL; while (!is_empty(&st)) { struct Tnode *cur = (struct Tnode *)top(&st); if (!prev || prev->left == cur || prev->right == cur) { if (cur->left != NULL) push(&st, cur->left); else if (cur->right != NULL) push(&st, cur->right); else { printf("%d,", cur->data); pop(&st); } } else if(cur->left == prev) { if (cur->right != NULL) push(&st, cur->right); else { printf("%d,", cur->data); pop(&st); } } else if (cur->right == prev) { printf("%d,", cur->data); pop(&st); } prev = cur; } printf("\n"); }
int calc_suffix_expr(int *suffix, int len) { int i, tmp, param1, param2, result = 0; link_stack sans; init_stack(&sans); for (i = 0; i < len; i++) { switch (suffix[i]) { case '+': case '-': case '*': case '/': pop(&sans, ¶m2); pop(&sans, ¶m1); tmp = calc_little(param1, param2, suffix[i]); push(&sans, tmp); break; default: push(&sans, suffix[i]); } } pop(&sans, &result); return result; }
int infix_to_suffix(int *mid, int mid_len, int *suffix) { int i, tmp, counter = 0; link_stack sans; init_stack(&sans); for (i = 0; i < mid_len; i++) { switch (mid[i]) { case '+': case '-': case '*': case '/': case '(': case ')': process_op_char(mid[i], &sans, suffix, &counter); break; default: suffix[counter++] = mid[i]; break; } } while (!is_empty(&sans)) { pop(&sans, &tmp); suffix[counter++] = tmp; } return counter; }
int main() { stack_sq S; int a[] = {3, 8, 5, 17, 9, 30, 15, 22}; int i; init_stack(&S, 5); for (i = 0; i < 8; i++) { push(&S, a[i]); } printf("%d ", pop(&S)); printf("%d \n", pop(&S)); push(&S, 68); printf("%d ", peek_stack(&S)); printf("%d \n", pop(&S)); while(!empty_stack(&S)) { printf("%d ", pop(&S)); } printf("\n"); clear_stack(&S); return 0; }
void DFS_directed(node *a[], int V) { /* Get Transitive Closure by Depth First Search */ int i, j; node *t; init_stack(); for (i = 0; i < V; i++) { for (j = 0; j < V; j++) check[j] = 0; /* clear */ push(i); check[i] = 1; printf("\n %c : ", int2name(i)); while (!stack_empty()) { j = pop(); visit(j); for (t = a[j]; t != NULL; t = t->next) if (check[t->vertex] == 0) { push(t->vertex); check[t->vertex] = 1; } } } }
void test_stack() { stack test; init_stack(&test); node *temp = NULL; temp = top(&test); printf("\n[TOP] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = pop(&test); printf("\n[POP] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = push(&test ,10); printf("\n[PUSH] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = push(&test ,20); printf("\n[PUSH] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = top(&test); printf("\n[TOP] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = pop(&test); printf("\n[POP] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = pop(&test); printf("\n[POP] : %d", (temp != NULL ? temp->start_bar_id : 0)); temp = pop(&test); printf("\n[POP] : %d", (temp != NULL ? temp->start_bar_id : 0)); }
int main(void) { stack_t stack; int item, i; init_stack(&stack); for (i = 0; i < 5; ++i) push(&stack, i); printf("After push, length = %d\n", length(&stack)); pop(&stack, &item); printf("pop top item = %d\n", item); printf("After pop, length = %d\n", length(&stack)); for (i = 0; i < 5; ++i) push(&stack, i + 10); printf("After push, length = %d\n", length(&stack)); while ((pop(&stack, &item)) != -1) printf("item = %d\n", item); printf("After pop, length = %d\n", length(&stack)); return 0; }
int count_components(int a[][MAX_VERTEX], int V) { int count = 0; int i, j; init_stack(); for (i = 0; i < V; i++) check[i] = 0; for (i = 0; i < V; i++) { if (check[i] == 0) { printf("\nConnected Component %d : ", ++count); push(i); check[i] = 1; while (!stack_empty()) { i = pop(); printf("%c ", int2name(i)); for (j = 0; j < V; j++) if (a[i][j] != 0) if (check[j] == 0) { push(j); check[j] = 1; } } } } printf("\nTotally this graph has %d connected components.", count); return count; }
ARCH init_simu(void) { section_t* section_ptr; ARCH arch; arch = (ARCH) calloc(1, sizeof(*arch)); if (arch == NULL) return NULL; /* temporary alloc, mostly useful for tests */ arch->sections[TEXT].start_addr = 0x400; arch->sections[BSS].start_addr = 0xc00; arch->sections[DATA].start_addr = 0x1400; for (int i = 0; i < 3 ; i++) { section_ptr = &(arch->sections[i]); section_ptr->size = 1024; section_ptr->data = (uchar*) calloc((section_ptr->size)*1024, sizeof(uchar)); if (section_ptr->data == NULL) return NULL; } /* let's init the stack section */ init_stack(arch); arch->state = NOT_LOADED; arch->breakpoints = init_list(); return arch; }
void nrDFS_adjmatrix(int a[][MAX_VERTEX], int V) { int i, j; init_stack(); for (i = 0; i < V; i++) check[i] = 0; for (i = 0; i < V; i++) { if (check[i] == 0) { push(i); check[i] = 1; while (!stack_empty()) { i = pop(); visit(i); for (j = 0; j < V; j++) if (a[i][j] != 0) if (check[j] == 0) { push(j); check[j] = 1; } } } } }
void topsort(head net[], int V) { /* function for topological sorting */ int i, j, k; node *ptr; init_stack(); set_count_indegree(net, V); for (i = 0; i < V; i++) if (!net[i].count) /* search start position of topological sort */ push(i); for (i = 0; i < V; i++) { /* if i < V, network has cycle, case of acyclic network loop must be exhausted */ if (stack_empty()) { printf("\nNetwork has a cycle. Sort Terminated ! "); exit(1); } else { j = pop(); printf("%c, ", int2name(j)); for (ptr = net[j].next; ptr; ptr = ptr->next) { k = ptr->vertex; net[k].count--; if (!net[k].count) push(k); } } } }
void proxy_init_all(void) { pj_status_t status; global.port = 5060; global.record_route = 0; pj_log_set_level(5); status = init_stack(); if (status != PJ_SUCCESS) { app_perror("Error initializing stack", status); return; } status = init_proxy(); if (status != PJ_SUCCESS) { app_perror("Error initializing proxy", status); return; } status = init_stateful_proxy(); if (status != PJ_SUCCESS) { app_perror("Error initializing stateful proxy", status); return; } return; }
int main() { Stack s; init_stack(&s); int i = 0; sElemType start = { 0, { 1, 1, } }; sElemType curpos = start; welcome(); printf("\n\n"); print_map(); printf("\n\nI'm going...........................\n\n"); i = walk_maze(&curpos, s); printf("(@_@)\n\n"); print_map(); if(i == 1) printf("\n\nDone!\n\n"); else printf("\n\nI'm missing!\n\n"); return 0; }
void find_max_filling_area(const int *containers, int length, int *start, int *end, int *max_area) { stack fill_stack; node *temp = NULL; init_stack(&fill_stack); int i=0; *max_area = 0; if(length > 0){ temp = push(&fill_stack, containers[0]); for(i=1; i<length; ++i) { if(containers[temp->start_bar_id] <= containers[i]) { /* stack top bar is less than next bar * need to stop filling it * Number of bars (i - temp->start_bar_id + 1) * Max Area (containers[temp->start_bar_id] * #bars) * Push it to stack */ int area = (containers[temp->start_bar_id] * (i - temp->start_bar_id + 1)); if(area > *max_area) { *start = temp->start_bar_id; *end = i; *max_area = (containers[temp->start_bar_id] * (i - temp->start_bar_id + 1)); } temp = pop(&fill_stack); temp = push(&fill_stack, i); } } } }
metalink_stack_t *metalink_stack_new(void) { metalink_stack_t *s = malloc(sizeof(metalink_stack_t)); if (s) { init_stack(s); } return s; }
main(){ unsigned char c,x; int i; FILE *fp; init_stack(); fp = fopen("abc.c","r"); while( (i=fgetc(fp)) !=EOF ){ c= (unsigned char) i; if ( (c == '{') || (c == '(')) push(c); // add code to check for stack errors. if ( c == ')'){ x=pop(); if(x != '('){ printf(" error in file \n"); exit(-1); } } if ( c == '}'){ x=pop(); if(x != '{'){ printf(" error in file \n"); exit(-1); } } } printf(" no error in file \n") ; // is it ??? fclose(fp); }
int main(void){ char c; int i=0, j=0, k=0; PQueue *min = pq_init(); char array[MAX_UNIQUE_CHARS]; char freq[MAX_UNIQUE_CHARS]; char path[MAX_LENGTH]; gets(array); gets(freq); gets(path); int r=0; while(array[r]!=NULL){ Tree *node= tree_init(freq[r]-'0', array[r]); pq_enqueue(min, node, freq[r]-'0'); r+=2; } while(min->size > 1){ Tree *left=pq_dequeue(min); Tree *right=pq_dequeue(min); Tree *node=tree_merge(left, right); pq_enqueue(min, node, node->root->freq); } List *l=init_list(9); Stack *s=init_stack(); l=recursive_Encoding(min->data[0]->root, s, l); read_path(min->data[0]->root, path); }
void quick_sort4(int a[], int n) { /* remove recursion & median & small subfile insert*/ int v, t; int i, j; int l, r; init_stack(); l = 0; r = n-1; push(r); push(l); while (!is_stack_empty()) { l = pop(); r = pop(); if (r-l+1 > 200) /* terminal condition */ { t = (r+l) >> 1; /* t is middle */ if (a[l] > a[t]) /* sort left, middle, right */ { v = a[l]; a[l] = a[t]; a[t] = v; } if (a[l] > a[r]) { v = a[l]; a[l] = a[r]; a[r] = v; } if (a[t] > a[r]) { v = a[t]; a[t] = a[r]; a[r] = v; } v = a[t]; /* exchange middle with a[r-1] */ a[t] = a[r-1]; a[r-1] = v; i = l; /* partition l+1 to r-2 */ j = r-1; while (1) /* partition */ { while (a[++i] < v); while (a[--j] > v); if (i >= j) break; t = a[i]; a[i] = a[j]; a[j] = t; } t = a[i]; a[i] = a[r-1]; a[r-1] = t; push(r); push(i+1); push(i-1); push(l); } else
task_t *task_create( const char *name, void (*entry)(void *parameter), void *parameter, u16int stackSize, u8int priority, u16int tick){ task_t *task; u32int *stackAddr; u32int task_id; task_id = get_task_id(); if( task_id < 0 ){ return NULL; } task = (task_t *)kmalloc(sizeof(task_t)); if(task == NULL) return NULL; stackAddr = (void *)kmalloc(stackSize); if( stackAddr == NULL ){ kfree(task); return NULL; } for( int temp=0; temp<NAME_MAXLENTH; temp++ ){ task->name[temp] = name[temp]; } task->task_id = task_id; task->entry = (void *)entry; task->parameter = parameter; task->stack_addr = stackAddr; task->stack_size = stackSize; task->node.next = NULL; task->node.prev = NULL; task->init_tick = tick; task->remaining_tick = tick; task->priority = priority; task->sp = (void *)( (void *)stackAddr + stackSize -4 ); memset( (u8int *)task->stack_addr, '?', task->stack_size ); task->sp = (void *)init_stack(task->sp, task->entry, task->parameter); task_table[task->task_id] = 1; task->timer = timer_create(task->name, task_timeout, task, 0, SET_ONESHOT); return task; }
/********************************************************************** * FUNCTION NAME: * save_file * * DESCRIPTION: * This function save the RAM tree info to the given file * * INTERFACE: * GLOBAL DATA: * None * * INPUT: * file_name-- given file name * root --root of the tree * * OUTPUT: * None * * INPUT/OUTPUT: * None * * AUTHOR: * Fu Pei * * RETURN VALUE: * * if save file failed return the error type otherwise return PROCESS_SUCCESS * * * NOTES: * *********************************************************************/ int save_file(char *file_name,node_t* root) { int ret = PROCESS_SUCCESS; FILE* file; stack_t stk; node_t *child = NULL; node_t* nd = NULL; if (file_name) { file = fopen( file_name, "w" ); } /*file open failed*/ if ((NULL == file) ||(NULL == root) ) { ret = FILE_WRITE_ERROR; } if (ret >= 0) { /*print head of xml*/ print_declaration(file,root); /*create stack*/ init_stack(&stk); /*push all children of the node to stack*/ child = root->child; while(child) { /*push data to stack*/ push(&stk,child); child = child->sibl; } /*is stack empty*/ while (!stack_empty(&stk)) { node_t* nd_child = NULL; int nd_chld_index = 0; /*get node from the stack*/ pop(&stk,&nd); /*write node to xml file*/ write_node_begin(file,nd); /*last leaf node of the tree with nd as its root*/ write_node_end(file,nd,&stk); /*does nd node have child*/ nd_child = nd->child; /*push all nd_child to stack*/ while (nd_child) { push(&stk,nd_child); nd_child = nd_child->sibl; }/*end while*/ }/*end while*/ fclose(file); } return ret; }
void* do_operations(void* thread_index_void_ptr) { int* thread_index_ptr = (int*)thread_index_void_ptr; // Get my thread info int num_elements_to_spawn = thread_info_array[*thread_index_ptr].num_elements_to_spawn; char* operation_array = thread_info_array[*thread_index_ptr].operation_array; // Create a stack STACK stack; init_stack(&stack); // Spawn elements int i; for (i = 0; i < num_elements_to_spawn; ++i) { // Create an element and push it ELEMENT* element = (ELEMENT*)malloc(sizeof(ELEMENT)); element->value = i; push(&stack, element); } // Do operations for (i = 0; i < NUM_OPERATIONS; ++i) { if (ADD == operation_array[i]) { // Enqueue an element ELEMENT* element = pop(&stack); if (USE_BLOCKING == mode) { add_blocking_queue(&blocking_queue, element); } else { while (!add_nonblocking_queue(&nonblocking_queue, element)); } } else { // Dequeue an element ELEMENT* element = NULL; if (USE_BLOCKING == mode) { element = remove_blocking_queue(&blocking_queue); } else { while (!(element = remove_nonblocking_queue(&nonblocking_queue))); } push(&stack, element); } } return NULL; }