int main() { int i, j,tmp; int a[N],b[N]; for(i=10;;i++) { memset(a, 0, N*sizeof(int)); format_long_num(i,a); sort_list(&a[1],a[0]); for(j=2;j<=MAX_NUM;j++) { tmp = i*j; memset(b, 0, N*sizeof(int)); format_long_num(tmp,b); sort_list(&b[1],b[0]); if(memcmp(a,b, N*sizeof(int))!=0) break; } if(j==MAX_NUM+1) { printf("%d\n", i); break; } } }
int main() { t_glist *lst; t_glist *clone; t_glist *rev; /* t_elem elem; */ /* srand(time(0)); */ /* elem.id = rand() % 10; */ lst = init_list(); printf("[+] Init list...\n"); put_elements(lst, 10); show_list_content(lst); printf("[+] Sorting...\n"); sort_list(lst, data_cmp); show_list_content(lst); printf("[+] Sorting opposite...\n"); sort_list(lst, data_cmp_opp); show_list_content(lst); printf("[+] Will clone list...\n"); clone = clone_list(lst); show_list_content(clone); printf("[+] Will rev list...\n"); rev = get_rev(lst); show_list_content(rev); printf("[+] Will rm last elem from clone...\n"); rm_last(clone); show_list_content(clone); printf("[+] Will rm first elem from clone...\n"); rm_first(clone); show_list_content(clone); printf("[+] Will show list from end to start...\n"); end_to_start(clone); return (0x0); }
int main(int argc, const char *argv[]) { TContact_list contact_list = {contact_list.first = NULL, contact_list.last = NULL}; get_dir(); switch(get_mode(argc, argv)){ case DEL: get_data(&contact_list); remove_from_list(&contact_list, atoi(argv[2])); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); break; case ADD: get_data(&contact_list); add_to_list(argv, &contact_list); sort_list(&contact_list); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); break; case LIST: get_data(&contact_list); sort_list(&contact_list); print_list(&contact_list); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); break; case SIN: get_data(&contact_list); print_single(&contact_list, atoi(argv[2])); free_list(&contact_list); break; case FIND: get_data(&contact_list); find_in_list(&contact_list, (char *)argv[2]); generate_html(&contact_list); free_list(&contact_list); break; case PLIST: get_data(&contact_list); sort_list(&contact_list); generate_plist(&contact_list); free_list(&contact_list); break; case DELN: get_data(&contact_list); delete_by_name(&contact_list, (char *)argv[2], (char *)argv[3]); save_csv(&contact_list); generate_html(&contact_list); free_list(&contact_list); default: handle_errors(); return EXIT_FAILURE; } if(handle_errors() != EXIT_SUCCESS) return EXIT_FAILURE; else return EXIT_SUCCESS; }
// Load the item lists from the file in players config directory // void List_Container::load(void) { loaded = true; saved_item_lists.clear(); std::string fullpath = get_path_config() + std::string(filename); std::ifstream in(fullpath.c_str()); if (!in) return; int revision; in >> revision; if (revision != FILE_REVISION) { LOG_ERROR("%s: %s [%s]\n", __FILE__, item_list_version_error_str, fullpath.c_str() ); return; } while (!in.eof()) { saved_item_lists.push_back(List()); if (!saved_item_lists.back().read(in)) saved_item_lists.pop_back(); } in.close(); sort_list(); active_list = 0; }
// Desc : Remove a employee from list // Params : head - The head node of list // Return : None void remove_employee(Node *head) { Node* node; char emp_no[7]; if(head->next == NULL) { printf("\n:: There is no employee!\n"); return; } sort_list(head); print_list(head); printf("\n> Employee Number : "); gets(emp_no); fflush(stdin); node = find_node(head, emp_no); if(node) { remove_node(head, node); printf(":: Success!\n"); }else{ printf(":: The employee number does not exist!\n"); } }
// Load the item lists from the file in players config directory // void List_Container::load(void) { loaded = true; saved_item_lists.clear(); std::string fullpath = get_path_config() + std::string(filename); std::ifstream in(fullpath.c_str()); if (!in) return; int revision; in >> revision; if (revision != FILE_REVISION) { LOG_ERROR("%s: %s [%s]\n", __FILE__, item_list_version_error_str, fullpath.c_str() ); LOG_TO_CONSOLE(c_red2, item_list_version_error_str); return; } bool logged_error = false; while (!in.eof()) { saved_item_lists.push_back(List()); if (!saved_item_lists.back().read(in)) { if ((saved_item_lists.back().is_valid_format()) && !logged_error) { LOG_TO_CONSOLE(c_red2, item_list_format_error); logged_error = true; } saved_item_lists.pop_back(); } } in.close(); sort_list(); set_active(initial_active_list); }
gpointer inquire_province(size_t offset) { float result; Province *pp; gchar *str; struct datalist *headlist=NULL,*p=NULL,*q=NULL; for(pp=head_province;pp;pp=pp->next) { result=*(float*)((gpointer)pp+offset); str=pp->name; p=(struct datalist*)malloc(sizeof(struct datalist)); *(char**)p->data=str; *(float*)(p->data+sizeof(char*))=result; if(!headlist) { headlist=p; } else { for(q=headlist;q->next;q=q->next); q->next=p; } p->next=NULL; } sort_list(&headlist,sizeof(char*)); return headlist; }
void sortStructTest() { struct node_t nodes[20]; nodes[0].prev = NULL; nodes[0].next = &(nodes[1]); nodes[19].next = NULL; nodes[19].prev = &(nodes[19]); int i; for(i = 1; i < 19; i++) { nodes[i].prev = &(nodes[i-1]); nodes[i].next = &(nodes[i+1]); } for(i = 0; i < 20; i++) { nodes[i].data = i % 7; } struct list_t list; list.head = &(nodes[0]); list.tail = &(nodes[19]); sort_list(&list); struct node_t* iter = list.head; while(iter != NULL) { printIntEndline(iter->data); iter = iter->next; } }
//查看列表 void print_list(list L) { int page=1; char ch; int max_page=len_list(L)/NPAGE+(len_list(L)%NPAGE==0?0:1); for(;;) { CLS; //头列标记 print_list_one_page(L,page); printf("\n==第 %d 页",page); if(page==max_page)printf(",尾页"); printf("==\n"); printf("使用“-”和“=”翻页,“s”排序,“0”回到主菜单\n"); ch=getch(); switch(ch) { case '-': if(page>1) --page; break; case '=': if(page<max_page) ++page; break; case '0': return; break; case 's': sort_list(L); page=1; break; } } }
main() { list_t mylist; mylist.head = mylist.tail = NULL; node_t * old_node; node_t * rm_node; // list creation phase insert_at_front(8, &mylist); rm_node = mylist.head; insert_at_front(5, &mylist); insert_at_front(1, &mylist); insert_at_front(12, &mylist); insert_at_front(3, &mylist); insert_at_front(9, &mylist); insert_at_front(7, &mylist); print_list(&mylist); // list sort phase sort_list( &mylist); print_list(&mylist); // element removal phase remove_element( mylist.head, &mylist ); remove_element( mylist.head, &mylist ); remove_element( mylist.tail, &mylist ); remove_element( rm_node, &mylist ); print_list(&mylist); }
/* * Builds the full neighborlist list from scratch for a particle * This is used for the initial build for all the particles, then for rebuilds * of moved particles * * arguments: * particles: The spatially decomposed particle information * neighbor_list: The particle's neighborlist * x,y,z: The indecies for the block which the particle belongs to * array_index: The index of the particle in the list */ void build_list_full(Particle* particles[XDiv][YDiv][ZDiv], Neighbor* neighbor_list, int x, int y, int z, int array_index){ // Iterates through the buckets in in such a way that for every pair of particles which are // potential neighbors, one and only one of them will have to check the distance for that pair. This is done by, // if we are looking at particle p, only looking at particles further down in the array in the block containing p, // and only looking in a "forward" direction (that is, for each pair of blocks that are "across" from eachother around // the block containing p, we consider only of those blocks) int j, k; int index = 0; Particle p = particles[x][y][z][array_index]; for (j = -1; j <= 1; ++j){ //y offset for (k = -1; k <= 1; ++k) { //z offset check_particles(particles, x+1, y+j, z+k, neighbor_list, p, &index); } } check_particles(particles, x, y+1, z+1, neighbor_list, p, &index); check_particles(particles, x, y+1, z , neighbor_list, p, &index); check_particles(particles, x, y+1, z-1, neighbor_list, p, &index); check_particles(particles, x, y , z+1, neighbor_list, p, &index); check_particles_center(particles, x, y, z, array_index, neighbor_list, p, &index); sort_list(neighbor_list); }
int config_write(int level, const char *media) { logprintf(LOG_STACK, "%s(...)", __FUNCTION__); struct JsonNode *root = json_mkobject(); FILE *fp; sort_list(0); struct config_t *listeners = config; while(listeners) { if(listeners->sync) { struct JsonNode *child = listeners->sync(level, media); if(child != NULL) { json_append_member(root, listeners->name, child); } } listeners = listeners->next; } /* Overwrite config file with proper format */ if(!(fp = fopen(configfile, "w+"))) { logprintf(LOG_ERR, "cannot write config file: %s", configfile); return EXIT_FAILURE; } fseek(fp, 0L, SEEK_SET); char *content = json_stringify(root, "\t"); fwrite(content, sizeof(char), strlen(content), fp); fclose(fp); json_free(content); json_delete(root); return EXIT_SUCCESS; }
int config_parse(JsonNode *root) { logprintf(LOG_STACK, "%s(...)", __FUNCTION__); struct JsonNode *jconfig = NULL; unsigned short error = 0; sort_list(1); struct config_t *listeners = config; while(listeners) { if((jconfig = json_find_member(root, listeners->name))) { if(listeners->parse) { if(listeners->parse(jconfig) == EXIT_FAILURE) { error = 1; break; } } } listeners = listeners->next; } if(error == 1) { config_gc(); return EXIT_FAILURE; } else { return EXIT_SUCCESS; } }
void count_alpha(int argc, char *argv[]) { int i; int k; int lower_alpha[26] = {0}; int upper_alpha[26] = {0}; int alpha_count[26] = {0}; i = 0; while (i < 26) { lower_alpha[i] = 97 + i; upper_alpha[i] = 65 + i; i++; } i = 0; while (argv[1][i]) { k = 0; while (k < 26) { if (argv[1][i] == lower_alpha[k] || argv[1][i] == upper_alpha[k]) alpha_count[k]++; k++; } i++; } sort_list(lower_alpha, upper_alpha,alpha_count, argv[1]); }
/** Ejemplo de lista doblemente enlazada */ int main(int argc, char * argv[], char *arge[]) { int i; // Lista principal struct doubly_node *L = NULL; // Genera sets de datos random_init(); for(i=0; i<10; i++) doubly_insert(&L, get_data()); // Imprime la lista original print_list("Lista original", L); // Imprime la lista con algunos datos removidos crop_list(&L); print_list("Lista recortada", L); // Imprime la lista ordenada sort_list(L); print_list("Lista ordenada", L); // Imprime la lista con algunos datos ordenados doubly_insert_after( L->next, get_data()); doubly_insert_before( L->next, get_data()); print_list("Lista con elementos adicionales", L); // Libera memoria doubly_destroy(&L); return 0; }
void chain_pair_alg_update_init(struct DotList *dots, int *num, struct kdnode *tree, struct perm_pt *p_pts, int size1, int size2, struct DotList *init_algns) { struct slist *sorted; int i = 0; int num_lines = 0; int xval = 0, yval = 0; int w_sid = 0, w_fid = 0, h_sid = 0, h_fid = 0; int opt_id = -1; bool *is_x; is_x = (bool *) malloc(sizeof(bool)); num_lines = *num; sorted = (struct slist *) ckalloc((*num) * sizeof(struct slist)); if( num_lines > 0 ) sort_list(sorted, dots, num_lines); for( i = 0; i < num_lines; i++ ) { opt_id = -1; if( dots[sorted[i].id].sign == DELETED ) { } else { xval = dots[sorted[i].id].x.lower; if( dots[sorted[i].id].sign == 0 ) { yval = dots[sorted[i].id].y.lower; } else { yval = dots[sorted[i].id].y.upper; } w_sid = find_id(dots, tree, size1, sorted[i].id, xval, yval, W_SID); w_fid = find_id(dots, tree, size1, sorted[i].id, xval, yval, W_FID); h_sid = find_id(dots, tree, size2, sorted[i].id, xval, yval, H_SID); h_fid = find_id(dots, tree, size2, sorted[i].id, xval, yval, H_FID); opt_id = find_opt_ch_alg(dots, num_lines, sorted[i].id, p_pts, w_sid, w_fid, h_sid, h_fid); } if( opt_id != -1 ) { if( debug_mode == TRUE ) { printf("Combined: %d-%d,%d-%d\n", dots[opt_id].x.lower, dots[opt_id].x.upper, dots[opt_id].y.lower, dots[opt_id].y.upper); printf("%d-%d,%d-%d\n", dots[sorted[i].id].x.lower, dots[sorted[i].id].x.upper, dots[sorted[i].id].y.lower, dots[sorted[i].id].y.upper); } mark_chain(dots, opt_id, sorted[i].id, init_algns); merging_step(dots, opt_id, sorted[i].id); } } overwrite_dots(num, dots); free(sorted); free(is_x); }
void add_to_list() { if(head == NULL) { create_list(); } else { sort_list(); } }
LOCAL void sort_list( NAME_LIST **files, int left, int right) { int i, last; if (left >= right) return; swap(files,left,(left+right)/2); last = left; for (i = left+1; i <= right; ++i) if (in_order(files[i],files[left]) == -1) swap(files,++last,i); swap(files,left,last); sort_list(files,left,last-1); sort_list(files,last+1,right); }
int main(int argc, char* argv[]) { int list[] = { 30, 1, 3, 6, 7, 8, 4, 16, 29, 10, 11, 12, 20, 5, 9, 23, 26, 22, 24, 13, 14, 17, 18, 19, 27, 28, 2, 25, TERMCHAR }; int list_length = count(list); printf("Got a list of length: %d\n", list_length); print_list(list); sort_list(list); print_list(list); }
// Rename the active list // void List_Container::rename_active(const char *name) { if (active_list >= size()) return; saved_item_lists[active_list].set_name(name); sort_list(); select_by_name(name); save(); }
int main(void) { /* Declare YOUR variables here ! */ Slist mylist; int menu_choice; /* Seed to random generator and clear the screen.. */ srand((unsigned int)time(NULL)); if ((mylist = SLISTinit(my_destroy)) == NULL) { printf("\nFatal error... - bailing out!"); SLISTdestroy(mylist); exit(-1); } /* Set match-callback into list structure.. */ SLISTsetmatch(mylist, my_match); /* Populate the (empty) list.. */ create_random_nodes(mylist, NR_OF_ITEMS); /* Enter menu loop... */ do { menu_choice = menu(MAIN_MENU_ROW, 0, 5); switch (menu_choice) { case 1: ins_nodes(mylist); break; case 2: rem_nodes(mylist); break; case 3: search_node(mylist); break; case 4: sort_list(mylist); break; case 5: print_list(mylist); break; default: final_status(mylist); break; } } while (menu_choice); /* ..and finally destroy the list. */ prompt_and_pause("\n\nLet's tidy up and destroy the list..- Bye!"); SLISTdestroy(mylist); return 0; }
void main( ){ int opt= 0; int p; process *proc; list *l; l= (list * ) malloc (sizeof(list)); make_list(l); printf("\n\n\n"); printf("\tTrabalho ED1 - Marcos Oleiro - Listas Simplesmente Encadeadas\n"); printf("\n\n\n"); while (opt != 3) { printf("1 - Adcionar Processos.\n"); printf("2 - Listar Processos.\n"); printf("3 - Sair.\n\n\n"); printf("Digite sua opcao: "); scanf ("%d", &opt); printf("\n"); switch (opt) { case 1: // process *proc= NULL ; printf("\n"); proc = newProcess(); printf("\n\n"); add_process(l,proc); printf("ID: %d, Prioridade: %d, Horario: %d:%d:%d\n",proc->id, proc->priority, proc->h->hour,proc->h->minute,proc->h->second); proc = NULL; printf("\n\n"); break; case 2: // printf("Opção 2.\n"); // sort_priority(l); sort_list(l); print_list(l); break; case 3: // printf("Opção 3.\n"); break; } } }
// Desc : Print all the employee data // Params : head - The head node of list // Return : None void retrieve_employee(Node *head) { if(head->next == NULL) { printf("\n:: There is no employee!\n"); return; } sort_list(head); print_list(head); }
static void do_trace_mem(struct tracecmd_input *handle) { struct pevent *pevent = tracecmd_get_pevent(handle); struct event_format *event; struct pevent_record *record; int missed_events = 0; int cpus; int cpu; int ret; ret = tracecmd_init_data(handle); if (ret < 0) die("failed to init data"); if (ret > 0) die("trace-cmd mem does not work with latency traces\n"); cpus = tracecmd_cpus(handle); /* Need to get any event */ for (cpu = 0; cpu < cpus; cpu++) { record = tracecmd_peek_data(handle, cpu); if (record) break; } if (!record) die("No records found in file"); ret = pevent_data_type(pevent, record); event = pevent_data_event_from_type(pevent, ret); common_type_field = pevent_find_common_field(event, "common_type"); if (!common_type_field) die("Can't find a 'type' field?"); update_kmalloc(pevent); update_kmalloc_node(pevent); update_kfree(pevent); update_kmem_cache_alloc(pevent); update_kmem_cache_alloc_node(pevent); update_kmem_cache_free(pevent); while ((record = tracecmd_read_next_data(handle, &cpu))) { /* record missed event */ if (!missed_events && record->missed_events) missed_events = 1; process_record(pevent, record); free_record(record); } sort_list(); print_list(); }
static node *sort_list(node *head) { node *n; for(n = head; n != NULL; n = n->next) { if(n->children != NULL) { n->children = sort_list(n->children); } } return merge_sort(head); }
int main(void) { List *list; char *array[] = {"San Marcos", "Holberton", "School", "California", "San Francisco", NULL}; if (!(list = array_to_list(array))) return (1); print_list(list); sort_list(&list, &node_cmp); print_list(list); free_list(list); return (0); }
// Add a new list // bool List_Container::add(const char *name) { saved_item_lists.push_back(List()); if (saved_item_lists.back().set(name)) { sort_list(); save(); select_by_name(name); return true; } saved_item_lists.pop_back(); return false; }
void sort_list(list_t * mylist) { if (mylist->head == mylist->tail) { return; } node_t *smallest = mylist->head, *trav; for (trav = smallest->next ; trav != NULL ; trav = trav->next) { if (trav->data < smallest->data) { smallest = trav; } } remove_element(smallest, mylist); sort_list(mylist); insert_element_after(smallest, NULL, mylist); }
void s_pair_heap::sort_list(s_pair *& p) const { if (p == NULL || p->next == NULL) return; s_pair *p1 = NULL; s_pair *p2 = NULL; while (p != NULL) { s_pair *tmp = p; p = p->next; tmp->next = p1; p1 = tmp; if (p == NULL) break; tmp = p; p = p->next; tmp->next = p2; p2 = tmp; } sort_list(p1); sort_list(p2); p = merge(p1, p2); }
void sort_list(struct list_t * mylist) { if (mylist->head != mylist->tail) { struct node_t *smallest = mylist->head; struct node_t *trav; for (trav = smallest->next ; trav != NULL ; trav = trav->next) { if (trav->data < smallest->data) { smallest = trav; } } remove_element(smallest, mylist); sort_list(mylist); insert_node_after(smallest, NULL, mylist); } }