int set_remove(Set *set, void **data) { ListElmt *member, *prev_to_member; /* * Find member to remove */ /* Start at the head of the list. * Note prev_to_member is NULL as it should be for member = HEAD */ member = list_head(set); prev_to_member = NULL; for ( ; member != NULL; member = list_next(member)) { /* Logic is a little delicate here. When we break, * prev_to_member will be correct. */ if (set->match(*data, list_data(member))) break; prev_to_member = member; } /* * If we didn't find the element, return -1 */ if (member == NULL) return -1; return list_rem_next(set, prev_to_member, data); }
int chtbl_remove(CHTbl *htbl, void **data){ ListElem *elem,*prev; int bucket; bucket = htbl->h(*data) % htbl->buckets; prev =NULL; for (elem=list_head(&htbl->table[bucket]);elem !=NULL;elem=list_next(elem)){ if (htbl->match(*data,list_data(elem))){ if (list_rem_next(&htbl->table[bucket],prev,data)==0){ htbl->size--; return 0; } else{ return -1; } } prev = elem; } //data not found return -1; };
int set_remove(Set * set, void **data) { ListElmt *member, *prev; /***************************************************************************** * Find the member to remove. * *****************************************************************************/ prev = NULL; for (member = list_head(set); member != NULL; member = list_next(member)) { if (set->match(*data, list_data(member))) break; prev = member; } /***************************************************************************** * Return if the member was not found. * *****************************************************************************/ if (member == NULL) return -1; /***************************************************************************** * Remove the member. * *****************************************************************************/ return list_rem_next(set, prev, data); }
/***************************************************************************** * * * ----------------------------- list_destroy ----------------------------- * * * *****************************************************************************/ void list_destroy(List *list) { void *data; /***************************************************************************** * * * Remove each element. * * * *****************************************************************************/ while (list_size(list) > 0) { if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL) { /*********************************************************************** * * * Call a user-defined function to free dynamically allocated data. * * * ***********************************************************************/ list->destroy(data); } } /***************************************************************************** * * * No operations are allowed now, but clear the structure as a precaution. * * * *****************************************************************************/ memset(list, 0, sizeof(List)); return; }
//rehashing function int rehash(CHTbl *htbl) { void *key; void *data; int i, j, oldbuckets, size; oldbuckets = htbl->buckets; htbl->buckets *= 2; for(i = oldbuckets; i < htbl->buckets; ++i) list_init(&htbl->table[i], list_dest_elm, NULL, list_print_elm); htbl->h = f[((*fcptr)++)%3]; for(i = 0; i < oldbuckets; ++i) { size = (&(htbl->table[i]))->size; for(j = 0; j < size; ++j) { list_rem_next(&(htbl->table[i]), NULL, (const void**) &key, (const void**) &data); htbl->size--; chtbl_insert(&htbl, key, data); } } return 0; }
/* chtbl_remove */ int chtbl_remove(CHTbl *htbl, void **data) { ListElmt *element, *prev; int bucket; /* Hash the key. */ bucket = htbl->h(*data) % htbl->buckets; /* Search for the data in bucket. */ prev = NULL; for (element = list_head(&htbl->table[bucket]); element != NULL; element = list_next(element)) { if (htbl->match(*data, list_data(element))) { /* Remove the data from the bucket. */ if (list_rem_next(&htbl->table[bucket], prev, data) == 0) { htbl->size--; return 0; } else { return -1; } } prev = element; } /* Return that the data was not found. */ return -1; }
int chtbl_remove_kv(CHTbl *htbl, SweetListKv **data) { ListElmt *element, *prev; int bucket; bucket = htbl->h((*data)->key) % htbl->buckets; prev = NULL; for (element = list_head(&htbl->table[bucket]); element != NULL; element = list_next(element)){ if (htbl->match(*data, list_data(element))){ if (list_rem_next(&htbl->table[bucket], prev, (void **)data) == 0){ htbl->size--; return 0; }else { return -1; } } prev = element; } return -1; }
/*删除哈希表中的元素*/ int chtbl_remove(CHTbl *chtbl,void **data){ ListElmt *element,*prev; int bucket; /*Hash the key*/ bucket = chtbl->h(*data)%chtbl->buckets; /*在哈希表中查找data*/ prev = NULL; for (element = list_head(&chtbl->table[bucket]); element==NULL; element = list_next(element)) { if (chtbl->match(*data,list_data(element))) { if (list_rem_next(&chtbl->table[bucket], prev, data)==0) { chtbl->size--; return 0; }else{ return -1; } } prev = element; } return -1; }
/* graph_destroy */ void graph_destroy(Graph *graph) { AdjList *adjlist; /* Remove each adjacency-list structure and destroy its adjacency list.*/ while (list_size(&graph->adjlists) > 0) { if (list_rem_next(&graph->adjlists, NULL, (void **)&adjlist) == 0) { set_destroy(&adjlist->adjacent); if (graph->destroy != NULL) { graph->destroy(adjlist->vertex); } free(adjlist); } } /* Destroy the list of adjacency-list structures, which is now empty. */ list_destroy(&graph->adjlists); /* No operation are allowed now, * but clear the structures as a precaution. */ memset(graph, 0, sizeof(Graph)); return; }
int main(int argc, char **argv){ ListElmt *node; int i; int x[] = {1,5,3,4,0,-2,100}; /* create a buffer of ints */ char y[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'}; int tmp; char ytmp; int *xp = &tmp; char *yp = &ytmp; char *otherKey = "test"; int otherVal = -121; int n = sizeof(x)/sizeof(int); /* create the list. would be nice if list_init did this */ List *list = (List *) malloc(sizeof(List)); /* pass list to list_init with destroy and tostring methods */ list_init(list,int_destroy,NULL,int2str); /* insert at head of list */ list_ins_next(list,NULL,&y[0],&x[0]); list_print(list); /* let's do a few more */ node = list_head(list); for (i=1;i<n;++i){ list_ins_next(list,node,&y[i],&x[i]); list_print(list); node = list_next(node); } /* now what if we want to, say, insert after the 3rd element of the list? */ node = list->head; /* unfortunately we have to traverse the list from the head until we get the 3rd element */ /* next we add this capability to the list class itself via a new higher level method */ for (i=0;i<3;++i){ node = list_next(node); } list_ins_next(list,node,otherKey,&otherVal); list_print(list); /* now let's remove some elements. let's start with head */ list_rem_next(list,NULL,(const void **) &yp,(const void **) &xp); list_print(list); list_rem_next(list,NULL,(const void **) &yp,(const void **) &xp); list_print(list); printf("%d\n", *xp); return 0; }
void list_destroy(List *list) { void *data; while (list->size > 0) if (list_rem_next(list, NULL, (void **) &data) == 0 && list->destroy != NULL) list->destroy(data); memset(list, 0, sizeof (List)); }
void list_destroy(List *list){ void *data; while (list_size(list) > 0){ if (list_rem_next(list,NULL,(const void **) &data) == 0 && list->destroy != NULL) list->destroy(data); } memset(list,0,sizeof(list)); }
/* graph_rem_vertex */ int graph_rem_vertex(Graph *graph, void **data) { ListElmt *element, *temp, *prev; AdjList *adjlist; int found; /* Traverse each adjacency list and the verticces it contains. */ prev = NULL; found = 0; for (element = list_head(&graph->adjlists); element != NULL; element = list_next(element)) { /* Do not allow removal of the vertex if * it is an adjacency list. */ if (set_is_member(&((AdjList *)list_data(element)) ->adjacent, *data)) { return -1; } /* Keep a pointer to the vertex to br removed. */ if (graph->match(*data, ((AdjList *)list_data(element))->vertex)) { temp = element; found = 1; } /* Keep a pointer to the vertex before * the vertex to be removed. */ if (!found) { prev = element; } } /* Return if the vertex was not found. */ if (!found) { return -1; } /* Do not allow removal of the vertex if * its adjacency list is not empty. */ if (set_size(&((AdjList *)list_data(temp))->adjacent) > 0) { return -1; } /* Remove the vertex. */ if (list_rem_next(&graph->adjlists, prev, (void **)&adjlist) != 0) { return -1; } /* Free the storage allocated by the abstract datatype. */ *data = adjlist->vertex; free(adjlist); /* Adjust the vertex count to account for the removed vertex. */ graph->vcount--; return 0; }
int main() { // setup List *list1 = malloc(sizeof(List)); int *five = malloc(sizeof(int)); int *four = malloc(sizeof(int)); int *three = malloc(sizeof(int)); int *two = malloc(sizeof(int)); int *one = malloc(sizeof(int)); ListElmt *go_to_end = malloc(sizeof(ListElmt)); void *tempvar = malloc(sizeof(int)); printf("test list_init\n"); list_init(list1, &destroy_int); printf("list_init success\n"); *five = 5; *four = 4; *three = 3; printf("test list_ins_front\n"); list_ins_front(list1, five); list_ins_front(list1, four); list_ins_front(list1, three); print_list(list1); printf("test list_ins_next\n"); *two = 2; *one = 1; list_ins_next(list1, list_head(list1), two); go_to_end = list_head(list1); while(go_to_end->next != NULL) { go_to_end = go_to_end->next; } list_ins_next(list1, go_to_end, one); print_list(list1); printf("test list_rem_next\n"); list_rem_next(list1, list_head(list1), tempvar); list1->destroy(tempvar); print_list(list1); printf("test list destroy\n"); list_destroy(list1); print_list(list1); printf("list size: %d\n", list_size(list1)); // clean up free(tempvar); //free(go_to_end); free(one); free(two); // the following are freed by list_destroy // free(three); // free(four); // free(five); free(list1); }
void list_destroy(List *list){ void *data; while(list_size(list)>0){ if(list_rem_next(list,NULL,(void **)&data)==0&&list->destroy!=NULL) { list->destroy(data); } } memset(list,0,sizeof(List));//清空list return; }
int queue_dequeue(Queue *queue, void **data) { /***************************************************************************** * * * Dequeue the data. * * * *****************************************************************************/ return list_rem_next(queue, NULL, data); }
int stack_pop(Stack *stack, void **data) { /***************************************************************************** * * * Pop the data off the stack. * * * *****************************************************************************/ return list_rem_next(stack, NULL, data); }
int list_destroy(struct linked_list* list) { if (list == NULL) return -1; void* data; while (list_size(list) > 0) { if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL) { list->destroy(data); } } memset(list, 0, sizeof(struct linked_list)); return 0; }
//list_destory void list_destory(List *list) { void *data; while (list_size(list)>0){ if(list_rem_next(list,NULL,(void**)&data) == 0) { // list->destory(data); free(list); } } memset(list, 0, sizeof(List)); return; }
void LinksAspect::delete_biedge(int i, int j) { LinksInfo *iInfo = (*this)[i]; LinksInfo *jInfo = (*this)[j]; ListElmt *element, *prev; int retval=-2; if (i == j) return; prev = NULL; for (element = iInfo->Table.head; element != NULL; element = element->next) { if ( j == element->data->v2) { list_rem_next(&iInfo->Table, prev); Links--; iInfo->Degree--; break; } prev = element; } prev = NULL; for (element = jInfo->Table.head; element != NULL; element = element->next) { if ( i == element->data->v2) { list_rem_next (&jInfo->Table, prev); Links--; jInfo->Degree--; break; } prev = element; } }
void list_free(sllist_t **lst) { void *data; while ((*lst)->size > 0) { if (list_rem_next(*lst, NULL, (void **) &data) == 0 && (*lst)->destroy != NULL) { (*lst)->destroy(data); } } // memset(*lst, 0, sizeof(sllist_t)); free(*lst); *lst = NULL; return; }
int graph_rem_vertex(Graph *graph, void **data) { ListElmt *element, *temp, *prev; AdjList *adjlist; int found; prev = NULL; found = 0; for (element = list_head(&graph->adjlists); element != NULL; list_next(element)) { // 如果在一个临近链表中,不允许移除其顶点 if (set_is_member(&(AdjList *)list_data(element))->adjacent, *data) { return -1; } // 保持一个指针指向需要被移除的顶点 if (graph->match(*data, ((AdjList *)list_data(element))->vertex)) { temp = element; found = 1; } // 保持一个指针在顶点被移除之前的顶点 if (! found) { prev = element; } } // 如果顶点未被找到就返回 if (! found) { return -1; } // 如果临近链表非空,则不允许移除其顶点 if (set_size(&((AdjList *)list_data(temp))->adjacent) > 0) { return -1; } // 移除顶点 if (list_rem_next(&graph->adjlists, prev, (void **)&adjlist) != 0) { return -1; } *data = adjlist->vertex; free(adjlist); graph->vcount--; return 0; }
int set_remove(Set *set, void **data) { ListElmt *member, *prev; prev = NULL; for (member = list_head(set); member != NULL; member = list_next(member)) { if (set->match(*data, list_data(member))) break; prev = member; } if (member == null) return -1; return list_rem_next(set, prev, data); }
int alloc_frame(List *frames) { int frame_number, *data; if (list_size(frames) == 0) { return -1; }else{ if (list_rem_next(frames, NULL, (void**)&data) != 0) { return -1; }else{ frame_number = *data; free(data); } } return frame_number; }
void list_destroy(List *list) { void *data; /// 删除每一个元素 while (list_size(list) > 0) { if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL) { /// 调用用户定义的 destroy 方法销毁动态创建的数据 list->destroy(data); } } /// 清理链表结构体数据 memset(list, 0, sizeof(List)); return; }
/* alloc_frame */ int alloc_frame(List *frames){ int frame_number, *data; if(list_size(frames) == 0) /* return that there are no frames available. */ return -1; else{ if(list_rem_next(frames, NULL, (void **)&data) != 0) /* return that a frame could not be retrieved. */ return -1; else{ /* store the number of the available frame. */ frame_number = *data; free(data); } } return frame_number; }
// remove the element iteratively void list_destory (List *list) { void *data; while (list_size(list) > 0) { if ((list_rem_next (list, NULL, (void **)&data)) == 0 && list->destory != NULL) { // call a user defined function to destroy data list->destory (data); } } memset (list, 0, sizeof (List)); // question : why using memset zero instead of free() ? // ans : the pointer is still held by the calling function, that function is able // to decide whether to free this memory block or allocate another // memory block and assign that block address to list. return; }
//frees up all memory from the table void destroy_table(CHTbl *htbl) { int i; ListElmt *element, *parent; List *clist; void *key, *data; for(i = 0; i < htbl->buckets; ++i) { clist = &htbl->table[i]; parent = NULL; for(element = list_head(clist); element != NULL; element = list_next(element)) { list_rem_next(clist, parent, (const void **) &key, (const void **)&data); clist->destroy(key, data); htbl->size--; parent = element; } } }
void graph_destroy(Graph *graph) { AdjList *adjlist; // 移除每一个相邻的链表结构和链表 while(list_size(&graph->adjlists) > 0) { if (list_rem_next(&graph->adjlists, NULL, (void **)&adjlist) == 0) { set_destroy(&adjlist->adjacent); if (graph->destroy != NULL) { graph->destroy(adjlist->vertex); free(adjlist); } } } list_destory(&graph->adjlists); memset(graph, 0 sizeof(Graph)); return; }
//function to remove an item with the key "key" from the hash table int htbl_remove(CHTbl *htbl, void *key) { List *clist; ListElmt *element, *parent = NULL; int bucket; void *nkey, *data; bucket = htbl->h(key)%htbl->buckets; clist = &htbl->table[bucket]; for(element = list_head(clist); element != NULL; element = list_next(element)) { if(!htbl->match(key, list_key(element))) { list_rem_next(clist, parent, (const void **) &nkey, (const void **)&data); clist->destroy(nkey, data); htbl->size--; return 0; } parent = element; } return -1; }