SearchTree make_empty(SearchTree T) { if (T != NULL) { make_empty(T->left); make_empty(T->right); free(T); } return NULL; }
Tree *make_empty(Tree *t) { if (t != NULL) { make_empty(t->left); make_empty(t->right); free(t); } return NULL; }
static void make_empty(T tree, Node * node) { if (node == NIL(tree)) return; make_empty(tree, node->left); make_empty(tree, node->right); free(node); }
tree_node_t *make_empty(tree_node_t *tree) { if (NULL != tree) { make_empty(tree->left); make_empty(tree->right); free(tree); } return NULL; }
int main(void) { Stack st1, st2; int st_size = 10; // Imposta l'ampiezza massima di entrambi gli stack a 10 st1 = create(st_size); st2 = create(st_size); // Riempie entrambi gli stack for (int i=0; i<st_size; i++) { push(st1, i+i); push(st2, i*i); } destroy(st1); while (!is_empty(st2)) printf("popped %d from st2 Stack\n", pop(st2)); make_empty(st2); printf("popped %d from st2 Stack\n", pop(st2)); push(st2, 100); if (is_empty(st2)) fputs("st2 is empty\n", stdout); else fputs("st2 is not empty\n", stdout); destroy(st2); return(EXIT_SUCCESS); }
int main(void) { Stack s1, s2; void *n; s1 = create(); s2 = create(); push(s1, "\"first\""); push(s1, "\"second\""); n = pop(s1); printf("Popped %s from s1\n", n); push(s2, n); n = pop(s1); printf("Popped %s from s1\n", n); push(s2, n); destroy(s1); while (!is_empty(s2)) printf("Popped %s from s2\n", pop(s2)); push(s2, "\"third\""); make_empty(s2); if(is_empty(s2)) printf("s2 is empty\n"); else printf("s2 is not empty\n"); destroy(s2); return 0; }
int main(void) { Stack s1, s2; int n; s1 = create(); s2 = create(); push(s1, 1); push(s1, 2); printf("Peeked at %d from s1\n", peek(s1)); n = pop(s1); printf("Popped %d from s1\n", n); push(s2, n); n = pop(s1); printf("Popped %d from s1\n", n); push(s2, n); destroy(s1); while (!is_empty(s2)) printf("Popped %d from s2\n", pop(s2)); push(s2, 3); make_empty(s2); if (is_empty(s2)) printf("s2 is empty\n"); else printf("s2 is not empty\n"); destroy(s2); return 0; }
int main(int argc, char * argv[]) { int n = atoi(argv[1]); int m = atoi(argv[2]); int i = 0; List L = make_empty(); L->next = L; position p = L; for (i = 1; i <= n; i++ ) { p->next = (position)malloc(sizeof(Node)); p->next->element = i; p = p->next; p->next = L; } p->next = p->next->next; position prev = p; p = L->next; while (p->next != p) { for (i = 0; i < m; i++) { p = p->next; prev = prev->next; } printf("%d\n", p->element); prev->next = p->next; p = prev->next; } printf("%d\n", p->element); return 0; }
int main(void) { char ch; printf("Enter parentheses and/or braces: "); make_empty(); while (nested && !is_full()) { ch = getchar(); if (ch == '(' || ch == '{') push(ch); else if (ch == ')') { if (pop() != '(') nested = false; } else if (ch == '}') { if (pop() != '{') nested = false; } else if (ch == '\n') { if (!is_empty) nested = false; break; } } if (nested) printf("Parenteses/braces are nested properly\n"); else printf("Parenteses/braces are not nestes properly\n"); return 0; }
stack_t *create_stack(int esz, int nr) { stack_t *s; if (nr < MIN_STACK_SZ) { printf("error: stack size too small!\n"); return NULL; } s = malloc(sizeof(stack_t)); if (!s) { printf("out of memory!\n"); return NULL; } s->array = malloc(esz * nr); if (!s->array) { printf("out of array memory!\n"); return NULL; } s->cap = nr; s->esz = esz; make_empty(s); return s; }
int main() { struct node *head; int pos,choice,data; head=(struct node*) malloc(sizeof(struct node)); head=NULL; do { printf("\n1.Create\n2.Insert\n3.Delete\n4.Locate\n5.Retrieve\n6.Display\n7.Make empty\n8.Exit"); printf("\n Enter choice : "); scanf("%d",&choice); switch(choice) { case 1: head=create(head);break; case 2: { printf("\n1.Beginning\n2.End\n3.Middle\nEnter choice :"); scanf("%d",&choice); switch(choice) { case 1: head=insert(head,1);break; case 2: head=insert(head,0);break; case 3: printf("\nEnter the position to be inserted : "); scanf("%d",&pos); head=insert(head,pos); break; } }break; case 3: { printf("\nEnter the position to be deleted : "); scanf("%d",&pos); head=del(head,pos); }break; case 4: { printf("\nEnter the data to be located : "); scanf("%d",&data); pos=locate(head,data); if(pos==0)printf("\nData not found\n"); else printf("\nData found at position %d\n",pos); }break; case 5: { struct node *temp; temp=(struct node*) malloc(sizeof(struct node)); printf("\nEnter the position to be retrieved : "); scanf("%d",&pos); temp=retrieve(head,pos); if(temp->data==-1)printf("\nData not found\n"); else printf("\nData found at position %d is %d\n",pos,temp->data); }break; case 6: display(head);break; case 7: head=make_empty(head);break; case 8: return 0; } }while(5); getch(); }
/* * tree_free -- * Free all the nodes of the tree. */ void tree_free(T * tree) { assert(tree); if (*tree == NULL) return; make_empty(*tree, (*tree)->root); free(*tree); *tree = NULL; }
int main(void){ char expn[STACK_SIZE + 1]; make_empty(); for (;;){ if (is_empty()){ printf ("Enter an RPN expression: "); gets(expn); printf ("Value of expression: %d\n", evaluate_RPN_expression(expn)); make_empty(); continue; } } return 0; }
int main(void) { List L = (position)malloc(sizeof(struct Node)); L = make_empty(L); insert_node(1, L, L); insert_node(2, L, L); insert_node(3, L, L); insert_node(4, L, L); print_list(L); return 0; }
void stmt(Token *tk) {// statement make_empty(); if (tk->id == If) if_node(tk); else if (tk->id == While) while_node(tk); else if (tk->id == For) for_node(tk); else if (tk->id == Int) int_node(tk); else if (tk->id == Ret) return_node(tk); else if (tk->id == Prtf) printf_node(tk); else if (tk->id == Stru) struct_dec(tk); else if (tk->id == ';') next(tk); else if (tk->id == '}') return ; else { expr(tk); assembly(pop()); } }
int main(void){ char ch; int op1, op2; make_empty(); for (;;){ if (is_empty()){ printf ("Enter an RPN expression: "); } scanf (" %c", &ch); /* printf ("ch: %c\n", ch);*/ if (ch >= '0' && ch <= '9'){ push(ch - '0'); }else if (ch == '+' || ch == '-' || ch == '*' || ch == '/'){ op2 = pop(); op1 = pop(); /* printf ("op1: %d\n", op1);*/ /* printf ("op2: %d\n", op2); */ switch (ch){ case '+': push(op1 + op2); break; case '-': push(op1 - op2); break; case '*': push(op1 * op2); break; case '/': push(op1 / op2); break; } }else if (ch == '='){ printf ("Value of expression: %d\n", pop()); make_empty(); continue; }else{ exit (EXIT_SUCCESS); } } }
int main(void) { int c, i, j, tmp, isbalanced; do { j = 0; printf("Enter your input that contains parenthesis or Q to quit:\n"); while ((c = getchar()) != '\n') { j++; tmp = c; if(c == '(' || c == '<' || c == '[' || c == '{') { push(c); } if(c == ')' || c == '>' || c == ']' || c == '}') { if(c == ')' && pop() == '(') { continue; } else if(c == '>' && pop() == '<') { continue; } else if(c == ']' && pop() == '[') { continue; } else if(c == '}' && pop() == '{') { continue; } else { top++; isbalanced = 0; } } } if(tmp == 'Q' && j ==1) return 0; if(top == 0) isbalanced = 1; else isbalanced = 0; if(isbalanced == 1) printf("The input is balanced.\n"); else printf("The input is not balanced.\n"); make_empty(); } while (i >= 0); return 0; }
stack_t * create_stack(int size) { stack_t *s; if (size < MinStackSize) error(); s = malloc(sizeof(stack_t)); s->array = malloc(sizeof(int) * size); s->capacity = size; make_empty(s); return s; }
int main(void) { Stack s1, s2; int n; s1 = create(); s2 = create(); push(s1, 1); printf("Length of s1: %d\n", length(s1)); push(s1, 2); printf("Length of s1: %d\n", length(s1)); n = pop(s1); printf("Popped %d from s1\n", n); printf("Length of s1: %d\n", length(s1)); push(s2, n); printf("Length of s2: %d\n", length(s2)); n = pop(s1); printf("Popped %d from s1\n", n); printf("Length of s1: %d\n", length(s1)); push(s2, n); printf("Length of s2: %d\n", length(s2)); destroy(s1); while (!is_empty(s2)) { printf("Popped %d from s2\n", pop(s2)); printf("Length of s2: %d\n", length(s2)); } push(s2, 3); printf("Length of s2: %d\n", length(s2)); make_empty(s2); if (is_empty(s2)) { printf("s2 is empty\n"); } else { printf("s2 is not empty\n"); } destroy(s2); return 0; }
Map<S,T>& Map<S,T>::operator= (const Map<S,T>& m) { if (this != &m) { make_empty(); for (Mapiter<S,T> p (m); ++p; ) { // S s = p.key(); /* sidestep a cfront bug */ // (*this) [s] = p.value(); (*this) [p.key()] = p.value(); } // iter_head=0; // mi_count = 0; /* march through the iterator list, setting each to vacuous */ for (Mapiter<S,T> *ip = iter_head; ip; ip = ip->iter_next) { /* ip->m = this; */ /* unnecessary */ ip->p = 0; } remove_flag = 0; } return *this; }
void input(void) { int ch; printf("Enter an RPN expression: "); while (true) { ch = getchar(); if (ch == '*' || ch == '/' || ch == '+' || ch == '-') { calculate(ch); } else if (ch == '=') { display(); } else if (ch == ' ') { continue; } else if (ch == 'q') { make_empty(); } else if (ch == '\n') { break; } else { ch -= 48; push(ch); } } }
void syntax(Token *tk) {// syntax analyzer char *fun_name; int fun_pos; Func *fun = (Func *)malloc(sizeof(Func)); while (tk->id) { make_empty(); if (tk->id == Void || tk->id == Int) { fun->ret = tk->id; next(tk); if (tk->id == Id) { adjust_ebp(); if (lookup(tk->beg, Fun, tk->line, false) < 0) { fun_pos = fun_insert(tk->beg); fun_name = (char *)malloc((strlen(tk->beg) + 1) * sizeof(char)); strcpy(fun_name, tk->beg); } else PANIC("function redefinition", tk->line); } else PANIC("missing function name", tk->line); } else if (tk->id == Stru) { struct_def(tk); } else if (tk->id == '(') { ent(); fun->argc = 0; argument_dec(tk, fun); if (tk->id == ')') fun_info_insert(fun_name, fun_pos, fun); else PANIC("illegal function declaration", tk->line); } else if (tk->id == '{') { next(tk); if (tk->id == '}') PANIC("expected statement", tk->line); while (tk->id != '}' && tk->id) { stmt(tk); next(tk); } lev(); if (!tk->id) PANIC("expected right brace", tk->line); } next(tk); } }
void calculate(int operator) { int operand2 = pop(); int operand1 = pop(); switch ((char)operator) { case '+': push(operand1 + operand2); break; case '-': push(operand1 - operand2); break; case '*': push(operand1 * operand2); break; case '/': if (operand2 != 0) { push(operand1 / operand2); } break; default: printf("Bad operator!\n"); make_empty(); } }
void destroy(Stack s) { make_empty(s); free(s); }
Winner::~Winner( ){ make_empty(); }
void destroy(Queue q) { make_empty(q); free(q); }
HStore * adeven_count_text_array( Datum* i_data, int n, bool * nulls ) { adeven_count_Array a; adeven_count_init_array( &a, 100 ); AvlTree tree = make_empty( NULL ); int i, j; for( i = 0; i < n; ++i ) { if( ! nulls[i] ) { bool found = false; size_t datum_len = VARSIZE( i_data[i] ) - VARHDRSZ; char * current_datum = ( char * ) palloc ( datum_len ); memcpy( current_datum, VARDATA( i_data[i] ), datum_len ); Position position = find( current_datum, datum_len, tree ); if( position == NULL ) { j = a.used; tree = insert( current_datum, datum_len, j, tree ); adeven_count_insert_array( &a, current_datum, datum_len ); } else { j = value( position ); } a.counts[j] += 1; } } // save sort permutation to create pairs in order of ascending keys // we assume that postgres stores the pairs in that order int * perm = ( int * ) palloc ( a.used * sizeof( int ) ); sort_perm( tree, perm ); make_empty( tree ); Pairs * pairs = palloc0( a.used * sizeof( Pairs ) ); int4 buflen = 0; for( i = 0; i < a.used; ++i ) { j = perm[i]; if( a.array[j] != NULL ) { size_t datum_len = a.sizes[j]; int digit_num = adeven_count_get_digit_num( a.counts[j] ); char * dig_str = palloc0(digit_num); sprintf( dig_str, "%d", a.counts[j] ); a.counts_str[j] = dig_str; pairs[i].key = a.array[j]; pairs[i].keylen = datum_len; pairs[i].val = dig_str; pairs[i].vallen = digit_num; pairs[i].isnull = false; pairs[i].needfree = false; buflen += pairs[i].keylen; buflen += pairs[i].vallen; } } HStore * out; out = hstorePairs( pairs, a.used, buflen ); //adeven_count_free_array( &a ); return out; }
/****************************************************************** * * aa_to_codon(sfp, aa_start, aa_stop) * generate a list of CodonVecotr to show the codons of an * amino acid sequence * sfp: the Seq-feat for cds * aa_start: the start position of protein sequence * aa_stop the stop position of protein sequence * ******************************************************************/ NLM_EXTERN ValNodePtr aa_to_codon(SeqFeatPtr sfp, Int4 aa_start, Int4 aa_stop) { BioseqPtr bsp; Int4 frame_offset, start_offset; SeqLocPtr slp = NULL; SeqLocPtr cdloc; CdRegionPtr crp; Uint1 frame; Boolean is_end; /**is the end for process reached?**/ Int4 p_start=0, p_stop=0; /**protein start & stop in defined corresponding CdRegion Seq-loc**/ Int4 line_len; Int4 cur_pos; /**current protein position in process**/ Int4 cd_len; /**length of the cDNA for the coding region**/ Int2 i, j; Int2 k, n; CharPtr PNTR buf; Boolean is_new; /**Is cur_pos at the begin of new Seq-loc?**/ CharPtr temp; SeqPortPtr spp; Uint1 residue; Boolean end_partial; Int4 d_start, seq_pos; Int2 pos; ValNodePtr head= NULL; CodonVectorPtr cvp; Boolean prt_stop_codon; Uint2 exon; if(sfp->data.choice !=3) return NULL; crp = sfp->data.value.ptrvalue; if(!crp) return NULL; frame = crp->frame; cdloc = sfp->location; if(cdloc == NULL ) return NULL; if(frame>0) frame_offset = frame-1; else frame_offset = 0; start_offset = frame_offset; prt_stop_codon = (aa_stop == SeqLocStop(sfp->product)); line_len = (aa_stop - aa_start + 1) + 1; /* +1 for the possible partial start codon*/ if(prt_stop_codon)/*can be either as a stop codon or partial stop*/ ++line_len; buf = MemNew((size_t)3 * sizeof(CharPtr)); for(i =0; i<3; ++i) buf[i] = MemNew((size_t)(line_len + 1) * sizeof (Char)); cur_pos= aa_start; cd_len = 0; is_end = FALSE; p_start = 0; slp = NULL; exon = 0; while(!is_end && ((slp = SeqLocFindNext(cdloc, slp))!=NULL)) { ++exon; cd_len += SeqLocLen(slp); end_partial = ((cd_len - start_offset)%3 != 0); p_stop = (cd_len - start_offset)/3 -1; if(end_partial) ++p_stop; if(p_stop > aa_stop || (p_stop == aa_stop && !end_partial)) { p_stop = aa_stop; /**check if the end is reached**/ is_end = TRUE; } if(p_stop >= cur_pos) /*get the exon*/ { bsp = BioseqLockById(SeqLocId(slp)); if(bsp) { is_new = (p_start == cur_pos); /*start a new exon?*/ cvp = MemNew(sizeof(CodonVector)); cvp->sip = SeqIdDup(find_sip(bsp->id)); cvp->strand = SeqLocStrand(slp); cvp->exonCount = exon; if(is_new) { if(frame_offset == 0) cvp->frame = 0; else cvp->frame = 3- (Uint1)frame_offset; } else cvp->frame = 0; if(cur_pos==0 && frame_offset > 0) /*partial start codon*/ cvp->aa_index = 0; else cvp->aa_index = 1; if(is_new) /**special case of the first partial**/ d_start = SeqLocStart(slp); else { if(frame_offset && p_start >0) ++p_start; d_start = SeqLocStart(slp) + 3*(cur_pos - p_start) + frame_offset; } /**p_start is the start position of aa in the current Seq-loc cur_pos is the current aa that is in process. The offset will help to located the position on the DNA Seq-loc for translation d_start is the position of the starting DNA in the coordinates of DNA segment, used for mark the sequence **/ seq_pos = d_start - SeqLocStart(slp); /**the pos in spp**/ if(SeqLocStrand(slp)== Seq_strand_minus) d_start = SeqLocStop(slp) - seq_pos; cvp->dna_pos = d_start; n = (Int2)cur_pos - (Int2)aa_start + cvp->aa_index; /*position in buffer*/ for(i =0; i<3; ++i) make_empty(buf[i], (Int2)line_len); spp = SeqPortNewByLoc(slp, Seq_code_iupacna); SeqPortSeek(spp, seq_pos, SEEK_SET); /**store the partial codons**/ if(is_new && frame_offset > 0) { k = (Int2)frame_offset; while(k > 0) { residue = SeqPortGetResidue(spp); temp = buf[3-k]; /**the position**/ pos = n; temp[pos] = TO_LOWER(residue); --k; } ++n; if(cur_pos!=0) ++cur_pos; } /**load the codons**/ k =0; while((residue = SeqPortGetResidue(spp)) != SEQPORT_EOF && cur_pos <= p_stop) { j= (Uint1)k%3; temp = buf[j]; temp[n] = TO_LOWER(residue); if(j ==2) { /**the last base**/ ++n; if(!prt_stop_codon|| !is_end) /*for the last codon*/ /**prt_end controls to print the whole loc**/ ++cur_pos; } ++k; } /**end of while**/ SeqPortFree(spp); for(i =0; i<3; ++i) cvp->buf[i] = StringSave(buf[i]); ValNodeAddPointer(&head, 0, (Pointer)cvp); BioseqUnlock(bsp); }/*end of if(bsp)*/ }/**end of if for matched intervals**/ if(end_partial) p_start = p_stop; else p_start = p_stop +1; frame_offset = (cd_len - start_offset)%3; if(frame_offset >0) frame_offset = 3-frame_offset; }/**end of while(slp && !is_end) **/ for(i=0; i<3; ++i) MemFree(buf[i]); MemFree(buf); return head; }
void stack_overflow(void) { printf("Expression is too complex!\n"); make_empty(); }
void stack_underflow(void) { printf("Not enough operands in expression!\n"); make_empty(); }