Laboratório de Programação - Exercício 33

Transcrição

1 Laboratório de Programação - Exercício 33 Algoritmos para Lista Encadeada João Araujo Ribeiro jaraujo@uerj.br Universidade do Estado do Rio de Janeiro Departamento de Engenharia de Sistemas e Computação João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 1 / 20

2 Resumo 1 Ex33 - Algoritmos para Lista Encadeada Crédito extra João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 2 / 20

3 Exercício 33 - Algoritmos para Lista Encadeada Neste exercício vamos apresentar dois algoritmos que podemos implementar numa lista encadeada. Porém, que avisado, se você precisar ordenar dados, não o faça numa lista encadeada. Elas são horríveis para assuntos de ordenação, e existem estruturas de dados muito melhores para isso. Vamos usá-los aqui porque eles são mais difíceis de implementar numa lista encadeada e assim você precisará pensar de maneira mais eciente. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 3 / 20

4 Arquivos Para atingir nosso objetivo, vamos colocar os algoritmos em dois arquivos diferentes: list_algos.h e list_algos.c e o teste deles em list_algos_test.c. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 4 / 20

5 Desao Neste exercício, você tem um desao. Não trapaceie! Vamos fornecer o arquivo de teste primeiro e você deve tentar implementar os dois algoritmos baseado na descrição deles encontrada na Wikipedia, sem consultar a resposta fornecida aqui. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 5 / 20

6 Ordenação Bubble e Merge 1 Leia a descrição de cada algoritmo na Wikipedia. 2 Faça um chinês do algoritmo numa folha de papel, ou com um baralho para entender exatamente como ele funciona. 3 Crie um esqueleto das funções em list_algos.c e construa um arquivo list_algos.h funcional. Estude como testar. 4 Escreva um teste e compile tudo. 5 Volte à Wikipedia e copie o algoritmo (não o código C!) para a primeira função que esteja escrevendo. 6 Traduza este pseudo-código para um bom código C, como ensinado até aqui, usando sua unidade de teste para estar certo que funciona. 7 Escreva outros casos de etstes como listas vazias, listas já ordenadas, etc. 8 Repita o processo para o próximo algoritmo e teste. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 6 / 20

7 Unidade de teste: list_algos_test.c 1/4 1 #include "minunit.h" 2 #include <lcthw/list_algos.h> 3 #include <assert.h> 4 #include <string.h> 5 6 char *values[] = {"XXXX", "1234", "abcd", "xjvef", "NDSS"}; 7 #define NUM_VALUES List *create_words() 10 { 11 int i = 0; 12 List *words = List_create(); for(i = 0; i < NUM_VALUES; i++) { 15 List_push(words, values[i]); 16 } return words; 19 } int is_sorted(list *words) 22 { João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 7 / 20

8 Unidade de teste: list_algos_test.c 2/4 23 LIST_FOREACH(words, first, next, cur) { 24 if(cur->next && strcmp(cur->value, cur->next->value) > 0) { 25 debug("%s %s", (char *)cur->value, (char *)cur->next->value); 26 return 0; 27 } 28 } return 1; 31 } char *test_bubble_sort() 34 { 35 List *words = create_words(); // Deve funcionar numa lista que precise ser ordenada 38 int rc = List_bubble_sort(words, (List_compare)strcmp); 39 mu_assert(rc == 0, "Falha no Bubble sort."); 40 mu_assert(is_sorted(words), "Palavras não estão ordenadas após bubble sort."); // Deve funcionar numa lista já ordenada 43 rc = List_bubble_sort(words, (List_compare)strcmp); 44 mu_assert(rc == 0, "Falha do Bubble sort numa lista já ordenada."); 45 mu_assert(is_sorted(words), "Palavras deveriam estar ordenadas se já estivesse orde João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 8 / 20

9 Unidade de teste: list_algos_test.c 3/4 47 List_destroy(words); // Deve funcionar numa lista vazia 50 words = List_create(words); 51 rc = List_bubble_sort(words, (List_compare)strcmp); 52 mu_assert(rc == 0, "Falha do Bubble sort numa lista vazia."); 53 mu_assert(is_sorted(words), "Palavras deveriam estar ordenadas se lista vazia." List_destroy(words); return NULL; 58 } char *test_merge_sort() 61 { 62 List *words = create_words(); // Deve funcionar numa lista que precise ser ordenada 65 List *res = List_merge_sort(words, (List_compare)strcmp); 66 mu_assert(is_sorted(res), "Palavras não estão ordenadas após merge sort."); List *res2 = List_merge_sort(res, (List_compare)strcmp); João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 9 / 20

10 Unidade de teste: list_algos_test.c 4/4 69 mu_assert(is_sorted(res), "Deveria estar ordenada após merge sort."); 70 List_destroy(res2); 71 List_destroy(res); List_destroy(words); 74 return NULL; 75 } char *all_tests() 79 { 80 mu_suite_start(); mu_run_test(test_bubble_sort); 83 mu_run_test(test_merge_sort); return NULL; 86 } RUN_TESTS(all_tests); João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 10 / 20

11 Exercício Comece com o bubble sort e certique-se que ele funciona, só então passe para o merge sort. Faça os protótipos de função para que todos os três arquivos compilem, porém sem passar nos testes. Então preecha cada um deles até começar a funcionar. Não contiue a ler até ter feito esta tarefa. Depois compare sua solução com a fornecida mais adiante. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 11 / 20

12 src/lcthw/list_algos.h 1 #ifndef lcthw_list_algos_h 2 #define lcthw_list_algos_h 3 4 #include <lcthw/list.h> 5 6 typedef int (*List_compare)(const void *a, const void *b); 7 8 int List_bubble_sort(List *list, List_compare cmp); 9 10 List *List_merge_sort(List *list, List_compare cmp); #endif João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 12 / 20

13 src/lcthw/list_algos.c 1/4 1 #include <lcthw/list_algos.h> 2 #include <lcthw/dbg.h> 3 4 inline void ListNode_swap(ListNode *a, ListNode *b) 5 { 6 void *temp = a->value; 7 a->value = b->value; 8 b->value = temp; 9 } int List_bubble_sort(List *list, List_compare cmp) 12 { 13 int sorted = 1; if(list_count(list) <= 1) { 16 return 0; // já ordenada 17 } do { 20 sorted = 1; 21 LIST_FOREACH(list, first, next, cur) { 22 if(cur->next) { João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 13 / 20

14 src/lcthw/list.c 2/4 23 if(cmp(cur->value, cur->next->value) > 0) { 24 ListNode_swap(cur, cur->next); 25 sorted = 0; 26 } 27 } 28 } 29 } while(!sorted); return 0; 32 } inline List *List_merge(List *left, List *right, List_compare cmp) 35 { 36 List *result = List_create(); 37 void *val = NULL; while(list_count(left) > 0 List_count(right) > 0) { 40 if(list_count(left) > 0 && List_count(right) > 0) { 41 if(cmp(list_first(left), List_first(right)) <= 0) { 42 val = List_shift(left); 43 } else { 44 val = List_shift(right); João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 14 / 20

15 src/lcthw/list.c 3/4 45 } List_push(result, val); 48 } else if(list_count(left) > 0) { 49 val = List_shift(left); 50 List_push(result, val); 51 } else if(list_count(right) > 0) { 52 val = List_shift(right); 53 List_push(result, val); 54 } 55 } return result; 58 } List *List_merge_sort(List *list, List_compare cmp) 61 { 62 if(list_count(list) <= 1) { 63 return list; 64 } List *left = List_create(); João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 15 / 20

16 src/lcthw/list.c 4/4 67 List *right = List_create(); 68 int middle = List_count(list) / 2; LIST_FOREACH(list, first, next, cur) { 71 if(middle > 0) { 72 List_push(left, cur->value); 73 } else { 74 List_push(right, cur->value); 75 } middle--; 78 } List *sort_left = List_merge_sort(left, cmp); 81 List *sort_right = List_merge_sort(right, cmp); if(sort_left!= left) List_destroy(left); 84 if(sort_right!= right) List_destroy(right); return List_merge(sort_left, sort_right, cmp); 87 } João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 16 / 20

17 O que obtemos? $ make all ar rcs build/liblcthw.a src/lcthw/list_algos.o src/lcthw/list.o ranlib build/liblcthw.a cc -shared -o build/liblcthw.so src/lcthw/list_algos.o src/lcth sh./tests/runtests.sh Executando a unidade de testes: ---- RUNNING:./tests/list_algos_tests ALL TESTS PASSED Tests run: 2 tests/list_algos_tests PASS João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 17 / 20

18 Como melhorar Existem várias formas de melhorar a implementação, aqui algumas óbvias: a ordenação merge gasta muito tempo copiando e criando listas, encontre maneiras de reduzir isso. A implementação da ordenação bubble da wikipedia menciona algumas possíveis otimizações, implemente-as. Você poderia usar List_split e List_join (se você implementá-las) para melhorar a ordenação merge? Cheque seu programa com olhos da programação defensiva, protegendo-o contra ponteiros nulos, e crie um nível de invariante de debug opcional que faça o que is_sorted faz após ordenar. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 18 / 20

19 Crédito extra Crédito extra Crie uma unidade de teste que compare o desempenho dos dois algoritmos. Você deve estudar man 3 time para entender as funções básicas do timer em C, mas deve executar iterações sucientes para ter alguns segundos de execução. Mude o montante de dados de as listas precisam ordenar e veja se isso muda sua temporização. Encontre um modo de simular o preenchimento de listas aleatórias de tamanhos diferentes e meça o tempo que isso toma, colocando num gráco e compare esse resultado com a descrição do algoritmo. Tente explicar porque ordenar listas encadeadas é uma má ideia. Implemente uma função List_insert_sorted que recebe um valor e o insere, usando List_compare, na sua posição correta, de modo que a lista esteja sempre ordenada. Como esse método se comparara com a ordenação da lista após sua construção completa? Tente implementar a ordenação merge bottom up da página da Wikipedia. O código já está em C e deve ser fácil recriá-lo, mas tente compreender como ele funciona comparado com o a implementação mais lenta usada aqui. João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 19 / 20

20 Crédito extra FIM João Araujo Ribeiro (UERJ) Laboratório de Programação LabProg 20 / 20