List *quick_sort(List *list) { int count = List_Node_count(list); if(count==1 || count==0) { return list; } List *lesser = List_create(); List *greater = List_create(); Node *pivot = list->first; Node *current = pivot->next; Node *to_push; while(current!=NULL) { to_push = current; current = current->next; to_push->previous = NULL; to_push->next = NULL; if(to_push->data<pivot->data) { List_push(lesser, to_push); } else { List_push(greater, to_push); } } pivot->next = NULL; pivot->previous = NULL; return concatenate(quick_sort(lesser), pivot, quick_sort(greater)); }
List *List_merge_sort(List *list, List_compare cmp){ if(List_count(list)<=1){ return list; } List *left=List_create(); List *right=List_create(); int middle=List_count(list)/2; LIST_FOREACH(list, first, next, cur){ if(middle>0){ List_push(left, cur->value); } else { List_push(right, cur->value); } middle--; } List *sort_left=List_merge_sort(left, cmp); List *sort_right=List_merge_sort(right, cmp); if(sort_left !=left) List_destroy(left); if(sort_right !=right)List_destroy(right); return List_merge(sort_left, sort_right, cmp); }
List *List_merge_sort(List *list, List_compare cmp) { // 未初始化的List,视为不能排序 if(list == NULL) return NULL; // 空List和只有一个节点的List视为已经排序 if(List_count(list) < 2) return list; int i = 1; ListNode *cur = list->first; List *left = List_create(); List *right= List_create(); int middle = List_count(list) / 2; // 拆成两个List,分别排序 for(i = 1; i < middle; i++) { List_push(left, cur->value); cur=cur->next; } for(i = 1; i <= List_count(list) - middle; i++) { List_push(right, cur->value); cur=cur->next; } List *sort_left = List_merge_sort(left, cmp); List *sort_right = List_merge_sort(right, cmp); if(sort_left != left) List_destroy(left); if(sort_right != right) List_destroy(right); // merge return List_merge(sort_left, sort_right, cmp); }
List *List_merge_sort(List *list, List_compare cmp) { assert(list != NULL && "list can't be NULL"); assert(cmp != NULL && "cmp can't be NULL"); if(List_count(list) <= SUB_LIST_MIN_SIZE) { int rc = List_bubble_sort(list, cmp); assert(rc == 0 && "Bubble sort failed."); return list; } List *left = List_create(); List *right = List_create(); int middle = List_count(list) / 2; List_split(list, left, middle, right, List_count(list) - middle); List *sort_left = List_merge_sort(left, cmp); List *sort_right = List_merge_sort(right, cmp); if(sort_left != left) List_clear_destroy(left); if(sort_right != right) List_clear_destroy(right); List *merged_list = List_merge(sort_left, sort_right, cmp); List_clear_destroy(sort_left); List_clear_destroy(sort_right); return merged_list; }
Menu * Menu_create(SDL_Window * window, SDL_Rect * size, SDL_Color background_color) { Menu * menu = (Menu *) malloc(sizeof(Menu)); if (menu != NULL) { menu->window = window; if (size) { menu->surface = SDL_CreateRGBSurface(0, size->w, size->h, 32, 0, 0, 0, 0); } else { SDL_Surface * surface = SDL_GetWindowSurface(window); Uint32 rmask, gmask, bmask, amask; rmask = 0xff000000; gmask = 0x00ff0000; bmask = 0x0000ff00; amask = 0x000000ff; menu->surface = SDL_CreateRGBSurface(0, surface->w, surface->h, 32, rmask, gmask, bmask, amask); } if (menu->surface != NULL) { menu->rect = (SDL_Rect *) malloc(sizeof(SDL_Rect)); if (size) { menu->rect->x = size->x; menu->rect->y = size->y; } else { menu->rect->x = 0; menu->rect->y = 0; } menu->rect->w = menu->surface->w; menu->rect->h = menu->surface->h; menu->background_color = background_color; menu->buttons = List_create(); menu->inputs = List_create(); menu->labels = List_create(); } else { printf("Erro ao criar o menu: %s\n", SDL_GetError()); } } return menu; }
/** * Inserting "value" and "index" into the correct location in the * sparse array "head" * * Arguments: * head A pointer pointing to the first element of the linked list. * value The "value" of the value * index The "value" of the index * * Returns: * A sparse array * * This function inserts the node ["value", "index"] into the sparse * array "head", and ensures that the nodes remain in ascending order * by their "index". * * Before and after the call to this function, "head" must be in * ASCENDING order by the "index" of each node. */ Node * List_insert_ascend(Node * head, int value, int index) { if(head == NULL){ head = List_create(value, index); return head; } Node* p = head; while(p->next != NULL){ p = p->next; } p->next = List_create(value, index); return head; }
char* test_copy() { src = List_create(); dest = List_create(); List_push(src, test1); List_push(src, test2); List_push(src, test3); List_copy(dest, src); mu_assert(List_count(dest) == 3, "Wrong copy - count."); mu_assert(List_first(dest) == test1, "Wrong copy - first."); mu_assert(List_last(dest) == test3, "Wrong copy - last."); return NULL; }
char *test_genotype_hard_copy_genotype_t_list(){ List *new_list = List_create(); List *old = List_create(); genotype_t *geno = genotype_init_genotype(); int count = 10; char base = 'C'; genotype_set_base_count(geno, base, count); mu_assert(geno->c_count==10,"Wrong number of C bases recorded"); List_push(old,geno); genotype_hard_copy_genotype_t_list(new_list,old); mu_assert(List_count(new_list) == 1, "Wrong number of elements in list."); LIST_FOREACH(new_list, first, next, cur){ //Only one element... mu_assert(((genotype_t *)cur->value)->c_count == 10, "Wrong c count in copied value."); }
int serial_find(int com, int timeout, char* ack1, char* ack2) { if (!recvlst) { recvlst = List_create(); } int i; for (i = 0; i <= timeout * 10; i++) { if (!serial_read(com, __serial_buf2)) { delay(100); continue; } console_write(__serial_buf2); char* x = strtok(__serial_buf2, "\n"); while (x != 0) { if (ack1 && strstr(x, ack1) == x) { return 1; } if (ack2 && strstr(x, ack2) == x) { return 1; } x = strtok(0, "\n"); } } // console_write("ERROR/TIMEOUT\n"); return 0; }
/* * Match ranges */ static void init_ranges(Parser *parser) { if (parser == NULL) { return; } if (parser->ranges == NULL) { parser->range_count = get_delimeted_group_count( parser, parser->symbols[SYMBOL_RANGE_BEG], parser->symbols[SYMBOL_RANGE_END]); if (parser->range_count > 0) { parser->ranges = malloc(parser->range_count * sizeof(List *)); if (parser->ranges != NULL) { unsigned int i; for (i = 0; i < parser->range_count; ++i) { parser->ranges[i] = List_create(); } get_delimited_tokens(parser, parser->symbols[SYMBOL_RANGE_BEG], parser->symbols[SYMBOL_RANGE_END], parser->ranges); } } } }
List * List_copy(List * list, void * (*copy)(void *)) { List * newList; void * data, * copyData; ListIterator * iterator; if(list == NULL) return NULL; newList = List_create(); iterator = ListIterator_create(list); data = ListIterator_seekToFirst(iterator); while(data != NULL) { copyData = copy(data); if(copyData != NULL) { List_addBack(newList, copyData); } data = ListIterator_nextItem(iterator); } ListIterator_destroy(iterator); return newList; }
List *split_access_get_all_split_sections(char *file_loc){ assert(file_loc != NULL); FILE *file; char *chr = NULL; seq_region_t *reg = NULL; file = fopen(file_loc,"r"); check(file != NULL,"Error opening split list file."); char line[250]; int i=0; List *li = List_create(); while ( fgets(line,sizeof(line),file) != NULL ){ i++; chr = malloc(sizeof(char) * 250); check_mem(chr); int start_zero_based = 0; int stop = 0; int chk = sscanf(line,"%s\t%d\t%d",chr,&start_zero_based,&stop); check(chk==3,"Error parsing split file line number %d: %s.",i,line); reg = malloc(sizeof(struct seq_region_t)); check_mem(reg); reg->beg = start_zero_based+1; reg->end = stop; reg->chr_name = chr; List_push(li,reg); } return li; error: if(reg){ if(reg->chr_name) free(reg->chr_name); free(reg); } if(chr) free(chr); return NULL; }
static void clear_data(Parser *parser) { if (parser != NULL) { List_destroy(parser->token_list, (Destructor) Token_destroy); if (parser->groups != NULL) { unsigned int i; for (i = 0; i < parser->group_count; ++i) { List_destroy(parser->groups[i], (Destructor) Token_destroy); } free(parser->groups); parser->groups = NULL; } if (parser->ranges != NULL) { unsigned int i; for (i = 0; i < parser->range_count; ++i) { List_destroy(parser->ranges[i], (Destructor) Token_destroy); } free(parser->ranges); parser->ranges = NULL; } parser->token_list = List_create(); parser->group_count = 0; parser->range_count = 0; } }
static List * List_split( List *words , int pos){ List *second; assert( pos <= words->count); ListNode *middle = words->first; int position = pos; while( pos != 0){ middle = middle->next; assert(middle != NULL); pos--; } second =List_create(); second->count = words->count - position; second->first = middle; second->last = words->last; words->count = position; words->last = middle->prev; words->last->next = NULL; middle->prev = NULL; return second; }
inline List *List_merge(List *left, List *right, List_val_compare cmp) { check((left != NULL) || (right != NULL), "Tried to merge NULL."); List *merged = List_create(); void *val = NULL; while(List_count(left) > 0 || List_count(right) > 0) { if(List_count(left) > 0 && List_count(right) > 0) { if(cmp(List_first(left), List_first(right)) <= 0) { val = List_fpop(left); } else { val = List_fpop(right); } List_push(merged, val); } else if(List_count(left) > 0) { merged = List_join(merged, left); break; } else if(List_count(right) > 0) { merged = List_join(merged, right); break; } } return merged; error: return NULL; }
AnimatedSprite* AnimatedSprite_create(Sprite* sprite) { AnimatedSprite* this = malloc(sizeof(AnimatedSprite)); this->sprite = sprite; this->animations = List_create(); AnimationProgress_init(&this->progress, this, NULL); return this; }
struct fd_state * alloc_fd_state(struct event_base *base, evutil_socket_t fd) { struct fd_state *state = malloc(sizeof(struct fd_state)); if (!state) return NULL; state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state); if (!state->read_event) { free(state); return NULL; } state->write_event = event_new(base, fd, EV_WRITE|EV_PERSIST, do_write, state); if (!state->write_event) { event_free(state->read_event); free(state); return NULL; } state->rtmp = rtmp_create(); state->buffer = RingBuffer_create(BUFFER_SIZE); state->outputs = List_create(); assert(state->write_event); return state; }
static List *neighbours_list(World *world, Point *point, Point *destination, Hashmap *nodes) { List *neighbours = List_create(); int nx, ny; for(nx = point->x - 1; nx <= point->x + 1; nx++) { if(nx < 0 || nx >= world->width) continue; for(ny = point->y - 1; ny <= point->y + 1; ny++) { if(ny < 0 || ny >= world->height || (ny == point->y && nx == point->x) || (!World_can_enter(world, nx, ny, point->z) && !(nx == destination->x && ny == destination->y))) continue; Point *p = Point_create(nx, ny, point->z); Node *node = Node_create(p, 0, 0, NULL); Node *old_node = Hashmap_get(nodes, node); if(old_node) { Node_destroy(node); node = old_node; } else { Hashmap_set(nodes, node, node); } List_push(neighbours, node); } } return neighbours; }
void cerebrod_speaker_data_initialize(void) { #if !WITH_CEREBROD_NO_THREADS Pthread_mutex_lock(&speaker_data_init_lock); #endif /* !WITH_CEREBROD_NO_THREADS */ if (speaker_data_init) goto out; #if !WITH_CEREBROD_NO_THREADS /* * Must lock in this initialization routine, b/c the update thread * in a metric module may call the update state function. */ Pthread_mutex_lock(&metric_list_lock); #endif /* !WITH_CEREBROD_NO_THREADS */ metric_list = List_create((ListDelF)_destroy_speaker_metric_info); if (_setup_metric_modules() < 0) CEREBRO_EXIT(("_setup_metric_modules")); #if !WITH_CEREBROD_NO_THREADS Pthread_mutex_unlock(&metric_list_lock); #endif /* !WITH_CEREBROD_NO_THREADS */ speaker_data_init++; out: #if !WITH_CEREBROD_NO_THREADS Pthread_mutex_unlock(&speaker_data_init_lock); #endif /* !WITH_CEREBROD_NO_THREADS */ ; /* in case !WITH_CEREBRO_NO_THREADS */ }
char* test_split() { List* list_test = List_create(); List_push(list_test, test1); List_push(list_test, test2); List_push(list_test, test3); List_push(list_test, test4); List_push(list_test, test5); List_push(list_test, test6); ListNode* split1 = List_find(list_test, test3); ListNode* split2 = List_find(list_test, test5); mu_assert(split1->value == test3, "Ridi"); mu_assert(split2->value == test5, "Ridi"); List** splits = List_split(list_test, 2, split1, split2); mu_assert(splits[0]->first->value == list_test->first->value, "Ridi"); mu_assert(splits[0]->first->next->value == list_test->first->next->value, "Ridi"); mu_assert(splits[0]->last->value == list_test->first->next->next->value, "Ridi"); mu_assert(splits[1]->first->value == list_test->first->next->next->next->value, "Ridi"); mu_assert(splits[1]->last->value == list_test->first->next->next->next->next->value, "Ridi"); mu_assert(splits[2]->first->value == list_test->last->value, "Ridi"); return NULL; }
Node* List_create_internal_cycle(int size) { check(size >= 3, "Size should be equal to at least 3."); Node* head = Node_create(0); Node* neck = Node_create(1); head->next = neck; Node* backbone = List_create(size - 2); neck->next = backbone; Node* it = head; while (it->next) { it = it->next; } it->next = neck; return head; error: return NULL; }
//Function to build list from frequencies Node * List_build(int * frequencies) { Node * ln; int j = 0; while(frequencies[j] == 0) { j++; } printf("Inserting %c : %d\n", j, frequencies[j]); ln = List_create(j, frequencies[j]); j++; int i = 0; i = j; while(i < 127) { if (frequencies[i] > 0) { printf("Inserting %c : %d\n", i, frequencies[i]); ln = List_insert_ascend(ln, i, frequencies[i]); } i++; } return ln; }
int main(int argc, char *argv[]) { List *list; List *right; list = List_create(sizeof(int)); if (list == NULL) { errExit("List_create"); } List_blaster_test(list); List_pop_test(list); List_blaster_test(list); List_pop_left_test(list); List_blaster_test(list); right = List_split_test(list); List_join_test(list, right); List_copy_test(list); List_multithread_test(list); List_debug(list); List_bubble_sort_test(list); List_debug(list); List_mergesort_test(list); List_debug(list); List_destroy(list); exit(EXIT_SUCCESS); }
/* * _event_server_initialize * * perform metric server initialization */ static void _event_server_initialize(void) { int event_names_count; Pthread_mutex_lock(&event_server_init_lock); if (event_server_init) goto out; if (event_names) { event_names_count = List_count(event_names); event_connections = List_create((ListDelF)free); event_connections_index = Hash_create(event_names_count, (hash_key_f)hash_key_string, (hash_cmp_f)strcmp, (hash_del_f)list_destroy); } Signal(SIGPIPE, SIG_IGN); event_server_init++; Pthread_cond_signal(&event_server_init_cond); out: Pthread_mutex_unlock(&event_server_init_lock); }
char *test_create() { list = List_create(); mu_assert(list != NULL, "Failed to create list."); return NULL; }
/*! * @brief Setup SysLinkMemUtils module. * * @sa _SysLinkMemUtils_exit */ static Void _SysLinkMemUtils_init (Void) { List_Params listParams; GT_0trace (curTrace, GT_ENTER, "_SysLinkMemUtils_init"); List_Params_init (&listParams); SysLinkMemUtils_module->addrTable = List_create (&listParams); #if !defined(SYSLINK_BUILD_OPTIMIZE) if (!SysLinkMemUtils_module->addrTable) { GT_setFailureReason (curTrace, GT_4CLASS, (Char *)__func__, PROCMGR_E_MEMORY, "Translation list could not be created!"); } #endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */ SysLinkMemUtils_module->semList = OsalSemaphore_create ( OsalSemaphore_Type_Counting, 1); #if !defined(SYSLINK_BUILD_OPTIMIZE) if (!SysLinkMemUtils_module->semList) { GT_setFailureReason (curTrace, GT_4CLASS, (Char *)__func__, PROCMGR_E_MEMORY, "List semaphore could not be created!"); } #endif /* if !defined(SYSLINK_BUILD_OPTIMIZE) */ GT_0trace (curTrace, GT_LEAVE, "_SysLinkMemUtils_init"); }
List *List_merge(List *left, List *right, List_compare cmp) { List *result = List_create(); void *val = NULL; while(List_count(left) != 0 && List_count(right) != 0) { if(cmp(List_first(left), List_first(right)) <= 0) { val = List_shift(left); List_push(result, val); } else { val = List_shift(right); List_push(result, val); } } while(List_count(left) != 0) { val = List_shift(left); List_push(result, val); } while(List_count(right) != 0) { val = List_shift(right); List_push(result, val); } return result; }
DynamicTrace* DynamicTrace_create(uint32_t nbCasesX, uint32_t nbCasesY, uint32_t sizeX, uint32_t sizeY) { DynamicTrace* dt = (DynamicTrace*)malloc(sizeof(DynamicTrace)); if(dt == NULL) { perror("Error in malloc \n"); return NULL; } dt->nbCasesX = nbCasesX; dt->nbCasesY = nbCasesY; dt->sizeX = sizeX; dt->sizeY = sizeY; dt->tiles = (List***)malloc(sizeof(List**)*nbCasesX); uint32_t i, j; for(i=0; i < nbCasesX; i++) { dt->tiles[i] = (List**)malloc(sizeof(List*)*nbCasesY); for(j=0; j < nbCasesY; j++) dt->tiles[i][j] = List_create(); } return dt; }
void test_list_insert_ascend() { printf("running tests on list-insert-ascend\n"); Node * head = List_create(100, 2); head -> next = List_create(100, 4); head -> next -> next = List_create(100, 6); head -> next -> next -> next = List_create(100, 8); head -> next -> next -> next -> next = List_create(100, 10); //printf("Printing start-list\n"); //List_dump(head); List_print(stdout, head); List_destroy(head); }
Node * Node_Insert(Node * head, int val) //function to insert a node in the linked list containing integers { if (head == NULL) { head = List_create(val); //if head is head, then make it the first element } else { Node * cur = head; while (cur -> next != NULL) { cur = cur -> next; //find the correct position } cur -> next = List_create(val); //create the node at the rear end } return head; }