static void delnode(link_t root, item_t key) { if (root == NULL) { return; } if (root->left) { if (internal_node(root->left)) { delnode(root->left, key); } else if (external_node(root->left) && root->left->item == key) { dellink(&root->left); } } if (root->right) { if (internal_node(root->right)) { delnode(root->right, key); } else if (external_node(root->right) && root->right->item == key) { dellink(&root->right); } } if (external_node(root) && root->item == key) { dellink(&root); } }
/* The input function for a log buffer. */ static int ms_buffer_input (void *closure, char *data, size_t need, size_t size, size_t *got) { struct ms_buffer *mb = closure; int status; assert (mb->cur->input); status = (*mb->cur->input) (mb->cur->closure, data, need, size, got); if (status == -1) { Node *p; /* EOF. Set up the next buffer in line but return success and no * data since our caller may have selected on the target to find * ready data before calling us. * * If there are no more buffers, return EOF. */ if (list_isempty (mb->bufs)) return -1; buf_shutdown (mb->cur); buf_free (mb->cur); p = mb->bufs->list->next; mb->cur = p->data; p->delproc = NULL; p->data = NULL; delnode (p); if (!buf_empty_p (mb->cur)) buf_append_buffer (mb->buf, mb->cur); ms_buffer_block (closure, mb->block); *got = 0; status = 0; } return status; }
void maintainlist(int b){ int t; while(b!=-1 && (t=next[b])!=-1 && bcount[b] + bcount[t] < BLOCKSIZE){ memcpy(data[b]+bcount[b], data[t], bcount[t]*sizeof(int)); bcount[b]+=bcount[t]; next[b]=next[t]; delnode(t); } }
void maintainlist(int b){ for(; b!=-1; b=next[b]) for(int t=next[b]; t!=-1 && count[b] + count[t] <= BLOCKSIZE; t=next[b]){ memcpy(data[b]+count[b], data[t], count[t]*sizeof(int)); count[b]+=count[t]; next[b]=next[t]; delnode(t); } }
void deltree(Node *np) { if (!np) return; deltree(np->left); deltree(np->right); delnode(np); }
int stack_pop(T t) { int reval; L tmp; assert(!stack_empty(t)); reval = t->head->entry; tmp = t->head; t->head = tmp->next; delnode(tmp); return reval; }
void stack_finalize(T t) { L tmp; while ((tmp = t->head) != NULL) { t->head = tmp->next; delnode(tmp); } free(t); }
int erase(int p,int n){ int b,e; find(p,b); splite(b,p); for(e=next[b]; e!=-1 && n > count[e]; e=next[e])n -= count[e]; if(n){splite(e,n);e=next[e];} for(int t=next[b]; t!=e; t=next[b]){ next[b]=next[t]; delnode(t); } maintainlist(b); }
void xoatrung(LIST &l) { NODE *p=l.pHead; NODE *q; while (p) { q=timtrung(p->pNext,p->info); while (q) { delnode(l,q); q=timtrung(p->pNext,p->info); } p=p->pNext; } }
void maintainlist(int b){ for(; b!=-1; b=next[b]) for(int t=next[b]; t!=-1 && count[b]+count[t]<=BLOCKSIZE; t=next[b]){ if( !(same[b] && same[t] && samevalue[b]==samevalue[t]) ){ reverseblock(b); reverseblock(t); if(same[b])for(int i=count[b]-1; i>=0; --i)data[b][i]=samevalue[b]; same[b]=false; int cb=count[b],*str=data[b]; if(same[t])for(int i=count[t]-1,sv=samevalue[t];i>=0;--i)str[cb+i]=sv; else for(int i=count[t]-1,*a=data[t];i>=0;--i)str[cb+i]=a[i]; } count[b]+=count[t]; next[b]=next[t]; delnode(t); maintainblock(b); } }
static void * do_shift (List *stack, int isstring) { void *elem; if (isempty (stack)) return NULL; if (isstring) { elem = stack->list->next->key; stack->list->next->key = NULL; } else { elem = stack->list->next->data; stack->list->next->data = NULL; } delnode (stack->list->next); return elem; }
static uint64_t flush_node (FILE *fp, int features, struct memnode *mp, uint64_t *cntp) { uint64_t curpos, refpos, pos, cnt, tcnt; struct memnode *tp; if (mp == NULL) return 0; tp = mp; while (tp) { if (tp->child) { tp->childpos = flush_node (fp, features, tp->child, &(tp->subcnt)); tp->child = NULL; } tp = tp->sib; } curpos = ftell64 (fp); pos = curpos; refpos = pos; cnt = 0; while (mp) { tcnt = mp->subcnt; if (mp->end) tcnt++; trie_node_write (fp, features, &refpos, &pos, tcnt, mp->len, mp->end, mp->childpos, mp->dat); cnt += tcnt; tp = mp; mp = mp->sib; delnode (tp); } trie_node_write (fp, features, NULL, NULL, 0, 0, 0, 0, NULL); *cntp = cnt; return curpos; }
void btree_del_node(T t, item_t key) { delnode(t->root, key); }
int main() { int i; Head=NULL; while(1) { printf(" \nInsert a number \n1. At Beginning"); printf(" \n2. At End"); printf(" \n3. At a Particular Location in List"); printf(" \n\n4. Print the Elements in the List"); printf(" \n5. Print number of elements in the List"); printf(" \n6. Delete a Node in the List"); printf(" \n7. Reverse the linked List"); printf(" \n8. Exit"); printf(" \n\nChoose Option: "); scanf("%d",&i); switch(i) { case 1: { int num; printf(" \nEnter the Number to insert: "); scanf("%d",&num); addbeg(num); break; } case 2: { int num; printf(" \nEnter the Number to insert: "); scanf("%d",&num); append(num); break; } case 3: { int num, loc, k; printf("\nEnter the Number to insert: "); scanf("%d",&num); printf("\nEnter the location Number: "); scanf("%d",&loc); addafter(num,loc); break; } case 4: { printf(" \nElements in the List: "); display(); break; } case 5: { display(); printf(" \nTotal number of Elements in the List: %d",count()); break; } case 6: { int num; printf(" \nEnter the number to be deleted from List: "); scanf("%d",&num); delnode(num); break; } case 7: { reverse(); display(); break; } case 8: { struct node *temp; while( Head!=NULL) { temp = Head->next; free(Head); Head=temp; } exit(0); } default: { printf("\nWrong Option choosen"); } }/* end if switch */ }/* end of while */ }/* end of main */
void main ( int argc, char **argv ) { long i,a; char found = 0; char *nome_campo; FILE *fp; if (argc == 3) { // printf("Usage: ./insert_into <tablename> <FieldX> <ValueX>\n"); printf("OR\n"); printf("Usage: ./insert_into <tablename>\n"); return; } table *tmpTable; read_header(argv[1],&tmpTable); if (argc == 2) { // printf("[TABLE: %s; numFields: %i]\n",tmpTable->name, tmpTable->numFields); for (i=0;i<tmpTable->numFields;i++) { printf("[FIELD: %s; fieldSize: %i]\n",(tmpTable->fields[i]).name, (tmpTable->fields[i]).fieldSize); } free(tmpTable); return; } table_row *row; if (hasIndex(tmpTable,argv[2])) { printf("[FIELD: %s IS INDEXED!]\n",argv[2]); rdstart(); i = search(argv[3]); fclose(fptree); } else { i = 0; } if (i == -1) { printf("Nenhum registro encontrado!\n"); } for (;i>-1;i++) { row = get_row(tmpTable,i); if (row == NULL) { if (found == 0) { printf("Nenhum registro encontrado!\n"); } break; } if (strcmp(get_row_field(tmpTable,row,argv[2]),argv[3]) == 0) { found = 1; delete_row(tmpTable,i); for (a=0;a<tmpTable->numFields;a++) { if (hasIndex(tmpTable,(tmpTable->fields[a]).name)) { rdstart(); delnode(get_row_field(tmpTable,row,(tmpTable->fields[a]).name)); printtree(root); wrstart(); fclose(fptree); } } free(row); break; } free(row); } free(tmpTable); return; }
/* * This addline version assumes sorted input. This means that whenever * a split occurs all subtrees can be flushed. */ static void addline_trie (FILE *fp, int features, struct memnode **mpp, unsigned char *dat, int len) { /* Previous sib. Points to the last sib */ /* visited, or NULL is this is the first*/ /* sib in the node. */ struct memnode *prvsibp = NULL; while (len && dat[len-1] == '\n') len--; if (!len) return; for (;;) { int l1, l2, ct; unsigned char *d1, *d2; struct memnode *mp, *n1, *n2; mp = *mpp; /* In case of an empty trie: build one */ if (mp == NULL) { mp = newnode (dat, len); mp->end = 1; *mpp = mp; /* As the input is sorted, we won't*/ /* change the older sibs! So flush */ /* and forget prvsibp's subtrie */ if (prvsibp) { prvsibp->childpos = flush_node (fp, features, prvsibp->child, &(prvsibp->subcnt)); prvsibp->child = NULL; fflush (fp); } return; } /* Move to the next sib if appropriate */ if (len && dat[0] > mp->dat[0]) { prvsibp = mp; mpp = &(mp->sib); continue; } /* Introduce a new sib if appropriate */ if (len && dat[0] < mp->dat[0]) { abort_error (); } /* We found the right sib */ ct = 0; d1 = dat; l1 = len; d2 = mp->dat; l2 = mp->len; /* At what pos do the sib and the new */ /* value differ */ while (l1 && l2 && *d1 == *d2) { ct++; d1++; l1--; d2++; l2--; } if (!l2) { /* No sib string data left */ if (!l1) { /* No input string left as well*/ /* So we have a match! */ if (mp->child || mp->childpos) { abort_error (); } mp->end = 1; return; } /* Some input string data is left */ /* so the string is a child of sib */ /* Continue there */ mpp = &(mp->child); dat = d1; len = l1; prvsibp = NULL; continue; } /* There's unmatched sib string data */ /* left, so split the node */ if (!l1) { abort_error (); } /* New node n2 is the non matching tail*/ /* of mp */ n2 = newnode (d2, l2); n2->child = mp->child; n2->end = mp->end; /* New node n1 replaces mp, which has */ /* The prefix length ct of mp */ n1 = newnode (mp->dat, ct); n1->sib = mp->sib; n1->child = n2; *mpp = n1; /* mp is obsolete now */ delnode (mp); /* If there's no input string data left*/ /* Then the mp replacement n1 is an */ /* endpoint! */ if (!l1) { n1->end = 1; return; }; /* Now move on to the child, where the */ /* remainder of the input string will */ /* reside */ mpp = &(n1->child); dat = d1; len = l1; prvsibp = NULL; } }
/** * Delete a property from the given prop set, with the given property * name. It removes it from the AVL of 'list'. Does not save it to * the database right away. * * @param list Pointer to a PropPtr which is (usually) the root of the * property AVL tree. * @param name The name of the property to delete * @return Returns the pointer that 'list' is pointing to. Because 'list' * is modified, there is probably no reason to use the return * value. */ PropPtr delete_prop(PropPtr * list, char *name) { *list = delnode(name, *list); return (*list); }
int main(){ struct node *head = NULL; int n; char ch, fakech, quit = 1; do{ printf("\n"); printf("1 - Insert\n"); printf("2 - Display\n"); printf("3 - Find\n"); printf("4 - Delete\n"); printf("5 - Delete All\n"); printf("0 - Quit\n"); printf("\n"); printf("Enter choice: "); scanf("%c", &ch); scanf("%c", &fakech); switch(ch){ case '1': printf("Insert Element: "); scanf("%d", &n); scanf("%c", &fakech); printf("Add front or back?(f/b): "); scanf("%c", &ch); scanf("%c", &fakech); if(ch == 'f'){ head = addfront(head, n); } else{ head = addback(head, n); } break; case '2': display(head); break; case '3': printf("Find: "); scanf("%d", &n); scanf("%c", &fakech); printf("Result: %p\n", find(head, n)); break; case '4': printf("Delete: "); scanf("%d", &n); scanf("%c", &fakech); struct node *p; if((p = find(head, n)) != NULL){ head = delnode(head, p); } else{ printf("Not found in the list!\n"); } break; case '5': freelist(head); head = NULL; break; case '0': quit = 0; break; } } while(quit); return 0; }
void main() { int ch=0,ans=0; int val=0; char str[15]; struct node *new1,*new2; clrscr(); /* initialization of list with the existing records */ fp=fopen("phone.txt","r"); if(fp==NULL) { printf("File cant be opened !"); getch(); exit(1); } while(!feof(fp)) { new1=getrecord(); if(insert(new1)==-1) printf("Cant insert record ! Error..."); else printf("Record entered..."); } getch(); fclose(fp); do { clrscr(); printf("Menu"); printf("1. Add a New phone record."); printf("2. Delete an existing Record."); printf("3. show all Records."); printf("4. Modify a particular Record."); printf("5. Exit."); printf("Enter your choice--->"); scanf("%d",&ch); switch(ch) { case 1: new1 = getnode(); val = insert(new1); if(val==-1) printf("Employee id already exists ! try again..."); else printf("Employee details successfully stored"); break; case 2: printf("Enter the phone no.you wish to delete--->"); scanf("%d",&val); ans=delnode(val); if(ans==-1) printf("Record doesnt exist ! Try again..."); if(ans==0) printf("Record deleted !"); break; case 3: display(); break; case 4: printf("Search by phone no. or Name ? (1/2)--->"); scanf("%d",&ch); if(ch==1) { printf("Enter the phone no. you wish to search for--->"); scanf("%d",&val); new2=query(val,&str,1); } else { printf("Enter the name of the person you wish to search for--->"); scanf("%s",&str); new2=query(val,&str,0); } if(new2) { printf("Enter the New name of the person--->"); scanf("%s",&new2->name); printf("Enter new phone no. of the person--->"); scanf("%d",&new2->num); printf("Record modified successfully !"); } break; case 5: printf("Leaving Database,writing back to file..."); CopyToFile(); getch(); free(list); exit(1); break; } getch(); } while(1); }