├── Modulo02 ├── src │ ├── 202202 │ │ ├── ordenacao.h │ │ ├── selecao.c │ │ ├── contagem.c │ │ ├── quick_sort.c │ │ ├── usaordenacao.c │ │ ├── radixsort.c │ │ └── heapsort.c │ ├── 202301 │ │ ├── comandos.txt │ │ ├── dicioestatico.h │ │ ├── vetordinamico.h │ │ ├── diciodinamico.h │ │ ├── ab.h │ │ ├── abb.h │ │ ├── avl.h │ │ ├── usade.c │ │ ├── vetordinamico.c │ │ ├── dicioestatico.c │ │ ├── usadd.c │ │ ├── ent01.txt │ │ ├── usabb.c │ │ ├── usavl.c │ │ ├── ent02.txt │ │ ├── diciodinamico.c │ │ ├── ab.c │ │ ├── abb.c │ │ └── avl.c │ └── .DS_Store ├── .DS_Store ├── docs │ ├── .DS_Store │ └── slides.md │ │ ├── tfidf.pdf │ │ ├── tfidf.data │ │ ├── tfidf.data.txt │ │ ├── tfidf.md │ │ └── Algoritmos e Estruturas de Dados II.md └── prova │ └── radix.c ├── .gitignore ├── .DS_Store ├── docs ├── questoes.pdf └── imgs │ ├── playList.png │ ├── myPlayList_1.png │ ├── myPlayList_2.png │ └── myPlayList_3.png ├── Modulo01 ├── .DS_Store ├── src │ ├── 202202 │ │ ├── pilha.h │ │ ├── fila.h │ │ ├── heap.h │ │ ├── listase.h │ │ ├── intercalando2.c │ │ ├── intercalando.c │ │ ├── pilha.c │ │ ├── usafila.c │ │ ├── intercalando3.c │ │ ├── usapilha.c │ │ ├── usafilacp.c │ │ ├── fila.c │ │ ├── tocador.c │ │ ├── heap.c │ │ └── listase.c │ ├── 202301 │ │ ├── medicao │ │ ├── fila.h │ │ ├── filacomprioridade.h │ │ ├── heap.h │ │ ├── listase.h │ │ ├── fila.c │ │ ├── filacomprioridade.c │ │ ├── usaheap.c │ │ ├── medidor.c │ │ ├── heap.c │ │ └── listase.c │ └── .DS_Store └── docs │ ├── slides.pdf │ ├── imgs │ ├── fila.png │ ├── exemplo01.png │ ├── exemplo02.png │ ├── exemplo03.png │ ├── representaTAD.png │ ├── elemento_lse.svg │ ├── refatorar.svg │ ├── vetor-intercalar-res.svg │ ├── representa.svg │ └── void.svg │ ├── projetos.pdf │ ├── readme.md │ ├── atividades.md │ └── projetos.md ├── Modulo04 ├── .DS_Store └── src │ └── bfs.c ├── Modulo03 ├── 202202 │ └── src │ │ ├── carro.h │ │ ├── arv_bb.h │ │ ├── carro.c │ │ ├── usa_arv.c │ │ ├── ab.c │ │ └── arv_bb.c ├── docs │ ├── amostra.dat │ ├── sobreArvores.pdf │ ├── sobreArvores.md │ └── estrutura.drawio.svg ├── fabricados.txt ├── heap.h ├── radix.c ├── counting.c ├── quick_sort.c └── heap.c └── README.md /Modulo02/src/202301/comandos.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.vscode 2 | *.o 3 | *.out 4 | docs/questoes.md -------------------------------------------------------------------------------- /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/.DS_Store -------------------------------------------------------------------------------- /docs/questoes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/docs/questoes.pdf -------------------------------------------------------------------------------- /Modulo01/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/.DS_Store -------------------------------------------------------------------------------- /Modulo02/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo02/.DS_Store -------------------------------------------------------------------------------- /Modulo04/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo04/.DS_Store -------------------------------------------------------------------------------- /Modulo01/src/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/src/.DS_Store -------------------------------------------------------------------------------- /Modulo02/src/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo02/src/.DS_Store -------------------------------------------------------------------------------- /docs/imgs/playList.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/docs/imgs/playList.png -------------------------------------------------------------------------------- /Modulo01/docs/slides.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/slides.pdf -------------------------------------------------------------------------------- /Modulo02/docs/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo02/docs/.DS_Store -------------------------------------------------------------------------------- /Modulo01/docs/imgs/fila.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/imgs/fila.png -------------------------------------------------------------------------------- /Modulo01/docs/projetos.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/projetos.pdf -------------------------------------------------------------------------------- /Modulo01/src/202301/medicao: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/src/202301/medicao -------------------------------------------------------------------------------- /Modulo03/docs/amostra.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo03/docs/amostra.dat -------------------------------------------------------------------------------- /docs/imgs/myPlayList_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/docs/imgs/myPlayList_1.png -------------------------------------------------------------------------------- /docs/imgs/myPlayList_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/docs/imgs/myPlayList_2.png -------------------------------------------------------------------------------- /docs/imgs/myPlayList_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/docs/imgs/myPlayList_3.png -------------------------------------------------------------------------------- /Modulo01/docs/imgs/exemplo01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/imgs/exemplo01.png -------------------------------------------------------------------------------- /Modulo01/docs/imgs/exemplo02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/imgs/exemplo02.png -------------------------------------------------------------------------------- /Modulo01/docs/imgs/exemplo03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/imgs/exemplo03.png -------------------------------------------------------------------------------- /Modulo03/docs/sobreArvores.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo03/docs/sobreArvores.pdf -------------------------------------------------------------------------------- /Modulo02/docs/slides.md/tfidf.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo02/docs/slides.md/tfidf.pdf -------------------------------------------------------------------------------- /Modulo01/docs/imgs/representaTAD.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/cesaramelo/CCESEC202202/HEAD/Modulo01/docs/imgs/representaTAD.png -------------------------------------------------------------------------------- /Modulo01/docs/readme.md: -------------------------------------------------------------------------------- 1 | # Sobre estes documentos 2 | 3 | Nesta pasta você irá encontrar os documentos produzidos para o módulo 01 da disciplina. 4 | 5 | * Dicas 6 | * Quiz 7 | * Enunciados 8 | 9 | -------------------------------------------------------------------------------- /Modulo02/src/202301/dicioestatico.h: -------------------------------------------------------------------------------- 1 | typedef struct dicio_estatico t_de; 2 | 3 | t_de* criar_dicio_estatico(); 4 | void inserir_de(t_de* de, int chave, void* carga); 5 | void* buscar_de(t_de *de, int chave); -------------------------------------------------------------------------------- /Modulo01/src/202301/fila.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct fila t_fila; 3 | 4 | t_fila* criar_fila(int tamanho); 5 | void enfileirar(t_fila* f, void* elem); 6 | void* desenfileirar(t_fila* f); 7 | int tamanho_fila(t_fila* f); 8 | 9 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # CCESEC202202 2 | 3 | Repositório da disciplina AED-II oferecida para os cursos de Engenharia de Software, Engenharia de Computação e Ciência da Computação. 4 | 5 | Disciplina Oferecida no Primeiro Semestre 2023. 6 | 7 | -------------------------------------------------------------------------------- /Modulo02/src/202301/vetordinamico.h: -------------------------------------------------------------------------------- 1 | typedef struct vd t_vd; 2 | 3 | t_vd* criar_vd(); 4 | void* acessar_vd(t_vd* vd, int pos); 5 | void inserir_vd(t_vd* vd, void* elem); 6 | int ocupacao_vd(t_vd* vd); 7 | void* remover_vd(t_vd* vd, int pos); -------------------------------------------------------------------------------- /Modulo01/src/202202/pilha.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct pilha t_pilha; 3 | t_pilha* criar_pilha(int max_altura); 4 | short empilhar(t_pilha* p, void* elem); 5 | void* desempilhar(t_pilha* p); 6 | void* topo_pilha(t_pilha *p); 7 | int altura_pilha(t_pilha* p); 8 | -------------------------------------------------------------------------------- /Modulo01/src/202202/fila.h: -------------------------------------------------------------------------------- 1 | typedef struct fila t_fila; 2 | 3 | t_fila* criar_fila(int tamanho); 4 | int enfileirar(t_fila* f, void* elem); 5 | void* desenfileirar(t_fila* f); 6 | void* primeiro_fila(t_fila* f); 7 | int tamanho_fila(t_fila* f); 8 | int ocupacao_fila(t_fila* f); 9 | -------------------------------------------------------------------------------- /Modulo02/src/202301/diciodinamico.h: -------------------------------------------------------------------------------- 1 | typedef int(*t_comparar_dd)(void* carga1, void* carga2); 2 | typedef struct dicio_dinamico t_dd; 3 | 4 | t_dd* criar_dd(int fator_carga, int tam); 5 | int inserir_dd(t_dd *dd, int chave, void*carga); 6 | void* consultar_dd(t_dd *dd, int chave); 7 | void* remover_dd(t_dd *dd, int chave); 8 | -------------------------------------------------------------------------------- /Modulo03/202202/src/carro.h: -------------------------------------------------------------------------------- 1 | typedef struct carro t_carro; 2 | 3 | t_carro* criar_carro(char placa[], int hora, int min, int anoFab); 4 | void destroy_carro(t_carro *c); 5 | void imprimir_carro(t_carro* c); 6 | int comparar_carro(t_carro* c1, t_carro* c2); 7 | t_carro* ler_carro(); 8 | void* ler_chave_carro(char* placa); 9 | -------------------------------------------------------------------------------- /Modulo02/src/202301/ab.h: -------------------------------------------------------------------------------- 1 | typedef int(*t_comparar_ab)(void* i1, void* i2 ); 2 | typedef struct ab t_ab; 3 | 4 | t_ab* criar_ab(t_comparar_ab comparar); 5 | int altura_ab(t_ab *ab); 6 | int tamanho_ab(t_ab *ab); 7 | void* buscar_ab(t_ab *ab, void* chave); 8 | void inserir_ab(t_ab *ab, void* info); 9 | void podar_ab(t_ab *ab, void* podavel); -------------------------------------------------------------------------------- /Modulo03/fabricados.txt: -------------------------------------------------------------------------------- 1 | JWF1045 10 25 2011 2 | JWF1040 10 26 2012 3 | JWF1145 10 20 2010 4 | JWF1345 10 10 2013 5 | JWF1055 10 19 2009 6 | JWF1675 11 20 2011 7 | JWF1895 11 10 2010 8 | JWF1046 11 21 2008 9 | JWF1030 10 30 2010 10 | JWF1040 11 20 2011 11 | FIM 12 | JWF1030 13 | JWF1895 14 | JWF1046 15 | JWF1040 16 | FIM 17 | JWF1055 18 | JWF1675 19 | JWF1895 20 | FIM -------------------------------------------------------------------------------- /Modulo01/src/202202/heap.h: -------------------------------------------------------------------------------- 1 | typedef int(*TCompararHeap)(void*, void*); 2 | 3 | typedef struct heap t_heap; 4 | 5 | t_heap* criar_heap(int tam, TCompararHeap comparar); 6 | int inserir_heap(t_heap* h, void* elem); 7 | void* remover_heap(t_heap* h); 8 | void* raiz_heap(t_heap* h); 9 | int popular_heap(t_heap* h, void* elem); 10 | int ocupacao_heap(t_heap* h); 11 | int tamanho_heap(t_heap* h); -------------------------------------------------------------------------------- /Modulo01/src/202301/filacomprioridade.h: -------------------------------------------------------------------------------- 1 | typedef int(*TCompararFilaCP)(void*,void*); 2 | 3 | typedef struct fila_cp t_fila_cp; 4 | t_fila_cp* criar_fila_cp(int tam, TCompararFilaCP comparar); 5 | int enfileirarCP(t_fila_cp *f, void* elem); 6 | void* desenfileirarCP(t_fila_cp *f); 7 | void* primeiro_FCP(t_fila_cp *f); 8 | int ocupacao_FCP(t_fila_cp *f); 9 | int tamanho_FCP(t_fila_cp *f); 10 | -------------------------------------------------------------------------------- /Modulo03/heap.h: -------------------------------------------------------------------------------- 1 | typedef int(*t_heap_comparar)(void*, void*); 2 | typedef struct heap t_heap; 3 | t_heap* criar_heap(int tamanho, t_heap_comparar comparar); 4 | void* primeiro_heap(t_heap* heap); 5 | void* remover_heap(t_heap* heap); 6 | void sobe_heap(void* elems[], int i, t_heap_comparar comparar); 7 | void inserir_heap(t_heap* heap, void* elem); 8 | void alterar_heap(t_heap* heap, void* chave, void* elem); 9 | -------------------------------------------------------------------------------- /Modulo01/src/202301/heap.h: -------------------------------------------------------------------------------- 1 | typedef int(*t_heap_comparar)(void*, void*); 2 | typedef struct heap t_heap; 3 | t_heap* criar_heap(int tamanho, t_heap_comparar comparar); 4 | void* primeiro_heap(t_heap* heap); 5 | void* remover_heap(t_heap* heap); 6 | void sobe_heap(void* elems[], int i, t_heap_comparar comparar); 7 | void inserir_heap(t_heap* heap, void* elem); 8 | void alterar_heap(t_heap* heap, void* chave, void* elem); 9 | -------------------------------------------------------------------------------- /Modulo02/src/202202/ordenacao.h: -------------------------------------------------------------------------------- 1 | typedef int(*TCompararHeapsort)(void*, void*); 2 | typedef int(*TCompararQS)(void*, void*); 3 | typedef int(*TLerIdRadixSort)(void*); 4 | typedef int(*TLerIdContagem)(void*); 5 | 6 | void heap_sort(void* vetor[], int tam, TCompararHeapsort comparar); 7 | void quicksort(void* vetor[], int lim_i, int lim_f, TCompararQS comparar); 8 | void radix_sort(void* vetor[], int tam, int digs, TLerIdRadixSort ler_id); 9 | void contagem(void* vetor[], int tam, int tam_c, TLerIdContagem ler_id); 10 | -------------------------------------------------------------------------------- /Modulo03/202202/src/arv_bb.h: -------------------------------------------------------------------------------- 1 | typedef void(*TImprimirABB)(void* info); 2 | typedef int(*TCompararABB)(void* s1, void* s2); 3 | typedef struct abb t_abb; 4 | 5 | t_abb* criarABB(TImprimirABB imprimir, TCompararABB comparar); 6 | void estatisticaABB(t_abb *abb); 7 | void inserirABB(t_abb *abb, void* info); 8 | void* buscarABB(t_abb *abb, void* buscado); 9 | void removerABB(t_abb *abb, void* removivel); 10 | void podarABB(t_abb* abb, void* info); 11 | int alturaABB(t_abb *abb); 12 | int tamanhoABB(t_abb *abb); 13 | void imprimirABB(t_abb* abb); 14 | -------------------------------------------------------------------------------- /Modulo01/src/202301/listase.h: -------------------------------------------------------------------------------- 1 | 2 | typedef void (*t_imprimir_lse)(void*); 3 | typedef int (*t_comparar_lse)(void*, void*); 4 | 5 | typedef struct lse t_lse; 6 | t_lse* criar_lse(t_imprimir_lse imprimir, t_comparar_lse comparar); 7 | 8 | void inserir_lse(t_lse* lse, void* carga_util); 9 | void inserir_final_lse(t_lse* lse, void* carga_util); 10 | 11 | void* remover_inicio_lse(t_lse* lse); 12 | void* remover_lse(t_lse* lse, void* chave); 13 | void* acessar_lse(t_lse* lse, int pos); 14 | 15 | void imprimir_lse(t_lse *lse); 16 | void* buscar_lse(t_lse* lse, void* chave); -------------------------------------------------------------------------------- /Modulo02/src/202301/abb.h: -------------------------------------------------------------------------------- 1 | typedef struct abb t_abb; 2 | typedef int(*t_comparar_abb)(void* e1, void* e2); 3 | typedef void(*t_destruir_abb)(void* info); 4 | typedef void(*t_imprimir_abb)(void* info); 5 | 6 | t_abb* criar_abb(t_comparar_abb comparar, t_destruir_abb destruir, t_imprimir_abb imprimir); 7 | int altura_abb(t_abb *abb); 8 | int tamanho_abb(t_abb *abb); 9 | void* buscar_abb(t_abb *abb, void* chave); 10 | void inserir_abb(t_abb *abb, void* info); 11 | void podar_abb(t_abb *abb, void* podavel); 12 | void imprimir_abb(t_abb *abb); 13 | void remover_abb(t_abb *abb, void* chave); -------------------------------------------------------------------------------- /Modulo02/src/202301/avl.h: -------------------------------------------------------------------------------- 1 | typedef struct avl t_avl; 2 | typedef int(*t_comparar_avl)(void* e1, void* e2); 3 | typedef void(*t_destruir_avl)(void* info); 4 | typedef void(*t_imprimir_avl)(void* info); 5 | 6 | t_avl* criar_avl(t_comparar_avl comparar, t_destruir_avl destruir, t_imprimir_avl imprimir); 7 | int altura_avl(t_avl *avl); 8 | int tamanho_avl(t_avl *avl); 9 | void* buscar_avl(t_avl *avl, void* chave); 10 | void inserir_avl(t_avl *avl, void* info); 11 | void podar_avl(t_avl *avl, void* podavel); 12 | void imprimir_avl(t_avl *avl); 13 | void remover_avl(t_avl *avl, void* chave); -------------------------------------------------------------------------------- /Modulo02/src/202202/selecao.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | 3 | void selecao(int vetor[], int tam){ 4 | for(int i=0;i=1;i--){ 17 | for(int j=i-1;j>=0;j--){ 18 | if (vetor[j]>vetor[j+1]){ 19 | trocar(vetor,j,j+1); 20 | } 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Modulo01/src/202202/listase.h: -------------------------------------------------------------------------------- 1 | typedef struct lse t_lse; 2 | 3 | typedef void(*t_imprimir_lse)(void*); 4 | typedef int (*t_comparar_lse)(void* carga_na_lista, void* nova_carga); 5 | 6 | t_lse* criar_lse(t_imprimir_lse impressora, t_comparar_lse comparar); 7 | 8 | // operacoes baseadas em posicao 9 | void inserir_inicio_lse(t_lse* lse, void* carga); 10 | void* remover_inicio_lse(t_lse* lse); 11 | void* acessar_lse(t_lse* lse, int pos); 12 | void inserir_final_lse(t_lse* lse, void* carga); 13 | void* remover_final_lse(t_lse* lse); 14 | void imprimir_lse(t_lse* lse); 15 | void* remover_lse(t_lse* lse, void* chave); 16 | void* buscar_lse(t_lse* lse, void* chave); 17 | void inserir_lse(t_lse* lse, void* carga); 18 | 19 | -------------------------------------------------------------------------------- /Modulo02/docs/slides.md/tfidf.data: -------------------------------------------------------------------------------- 1 | Palavra| Página 1 | Página 2 | Página 3 | 2 | ------ | -------- | -------- | -------- | 3 | Maria | $0.16\times1.09 = 0.1744$ | 4 | vai | $0.1744$ | 5 | para | $0.1744$ | 6 | praia| $0.16\times0.0 = 0.0$ | $0.12\times0.0 = 0.0$ | $0.16\times0.0 = 0.0$ | 7 | tomar | $0.16\times1.09 = 0.1744$ | 8 | sol | $0.16\times0.41 = 0.0656$ | 9 | na | | $0.12\times1.09 = 0.1308$ | 10 | havia | | $0.1308$ | | 11 | uma | | $0.1308$ | 12 | barraca | | $0.12\times1.09=0.1208$ | 13 | e | | $0.12\times0.41 = 0.0492$ | $0.16\times0.41=0,0656$| 14 | cadeira | | $0.12\times1.09=0.1208$ | | 15 | combina | | | $0.16\times1.09= 0.1744$ | 16 | com | | | $0.1744$ | 17 | domingo| | | $0.1744$ | 18 | 19 | -------------------------------------------------------------------------------- /Modulo02/docs/slides.md/tfidf.data.txt: -------------------------------------------------------------------------------- 1 | Palavra| Página 1 | Página 2 | Página 3 | 2 | ------ | -------- | -------- | -------- | 3 | Maria | $0.16\times1.09 = 0.1744$ | 4 | vai | $0.1744$ | 5 | para | $0.1744$ | 6 | praia| $0.16\times0.0 = 0.0$ | $0.12\times0.0 = 0.0$ | $0.16\times0.0 = 0.0$ | 7 | tomar | $0.16\times1.09 = 0.1744$ | 8 | sol | $0.16\times0.41 = 0.0656$ | 9 | na | | $0.12\times1.09 = 0.1308$ | 10 | havia | | $0.1308$ | | 11 | uma | | $0.1308$ | 12 | barraca | | $0.12\times1.09=0.1208$ | 13 | e | | $0.12\times0.41 = 0.0492$ | $0.16\times0.41=0,0656$| 14 | cadeira | | $0.12\times1.09=0.1208$ | | 15 | combina | | | $0.16\times1.09= 0.1744$ | 16 | com | | | $0.1744$ | 17 | domingo| | | $0.1744$ | 18 | 19 | -------------------------------------------------------------------------------- /Modulo02/src/202301/usade.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "dicioestatico.h" 4 | 5 | static int char_to_int(char* pal){ 6 | int chave=0; 7 | int pesos[] = {10,20,5,700,2}; 8 | for(int i=0;itamanho = tamanho; 15 | f->ocupa=0; 16 | f->elementos = criar_lse(NULL,NULL); 17 | return f; 18 | } 19 | void enfileirar(t_fila* f, void* elem){ 20 | if (f){ 21 | f->ocupa++; 22 | inserir_final_lse(f->elementos, elem); 23 | } 24 | } 25 | 26 | void* desenfileirar(t_fila* f){ 27 | void* elem = NULL; 28 | if (f && (f->ocupa>0)){ 29 | elem = remover_inicio_lse(f->elementos); 30 | f->ocupa--; 31 | } 32 | return elem; 33 | } 34 | 35 | int tamanho_fila(t_fila* f){ 36 | return f->ocupa; 37 | } 38 | 39 | -------------------------------------------------------------------------------- /Modulo02/src/202202/contagem.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "math.h" 3 | #include "ordenacao.h" 4 | 5 | void contagem(void* vetor_A[], int tam, int tam_c, TLerIdContagem ler_id){ 6 | //int tam_c = maior(vetor_A, tam); 7 | 8 | void* vetor_B[tam]; 9 | int vetor_C[tam_c]; 10 | 11 | for(int i=0;i=0;i--){ 25 | int k = ler_id(vetor_A[i]); 26 | int j = vetor_C[k]; 27 | vetor_B[j-1] = vetor_A[i]; 28 | vetor_C[k] = vetor_C[k] - 1; 29 | } 30 | 31 | for(int i=0;iheap = criar_heap(tam, comparar); 16 | 17 | return fcp; 18 | 19 | } 20 | 21 | int enfileirarCP(t_fila_cp *f, void* elem){ 22 | 23 | return inserir_heap(f->heap, elem); 24 | 25 | } 26 | 27 | void* desenfileirarCP(t_fila_cp *f){ 28 | 29 | return remover_heap(f->heap); 30 | } 31 | 32 | void* primeiro_FCP(t_fila_cp *f){ 33 | 34 | return raiz_heap(f->heap); 35 | 36 | } 37 | 38 | int ocupacao_FCP( t_fila_cp *f){ 39 | return ocupacao_heap(f->heap); 40 | } 41 | 42 | int tamanho_FCP(t_fila_cp *f){ 43 | return tamanho_heap(f->heap); 44 | } 45 | -------------------------------------------------------------------------------- /Modulo01/src/202202/intercalando2.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | 3 | 4 | int main(int argc, char const *argv[]) 5 | { 6 | int tam_EC = 3; 7 | int tam_CC = 3; 8 | double notas_EC[] = {8.0,8.0,8.0}; 9 | double notas_CC[] = {8.0,8.5,9.0}; 10 | double medias[tam_CC+tam_EC]; 11 | int j=0, k=0, l=0; 12 | while((j notas_CC[k]){ 14 | medias[l] = notas_CC[k]; 15 | k++; 16 | }else{ 17 | medias[l] = notas_EC[j]; 18 | j++; 19 | } 20 | l++; 21 | } 22 | while(kchave - cc2->chave); 15 | } 16 | 17 | t_carga* criar_carga(int chave, char* msg){ 18 | t_carga* c= malloc(sizeof(t_carga)); 19 | c->chave=chave; 20 | strcpy(c->msg,msg); 21 | 22 | return c; 23 | } 24 | 25 | int main(){ 26 | t_heap *h = criar_heap(11, comparar_carga); 27 | for (int i=0;i<10;i++){ 28 | 29 | t_carga *c = criar_carga(i, "mesma msg"); 30 | printf("%p %d\n", c, c->chave); 31 | inserir_heap(h, c); 32 | } 33 | for (int i=0;i<10;i++){ 34 | t_carga *c = remover_heap(h); 35 | printf("%d %s\n",c->chave, c->msg); 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /Modulo01/src/202202/intercalando.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | 3 | 4 | void intercalar(double vetor[], int k, int l, int m){ 5 | double aux[m-k+1]; 6 | int ki = k; 7 | int mi = l+1; 8 | int n=0; 9 | while( (ki<=l) && (mi<=m) ){ 10 | if (vetor[ki] 0){ 41 | int meio = particionamento(vetor, lim_i, lim_f, comparar); 42 | quicksort(vetor, lim_i, meio-1, comparar); 43 | quicksort(vetor, meio+1, lim_f, comparar); 44 | } 45 | } -------------------------------------------------------------------------------- /Modulo02/src/202301/vetordinamico.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "vetordinamico.h" 3 | 4 | struct vd{ 5 | void* *elems; 6 | int tamanho; 7 | int ocupa; 8 | }; 9 | 10 | t_vd* criar_vd(int tam){ 11 | 12 | t_vd* vd = malloc(sizeof(t_vd)); 13 | vd->tamanho=tam; 14 | vd->elems = malloc(sizeof(void*)*vd->tamanho); 15 | vd->ocupa=0; 16 | 17 | return vd; 18 | } 19 | 20 | void* acessar_vd(t_vd* vd, int pos){ 21 | if (pos < vd->ocupa){ 22 | return vd->elems[pos]; 23 | } 24 | return NULL; 25 | } 26 | 27 | void inserir_vd(t_vd* vd, void* elem){ 28 | 29 | if (vd->ocupa == vd->tamanho){ 30 | vd->tamanho = vd->tamanho*2; 31 | vd->elems = realloc(vd->elems,sizeof(void*)*vd->tamanho); 32 | } 33 | vd->elems[vd->ocupa] = elem; 34 | vd->ocupa++; 35 | } 36 | 37 | int ocupacao_de(t_vd* vd){ 38 | return vd->ocupa; 39 | } 40 | 41 | void* remover_vd(t_vd* vd, int pos){ 42 | if (pos < vd->ocupa){ 43 | void* carga = vd->elems[pos]; 44 | for (int i=pos;iocupa-1;i++){ 45 | vd->elems[i] = vd->elems[i+1]; 46 | } 47 | vd->ocupa--; 48 | vd->elems[vd->ocupa] = NULL; 49 | return carga; 50 | } 51 | return NULL; 52 | } 53 | 54 | 55 | 56 | -------------------------------------------------------------------------------- /Modulo01/src/202202/pilha.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "stdio.h" 3 | #include "listase.h" 4 | #include "pilha.h" 5 | 6 | struct pilha{ 7 | t_lse *elems; //container de elems 8 | int max_altura; 9 | int altura; 10 | }; 11 | 12 | t_pilha* criar_pilha(int max_altura){ 13 | t_pilha *p = malloc(sizeof(t_pilha)); 14 | p->altura = 0; 15 | p->max_altura = max_altura; // se <=0 pilha de altura infinita 16 | p->elems = criar_lse(NULL,NULL); 17 | 18 | return p; 19 | } 20 | 21 | short empilhar(t_pilha* p, void* elem){ 22 | short infinita = (p->max_altura<=0?1:0); 23 | short empilhou = 1; 24 | 25 | if ((p!=NULL) && ((infinita) || ((p->altura+1) <= p->max_altura))){ 26 | inserir_inicio_lse(p->elems,elem); 27 | p->altura++; 28 | }else{ 29 | empilhou = 0; 30 | } 31 | 32 | return empilhou; 33 | } 34 | 35 | void* desempilhar(t_pilha* p){ 36 | void* elem = NULL; 37 | if ((p!=NULL) && (p->altura>=1)){ 38 | elem = remover_inicio_lse(p->elems); 39 | p->altura--; 40 | } 41 | return elem; 42 | } 43 | 44 | void* topo_pilha(t_pilha *p){ 45 | if((p!=NULL) && (p->altura>0)) 46 | return acessar_lse(p->elems,1); 47 | else 48 | return NULL; 49 | } 50 | 51 | int altura_pilha(t_pilha* p){ 52 | 53 | return (p!=NULL?p->altura:-1); 54 | 55 | } 56 | 57 | 58 | 59 | -------------------------------------------------------------------------------- /Modulo01/src/202202/usafila.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | #include "fila.h" 5 | 6 | typedef struct carro{ 7 | char placa[8]; 8 | int hora, min; 9 | }t_carro; 10 | 11 | t_carro* criar_carro(char placa[], int hora, int min){ 12 | t_carro *c = malloc(sizeof(t_carro)); 13 | 14 | strcpy(c->placa,placa); 15 | c->hora = hora; 16 | c->min = min; 17 | 18 | return c; 19 | } 20 | 21 | void destroy_carro(t_carro *c){ 22 | free(c); 23 | } 24 | 25 | void imprimir_carro(t_carro* c){ 26 | 27 | printf("Placa: %s %d:%d\n", c->placa, c->hora, c->min); 28 | 29 | } 30 | 31 | int main(int argc, char const *argv[]) 32 | { 33 | t_fila* estacionados = criar_fila(10); 34 | 35 | char placa[8]="placa"; 36 | int hora, min; 37 | 38 | scanf("%s", placa); 39 | while(strcmp(placa,"FIM")!=0){ 40 | scanf("%d",&hora); 41 | scanf("%d",&min); 42 | 43 | t_carro* novo = criar_carro(placa, hora, min); 44 | 45 | enfileirar(estacionados, novo); 46 | scanf("%s", placa); 47 | } 48 | 49 | t_carro* saindo = desenfileirar(estacionados); 50 | 51 | imprimir_carro(saindo); 52 | printf("Ocupacao: %d\n", ocupacao_fila(estacionados)); 53 | 54 | printf("Tem vaga?:",(ocupacao_fila(estacionados)= 0; i--) { 24 | output[count[ pega_digito(array[i],d) ] - 1] = array[i]; 25 | count[ pega_digito(array[i],d) ]--; 26 | } 27 | 28 | // Copy the sorted elements into original array 29 | for (int i = 0; i < size; i++) { 30 | array[i] = output[i]; 31 | } 32 | } 33 | 34 | 35 | void radix(int vetor[], int tam, int nro_dig){ 36 | 37 | // 38 | for(int d=1;d<=nro_dig;d++){ 39 | counting_sort(vetor,tam, d); 40 | } 41 | } 42 | 43 | int main(int argc, char const *argv[]) 44 | { 45 | int tam=5; 46 | int vetor[] = {10,3,100,15,24}; 47 | 48 | radix(vetor,tam,3); 49 | 50 | for(int i=0;iplaca,placa); 16 | c->hora = hora; 17 | c->min = min; 18 | c->anoFabricacao = anoFab; 19 | 20 | return c; 21 | } 22 | 23 | t_carro* ler_carro(){ 24 | t_carro* novo=malloc(sizeof(t_carro)); 25 | scanf("%s", novo->placa); 26 | if (strcmp(novo->placa, "FIM")!=0){ 27 | scanf("%d", &(novo->hora)); 28 | scanf("%d", &(novo->min)); 29 | scanf("%d",&(novo->anoFabricacao)); 30 | }else{ 31 | free(novo); 32 | novo=NULL; 33 | } 34 | return novo; 35 | } 36 | 37 | void destroy_carro(t_carro *c){ 38 | free(c); 39 | } 40 | 41 | void* ler_chave_carro(char* placa){ 42 | placa =(placa==NULL?malloc(12):placa); 43 | scanf("%s", placa); 44 | if(strcmp(placa,"FIM")==0){ 45 | free(placa); 46 | return NULL; 47 | }else{ 48 | return placa; 49 | } 50 | } 51 | 52 | void imprimir_carro(t_carro* c){ 53 | if (c) 54 | printf("Placa: %s %d:%d %d\n", c->placa, c->hora, c->min, c->anoFabricacao); 55 | 56 | } 57 | 58 | int comparar_carro(t_carro* c1, t_carro* c2){ 59 | return strcmp(c1->placa,c2->placa); 60 | } 61 | 62 | -------------------------------------------------------------------------------- /Modulo01/src/202301/medidor.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "fila.h" 4 | 5 | typedef struct medicao t_medicao; 6 | struct medicao{ 7 | int hora, min; 8 | double temp; 9 | }; 10 | 11 | t_medicao* criar_medicao(int hora, int min, double temp){ 12 | t_medicao* m = malloc(sizeof(t_medicao)); 13 | m->temp = temp; 14 | m->hora = hora; 15 | m->min = min; 16 | 17 | return m; 18 | } 19 | 20 | void imprimir_medicao(void* m){ 21 | t_medicao *mm = m; // casting 22 | printf("%02d:%02d %.2lf\n", mm->hora, mm->min, mm->temp); 23 | 24 | } 25 | 26 | int comparar_medicao(void* m1, void* m2){ 27 | 28 | return 1; 29 | } 30 | 31 | t_medicao* ler_medicao(){ 32 | int hora, min; 33 | double temp; 34 | 35 | scanf("%d", &hora); 36 | if (hora >= 0){ 37 | scanf("%d", &min); 38 | scanf("%lf", &temp); 39 | return criar_medicao(hora, min, temp); 40 | } 41 | return NULL; 42 | } 43 | 44 | int main(int argc, char const *argv[]) 45 | { 46 | short ainda_tem=1; 47 | //t_lse* medicoes = criar_lse(imprimir_medicao, comparar_medicao); 48 | t_fila* medicoes = criar_fila(0); 49 | while(ainda_tem){ 50 | t_medicao* nova = ler_medicao(); 51 | if (nova){ 52 | enfileirar(medicoes, nova); 53 | }else{ 54 | ainda_tem = 0; // falso 55 | } 56 | } 57 | 58 | t_medicao* m = desenfileirar(medicoes); 59 | imprimir_medicao(m); 60 | 61 | return 0; 62 | } 63 | 64 | 65 | 66 | -------------------------------------------------------------------------------- /Modulo03/counting.c: -------------------------------------------------------------------------------- 1 | // Counting sort in C programming 2 | 3 | #include 4 | 5 | void countingSort(int array[], int size) { 6 | // Find the largest element of the array 7 | int max = array[0]; 8 | for (int i = 1; i < size; i++) { 9 | if (array[i] > max) 10 | max = array[i]; 11 | } 12 | 13 | int count[max+1]; 14 | 15 | // Initialize count array with all zeros. 16 | for (int i = 0; i <= max; ++i) { 17 | count[i] = 0; 18 | } 19 | 20 | // Store the count of each element 21 | for (int i = 0; i < size; i++) { 22 | count[array[i]]++; 23 | } 24 | 25 | // Store the cummulative count of each array 26 | for (int i = 1; i <= max; i++) { 27 | count[i] += count[i - 1]; 28 | } 29 | 30 | int output[size]; 31 | // Find the index of each element of the original array in count array, and 32 | // place the elements in output array 33 | for (int i = size - 1; i >= 0; i--) { 34 | output[count[array[i]] - 1] = array[i]; 35 | count[array[i]]--; 36 | } 37 | 38 | // Copy the sorted elements into original array 39 | for (int i = 0; i < size; i++) { 40 | array[i] = output[i]; 41 | } 42 | } 43 | 44 | // Function to print an array 45 | void printArray(int array[], int size) { 46 | for (int i = 0; i < size; ++i) { 47 | printf("%d ", array[i]); 48 | } 49 | printf("\n"); 50 | } 51 | 52 | // Driver code 53 | int main() { 54 | int array[] = {4, 2, 2, 8, 3, 3, 1}; 55 | int n = sizeof(array) / sizeof(array[0]); 56 | countingSort(array, n); 57 | printArray(array, n); 58 | } -------------------------------------------------------------------------------- /Modulo01/src/202202/intercalando3.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | 3 | void intercalar(double notas01[], int tam_notas01, double notas02[], int tam_notas02, double resultado[]){ 4 | int j=0, k=0, l=0; 5 | while((j notas02[k]){ 7 | resultado[l] = notas02[k]; 8 | k++; 9 | }else{ 10 | resultado[l] = notas01[j]; 11 | j++; 12 | } 13 | l++; 14 | } 15 | while(jcapacidade = capacidade; 16 | x->tipo = tipo; 17 | return x; 18 | } 19 | 20 | typedef struct { 21 | int tipo; // 1-sobremesa, 2-sopa, 3-casocontrario 22 | int lava_na_maquina; // 1 - sim 2 - Nao 23 | int diametro; // cm 24 | }t_prato; 25 | 26 | t_prato* criar_prato(int tipo, int lava_na_maquina, int diametro){ 27 | t_prato* p = malloc(sizeof(t_prato)); 28 | p->tipo = tipo; 29 | p->diametro = diametro; 30 | p->lava_na_maquina = lava_na_maquina; 31 | 32 | return p; 33 | } 34 | 35 | 36 | int main(int argc, char const *argv[]) 37 | { 38 | t_pilha *pratos = criar_pilha(0); // pilha infinita 39 | t_pilha *xicaras = criar_pilha(5); // pilha de altura max = 5 40 | 41 | for(int i=1;i<10;i++){ 42 | empilhar(pratos, criar_prato(1,1,20)); 43 | } 44 | 45 | t_xicara* x; 46 | int i=0; 47 | do{ 48 | x = criar_xicara(150,1); 49 | i++; 50 | }while(empilhar(xicaras, x)); 51 | free(x); 52 | i--; 53 | 54 | printf("altura pratos: %d", altura_pilha(pratos)); 55 | printf("altura xicaras: %d", altura_pilha(xicaras)); 56 | 57 | t_prato* p = desempilhar(pratos); 58 | // imprimir_prato(p); 59 | x = desempilhar(xicaras); 60 | // imprimir_xicara(x); 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /Modulo02/src/202202/usaordenacao.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "time.h" 4 | #include "ordenacao.h" 5 | 6 | int ler_int(void* elem){ 7 | 8 | return *((int*)elem); 9 | 10 | } 11 | 12 | int compararint(void* e1, void* e2){ 13 | int* ee1 = (int*)e1; 14 | int* ee2 = (int*)e2; 15 | return (*ee1 - *ee2); 16 | } 17 | 18 | int* *criar_vetor_inteiro(int tam, int lim_i, int lim_s){ 19 | int* *vetor = malloc(sizeof(int*)*tam); 20 | for(int i=0;i=0;i--){ 24 | int k = (int)(ler_id(vetor_A[i])/denominador)%10; 25 | int j = vetor_C[k]; 26 | vetor_B[j-1] = vetor_A[i]; 27 | vetor_C[k] = vetor_C[k] - 1; 28 | } 29 | 30 | for(int i=0;i%d\n", vetor_A[i]); 33 | } 34 | } 35 | 36 | void distribuindo(void* vetor_A[], int tam, int d, TLerIdRadixSort ler_id){ 37 | //int tam_c = maior(vetor_A, tam); 38 | 39 | void* vetor_B[tam]; 40 | 41 | //t_lse* caixas[10]; 42 | 43 | for(int i=0;i<10;i++){ 44 | //caixas[i] = criar_lse(NULL, NULL); 45 | } 46 | 47 | // Para ser implementado 48 | 49 | // usar a inserir no final 50 | 51 | // remover no inicio 52 | 53 | // reconstruir os vetor original 54 | 55 | } 56 | 57 | void radix_sort(void* vetor[], int tam, int digs, TLerIdRadixSort ler_id){ 58 | for(int i=0;ichave =chave; 12 | e->carga = carga; 13 | 14 | return e; 15 | } 16 | 17 | typedef struct dicio_estatico{ 18 | t_vd* vd; 19 | 20 | }t_de; 21 | 22 | t_de* criar_dicio_estatico(){ 23 | t_de* de = malloc(sizeof(t_de)); 24 | 25 | de->vd = criar_vd(); 26 | 27 | return de; 28 | } 29 | 30 | void inserir_de(t_de* de, int chave, void* carga){ 31 | 32 | inserir_vd(de->vd, criar_elem(chave,carga) ); 33 | 34 | } 35 | 36 | static int bb_de(t_de *de, int chave){ 37 | //busca_binaria 38 | int lim_i = 0; 39 | int lim_s = ocupacao_vd(de->vd); 40 | 41 | while(lim_i<=lim_s){ 42 | int pos = (lim_i+lim_s)/2; 43 | t_elem_de* e = acessar_vd(de->vd, pos); 44 | if (e->chave == chave){ 45 | return pos; 46 | }else if(e->chave > chave){ 47 | lim_s = pos-1; 48 | }else{ 49 | lim_i = pos+1; 50 | } 51 | } 52 | return -1; 53 | } 54 | 55 | void* buscar_de(t_de *de, int chave){ 56 | //busca_binaria 57 | int pos = bb_de(de, chave); 58 | 59 | if (pos>=0){ 60 | t_elem_de* e = acessar_vd(de->vd, pos); 61 | return e->carga; 62 | } 63 | return NULL; 64 | } 65 | 66 | void* remover_de(t_de* de, int chave){ 67 | //busca_binaria 68 | int pos = bb_de(de, chave); 69 | if (pos>=0){ 70 | t_elem_de* e = remover_vd(de->vd, pos); 71 | return e->carga; 72 | } 73 | return NULL; 74 | } -------------------------------------------------------------------------------- /Modulo01/src/202202/usafilacp.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | #include "filacomprioridade.h" 5 | 6 | typedef struct carro{ 7 | char placa[9]; 8 | int hora, min; 9 | }t_carro; 10 | 11 | t_carro* criar_carro(char placa[], int hora, int min){ 12 | t_carro *c = malloc(sizeof(t_carro)); 13 | 14 | strcpy(c->placa,placa); 15 | c->hora = hora; 16 | c->min = min; 17 | 18 | return c; 19 | } 20 | 21 | int compararCarro(void* c1, void* c2){ 22 | t_carro* cc1 = c1; 23 | t_carro* cc2 = c2; 24 | 25 | return strcmp(cc1->placa, cc2->placa); 26 | } 27 | 28 | void destroy_carro(t_carro *c){ 29 | free(c); 30 | } 31 | 32 | void imprimir_carro(t_carro* c){ 33 | 34 | printf("Placa: %s %d:%d\n", c->placa, c->hora, c->min); 35 | 36 | } 37 | 38 | int main(int argc, char const *argv[]) 39 | { 40 | t_fila_cp* estacionados = criar_fila_cp(-1, compararCarro); 41 | 42 | char placa[9]="placa"; 43 | int hora, min; 44 | 45 | scanf("%s", placa); 46 | while(strcmp(placa,"FIM")!=0){ 47 | scanf("%d",&hora); 48 | scanf("%d",&min); 49 | 50 | t_carro* novo = criar_carro(placa, hora, min); 51 | 52 | enfileirarCP(estacionados, novo); 53 | scanf("%s", placa); 54 | } 55 | 56 | int qtd_vagas; 57 | do{ 58 | t_carro* saindo = desenfileirarCP(estacionados); 59 | 60 | imprimir_carro(saindo); 61 | printf("Ocupacao: %d\n", ocupacao_FCP(estacionados)); 62 | 63 | qtd_vagas = (tamanho_FCP(estacionados)-ocupacao_FCP(estacionados)); 64 | 65 | printf("Quantas vagas?: %d\n",qtd_vagas); 66 | 67 | }while(qtd_vagas!=tamanho_FCP(estacionados)); 68 | 69 | return 0; 70 | } 71 | -------------------------------------------------------------------------------- /Modulo01/src/202202/fila.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "fila.h" 4 | 5 | struct fila{ 6 | void* *elems; 7 | int tamanho; 8 | int inicio; 9 | int fim; 10 | int ocupacao; 11 | short e_infinita; 12 | }; 13 | 14 | t_fila* criar_fila(int tamanho){ 15 | t_fila* f = malloc(sizeof(t_fila)); 16 | 17 | f->e_infinita = (tamanho<=0?1:0); 18 | f->tamanho = (tamanho<=0?1:tamanho); 19 | f->inicio = 0; 20 | f->fim = 0; 21 | f->ocupacao=0; 22 | 23 | f->elems = malloc(sizeof(void*)*f->tamanho); 24 | 25 | return f; 26 | 27 | } 28 | 29 | int enfileirar(t_fila* f, void* elem){ 30 | int status = 0; // fals0 31 | if ((f->e_infinita) && (f->ocupacao == f->tamanho)){ 32 | f->tamanho = f->tamanho*2; 33 | f->elems = realloc(f->elems, sizeof(void*)*f->tamanho); 34 | } 35 | if (f->ocupacao < f->tamanho){ 36 | f->elems[f->fim] = elem; 37 | f->fim = (f->fim+1) % f->tamanho; 38 | f->ocupacao++; 39 | status = 1; // verdade 40 | } 41 | 42 | return status; 43 | } 44 | 45 | void* desenfileirar(t_fila* f){ 46 | void* elem = NULL; 47 | 48 | if (f->ocupacao>0){ 49 | elem = f->elems[f->inicio]; 50 | f->inicio = (f->inicio+1) % f->tamanho; 51 | f->ocupacao--; 52 | } 53 | return elem; 54 | } 55 | 56 | void* primeiro_fila(t_fila* f){ 57 | void* primeiro=NULL; 58 | if((f!=NULL) && (f->ocupacao>0)){ 59 | primeiro = f->elems[f->inicio]; 60 | } 61 | return primeiro; 62 | } 63 | 64 | int tamanho_fila(t_fila* f){ 65 | if(f!=NULL){ 66 | return f->tamanho; 67 | } 68 | return -1; 69 | } 70 | 71 | int ocupacao_fila(t_fila* f){ 72 | if(f!=NULL){ 73 | return f->ocupacao; 74 | } 75 | return -1; 76 | } 77 | // Espaço TAD 78 | -------------------------------------------------------------------------------- /Modulo03/202202/src/usa_arv.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "./arv_bb.h" 4 | //#include "arv_avl.h" 5 | //#include "arv_red.h" 6 | #include "carro.h" 7 | //#include "medidas.h" 8 | 9 | int comparar_dado(void* s1, void* s2){ 10 | 11 | //return comparar_medida(s1,s2); 12 | return comparar_carro(s1, s2); 13 | } 14 | 15 | // ler os dados 16 | void* ler_dado(){ 17 | void* novo=NULL; 18 | //novo = ler_medida(); 19 | 20 | novo = ler_carro(); 21 | 22 | return novo; 23 | } 24 | 25 | void* ler_chave_dado(void* chave){ 26 | 27 | //chave = ler_chave_medida(chave); 28 | 29 | chave = ler_chave_carro(chave); 30 | return chave; 31 | } 32 | 33 | void destroy_dado(void* s1){ 34 | 35 | (s1!=NULL?free(s1):NULL); 36 | } 37 | 38 | void imprimir_dado(void* dado){ 39 | 40 | //imprimir_medida(dado); 41 | imprimir_carro(dado); 42 | } 43 | 44 | 45 | int main(int argc, char const *argv[]) 46 | { 47 | 48 | t_abb *arv = criarABB(imprimir_dado, comparar_dado); 49 | 50 | // inserir dados na abb; 51 | void* novo = ler_dado(); 52 | while(novo!=NULL){ 53 | inserirABB(arv, novo); 54 | 55 | novo = ler_dado(); 56 | } 57 | estatisticaABB(arv); 58 | 59 | // altura e tamanho 60 | printf("Altura: %d\n", alturaABB(arv)); 61 | printf("Tamanho: %d\n", tamanhoABB(arv)); 62 | 63 | // buscar dados 64 | void* chave = ler_chave_dado(NULL); 65 | while(chave!=NULL){ 66 | 67 | void* buscado = buscarABB(arv, chave); 68 | imprimir_dado(buscado); 69 | chave = ler_chave_dado(chave); 70 | } 71 | estatisticaABB(arv); 72 | 73 | // remover dados 74 | chave = ler_chave_dado(NULL); 75 | while(chave!=NULL){ 76 | 77 | removerABB(arv, chave); 78 | 79 | chave = ler_chave_dado(chave); 80 | } 81 | estatisticaABB(arv); 82 | 83 | return 0; 84 | } 85 | -------------------------------------------------------------------------------- /Modulo03/quick_sort.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | 4 | int comparar_int(int* p1, int* p2){ 5 | return (*p1 - *p2); 6 | } 7 | 8 | int* ler_int(){ 9 | int* inteiro = malloc(4); 10 | scanf("%d", inteiro); 11 | return inteiro; 12 | } 13 | 14 | void mostrar_int(int* inteiros[], int tam){ 15 | for(int i=0;i=0) && (comparar(vetor[j], vetor[fim])>0) ){ //> pivo 41 | j--; 42 | } 43 | if (i<=j){ // <= ou mat = mat; 17 | strcpy(novo->nome, nome); 18 | strcpy(novo->cod_curso, cod_curso); 19 | 20 | return novo; 21 | } 22 | 23 | void mostrar_aluno(t_aluno* aluno){ 24 | if (aluno){ 25 | printf("mat: %d\n", aluno->mat); 26 | printf("nome: %s\n", aluno->nome); 27 | printf("cod_curso: %s\n", aluno->cod_curso); 28 | }else{ 29 | printf("Nada a ser mostrado\n"); 30 | } 31 | } 32 | 33 | void destroy_aluno(t_aluno *aluno){ 34 | if (aluno){ 35 | free(aluno); 36 | }else{ 37 | printf("Nada a ser destruído\n"); 38 | } 39 | } 40 | 41 | t_aluno* ler_aluno(){ 42 | t_aluno* aluno=NULL; 43 | int mat; 44 | scanf("%d", &mat); 45 | if (mat !=0){ 46 | char nome[100]; 47 | char cod_curso[10]; 48 | scanf("%s", nome); 49 | scanf("%s", cod_curso); 50 | aluno = criar_aluno(mat,nome,cod_curso); 51 | } 52 | return aluno; 53 | } 54 | 55 | int main(int argc, char const *argv[]) 56 | { 57 | t_aluno* matriculado=NULL; 58 | t_dd *alunos = criar_dd(6,3); 59 | do{ 60 | matriculado =ler_aluno(); 61 | if (matriculado){ 62 | inserir_dd(alunos, matriculado->mat, matriculado); 63 | } 64 | }while(matriculado); 65 | 66 | // consultar 67 | int mat; 68 | printf("consultando....\n"); 69 | scanf("%d", &mat); 70 | t_aluno* consultado = consultar_dd(alunos, mat); 71 | 72 | mostrar_aluno(consultado); 73 | 74 | // remover 75 | printf("removendo.....\n"); 76 | scanf("%d", &mat); 77 | t_aluno* removido = remover_dd(alunos, mat); 78 | 79 | mostrar_aluno(removido); 80 | destroy_aluno(removido); 81 | 82 | return 0; 83 | } 84 | 85 | -------------------------------------------------------------------------------- /Modulo02/src/202301/ent01.txt: -------------------------------------------------------------------------------- 1 | 22050788 ABNER_AUGUSTO_NEVES_DE_LIMA IE08 2 | 21600490 ALEXANDRE_MENEZES_DE_BARROS FT05 3 | 21551621 ANA_LIDIA_ROLIM_DE_LIMA IE17 4 | 22251133 ANDRE_KAORU_LINS_HIROSAKI IE08 5 | 22251132 ANDRE_VALENTE_DE_CRISTO IE08 6 | 21950083 DIOGO_ABREU_DA_SILVA FT05 7 | 21650358 ELENKARLA_VASCONCELOS_DA_SILVA IE17 8 | 22150001 EMILLY_FERNANDA_PRESTES_SALES IE08 9 | 21750017 ENYA_GUIMARAES_DA_SILVA IE08 10 | 22154532 ERICK_BRENNO_TROVAO_GONZAGA IE08 11 | 22251136 ERIN_DANTE_DE_OLIVEIRA_VASCONCELOS IE08 12 | 22152252 ERLLISON_DE_QUEIROZ_REIS IE08 13 | 22051330 GABRIEL_BENTO_DA_SILVA FT02-E 14 | 21954446 GABRIEL_FLORENCIO_MILLER IE08 15 | 22154584 GIOVANY_DA_SILVEIRA_FEITOSA IE08 16 | 22152256 HENRIQUE_SAMIR_DOS_SANTOS_NASCIMENTO IE08 17 | 22251131 HUGO_CARVALHO_DE_MORAES IE08 18 | 21952367 IAGO_SANTIAGO_PIRES IE08 19 | 21953633 INGRID_ADINE_NILO_VASCONCELOS IE08 20 | 22252719 ISMAEL_LINCOLN_RODRIGUES_DA_SILVA IE08 21 | 22053593 JANSER_MEIRELLES_DE_SOUZA_BEIRA_MAR IE08 22 | 22154600 JEAN_SEIXAS_DE_SOUZA IE08 23 | 22251129 JHONNATHA_LUIZ_DE_SOUZA_CARVALHO IE08 24 | 22250546 JOSÉ_EDUARDO_VIEIRA_GOMES IE08 25 | 22051492 JOSE_LEANDRO_DE_MELO_SOUSA IE08 26 | 22251895 JOSUE_SILVA_FONTENELE IE08 27 | 22251135 JUILE_YOSHIE_SARKIS_HANADA IE08 28 | 22250538 KAIKE_RIBAS_DA_SILVA_MACIEL IE08 29 | 22250541 KAREN_HAPUQUE_FERREIRA_PONCE_DE_LEAO IE08 30 | 22250552 LUCAS_DO_NASCIMENTO_SILVA IE08 31 | 22251137 LUCAS_EDUARDO_SIQUEIRA_DOS_SANTOS IE08 32 | 22252570 LUCAS_LEITE_MARTINI IE08 33 | 21753483 LUCAS_LEONA_MARTEL_CAVALCANTE IE17 34 | 22251141 LUÍS_EDUARDO_BENTES_NEGREIROS IE08 35 | 22250554 LUIS_FELIPE_DOS_SANTOS_LIMA IE08 36 | 22153622 MAIKON_DOUGLAS_GALVAO_DOS_SANTOS IE08 37 | 21953111 MARCELO_FERREIRA_LEDA_FILHO IE08 38 | 22250537 MARIA_GABRIELA_MORAIS_DE_SA IE08 39 | 22251138 MARIA_GIOVANNA_GONCALVES_SALES IE08 40 | 22050053 NICHOLAS_GUERINO_STIVALETI IE08 41 | 22154599 PAULO_HENRIQUE_OLIVEIRA_GOMES IE08 42 | 22052575 PAULO_RICARDO_LIMA_DE_SOUZA IE08 43 | 22052576 REBEKA_RIBEIRO_GOMES IE08 44 | 22250556 RICARDO_ELIEL_XAVIER_DA_SILVA IE08 45 | 22251127 RICARDO_OLIVEIRA_PINHO_DE_LIMA IE08 46 | 22250551 THIAGO_VITOR_GOMES_PEREIRA IE08 47 | 22250548 VINICIUS_LIMA_SILVEIRA IE08 48 | 21950561 VITOR_FERNANDES_ANTUNES FT12 49 | 22250543 WELLINGTON_DE_SOUZA_BEZERRA IE08 50 | 0 51 | 22250543 52 | 22050788 53 | -------------------------------------------------------------------------------- /Modulo01/src/202301/heap.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "math.h" 3 | #include "heap.h" 4 | 5 | struct heap{ 6 | void* *elems; 7 | int tamanho; 8 | int ocupacao; 9 | t_heap_comparar comparar; 10 | }; 11 | 12 | static void trocar(void* elems[], int i, int j){ 13 | void* aux = elems[i]; 14 | elems[i] = elems[j]; 15 | elems[j] = aux; 16 | } 17 | 18 | t_heap* criar_heap(int tamanho, t_heap_comparar comparar){ 19 | t_heap* heap = malloc(sizeof(t_heap)); 20 | heap->elems = malloc(sizeof(void*)*tamanho); 21 | heap->tamanho = tamanho; 22 | heap->ocupacao = 0; 23 | heap->comparar = comparar; 24 | 25 | return heap; 26 | } 27 | 28 | void* primeiro_heap(t_heap* heap){ 29 | void* elem = NULL; 30 | if (heap->ocupacao > 0){ 31 | elem = heap->elems[0]; 32 | } 33 | return elem; 34 | } 35 | 36 | static void desce_heap(void* elems[], int ocupa, int i, t_heap_comparar comparar){ 37 | int imaior = i; 38 | 39 | if ( (2*i+1 < ocupa) && (comparar(elems[imaior],elems[2*i+1])<0) ){ 40 | imaior = 2*i + 1; 41 | } 42 | if ( (2*i+2 < ocupa) && (comparar(elems[imaior],elems[2*i+2])<0) ){ 43 | imaior = 2*i + 2; 44 | } 45 | if (imaior != i){ 46 | trocar(elems,imaior,i); 47 | desce_heap(elems, ocupa, imaior,comparar); 48 | } 49 | } 50 | 51 | void* remover_heap(t_heap* heap){ 52 | void* elem = NULL; 53 | if (heap->ocupacao > 0){ 54 | elem = heap->elems[0]; 55 | heap->ocupacao--; 56 | if (heap->ocupacao>=1){ 57 | trocar(heap->elems,0,heap->ocupacao); 58 | desce_heap(heap->elems, heap->ocupacao, 0, heap->comparar); 59 | } 60 | } 61 | return elem; 62 | } 63 | 64 | void sobe_heap(void* elems[], int i, t_heap_comparar comparar){ 65 | if (i > 0){ 66 | int anc_i = (int)floor((i-1)/2); 67 | if (comparar(elems[anc_i],elems[i])<0){ 68 | trocar(elems,anc_i,i); 69 | sobe_heap(elems,anc_i,comparar); 70 | } 71 | } 72 | } 73 | 74 | void inserir_heap(t_heap* heap, void* elem){ 75 | heap->elems[heap->ocupacao] = elem; 76 | sobe_heap(heap->elems, heap->ocupacao, heap->comparar); 77 | heap->ocupacao++; 78 | 79 | } 80 | 81 | void alterar_heap(t_heap* heap, void* chave, void* elem){ 82 | // bsucar_sequencial 83 | // sobe ou desce 84 | 85 | } 86 | -------------------------------------------------------------------------------- /Modulo01/src/202202/tocador.c: -------------------------------------------------------------------------------- 1 | //---------- 2 | #include "stdio.h" 3 | #include "string.h" 4 | #include "stdlib.h" 5 | #include "listase.h" 6 | 7 | // Contexto especialista 8 | typedef struct musica{ 9 | char nome[60]; 10 | int duracao_seg; 11 | char genero[30]; 12 | }t_musica; 13 | 14 | t_musica* criar_musica(char nome[], int duracao, char genero[]){ 15 | t_musica* musica = malloc(sizeof(t_musica)); 16 | 17 | musica->duracao_seg = duracao; 18 | strcpy(musica->genero, genero); 19 | strcpy(musica->nome, nome); 20 | 21 | return musica; 22 | } 23 | 24 | void imprimir_musica(void* m){ 25 | t_musica* mm = m; 26 | 27 | printf("%s %d\n", mm->nome, mm->duracao_seg); 28 | } 29 | 30 | int comparar_musica(void* m1, void* m2){ 31 | t_musica *mm1 = m1; 32 | t_musica *mm2 = m2; 33 | int ret = strcmp(mm1->nome, mm2->nome); 34 | 35 | //int ret = mm1->duracao_seg - mm2->duracao_seg; 36 | 37 | return ret; 38 | } 39 | 40 | int main(){ 41 | t_lse* musicas = criar_lse(imprimir_musica, comparar_musica); 42 | char nome[60], genero[30]; 43 | int duracao; 44 | 45 | for(int i=1;i<3;i++ ){ 46 | scanf("%s", nome); 47 | scanf("%s", genero); 48 | scanf("%d", &duracao); 49 | t_musica* m = criar_musica(nome, duracao, genero); 50 | // inserir_inicio_lse(musicas, i); 51 | inserir_final_lse(musicas, m); 52 | } 53 | 54 | // t_musica* musica_inicio = remover_inicio_lse(musicas); 55 | // //printf("removeu: %d\n", musica); 56 | // free(musica_inicio); 57 | 58 | // t_musica* musica_ult = remover_final_lse(musicas); 59 | // //printf("removeu: %d\n", musica_ult); 60 | // free(musica_ult); 61 | 62 | // t_musica* segunda = acessar_lse(musicas, -2); 63 | // //printf("acessou: %d\n", segunda); 64 | // free(segunda); 65 | 66 | // t_musica* outra_musica = acessar_lse(musicas, 15); 67 | // //printf("acessou: %d\n", outra_musica); 68 | // free(outra_musica); 69 | 70 | imprimir_lse(musicas); 71 | t_musica* m; 72 | char minha_musica[60] = "senta aqui"; 73 | while(strcmp(minha_musica,"FIM")!=0){ 74 | scanf("%s", minha_musica); 75 | 76 | m = buscar_lse(musicas, minha_musica); 77 | if (m) 78 | imprimir_musica(m); 79 | 80 | m = remover_lse(musicas, minha_musica); 81 | if (m){ 82 | imprimir_musica(m); 83 | free(m); 84 | } 85 | m = buscar_lse(musicas, minha_musica); 86 | if (m) 87 | imprimir_musica(m); 88 | else 89 | printf("Musica não ta lista\n"); 90 | } 91 | return 0; 92 | 93 | } -------------------------------------------------------------------------------- /Modulo02/src/202202/heapsort.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "stdio.h" 3 | #include "ordenacao.h" 4 | 5 | typedef struct heap t_heap; 6 | 7 | t_heap* criar_heap(int tam, TCompararHeapsort comparar); 8 | int popular_heap(t_heap* h, void* elem); 9 | 10 | struct heap{ 11 | void* *elem; 12 | int ocupacao; 13 | int tamanho; 14 | int e_infinito; 15 | 16 | TCompararHeapsort comparar; 17 | }; 18 | 19 | static void trocar(void* elem[], int i, int j){ 20 | void* aux = elem[i]; 21 | elem[i] = elem[j]; 22 | elem[j] = aux; 23 | } 24 | 25 | static void desce_no_heap(t_heap* h, int k){ 26 | 27 | int imaior = k; 28 | int i_esq = (k*2) + 1; 29 | int i_dir = (k*2) + 2; 30 | 31 | if ((i_esq < h->ocupacao) && (h->comparar(h->elem[imaior],h->elem[i_esq])<0)){ 32 | imaior = i_esq; 33 | } 34 | if ((i_dir < h->ocupacao) && (h->comparar(h->elem[imaior],h->elem[ i_dir ])<0)){ 35 | imaior = i_dir; 36 | } 37 | if (imaior!=k){ 38 | trocar(h->elem, k, imaior); 39 | desce_no_heap(h,imaior); 40 | } 41 | 42 | } 43 | 44 | static void heapifica(t_heap* heap){ 45 | int n = heap->ocupacao; 46 | int k = (n-1)/2; 47 | 48 | do{ 49 | desce_no_heap(heap,k); 50 | k--; 51 | 52 | }while(k>0); 53 | } 54 | 55 | t_heap* criar_heap(int tam, TCompararHeapsort comparar){ 56 | t_heap* h = malloc(sizeof(t_heap)); 57 | h->tamanho = (tam>0?tam:2); 58 | h->e_infinito = (tam<=0?1:0); 59 | h->ocupacao = 0; 60 | h->elem = malloc(sizeof(void*)*h->tamanho); 61 | 62 | h->comparar = comparar; 63 | 64 | return h; 65 | } 66 | 67 | 68 | int popular_heap(t_heap* h, void* elem){ 69 | int status = 0; // fals0 70 | 71 | if ((h->e_infinito) && (h->ocupacao == h->tamanho)){ 72 | h->tamanho = h->tamanho*2; 73 | h->elem = realloc(h->elem,sizeof(void*)*h->tamanho); 74 | } 75 | if(h->ocupacaotamanho){ 76 | h->elem[h->ocupacao] = elem; 77 | h->ocupacao++; 78 | status = 1; // verdade 79 | } 80 | return status; 81 | } 82 | 83 | void destroy_heap(t_heap* h){ 84 | free(h->elem); 85 | free(h); 86 | } 87 | 88 | void heap_sort(void* vetor[], int tam, TCompararHeapsort comparar){ 89 | 90 | t_heap* h = criar_heap(tam, comparar); 91 | 92 | for(int i=0;ielem,0,h->ocupacao); // ordenando 100 | h->ocupacao--; 101 | desce_no_heap(h,0); // estabelece a ordem 102 | }while(h->ocupacao>1); 103 | 104 | for(int i=0;ielem[i]; 106 | } 107 | 108 | destroy_heap(h); 109 | } 110 | 111 | -------------------------------------------------------------------------------- /Modulo01/src/202202/heap.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "stdio.h" 3 | #include "heap.h" 4 | 5 | struct heap{ 6 | void* *elem; 7 | int ocupacao; 8 | int tamanho; 9 | int e_infinito; 10 | 11 | TCompararHeap comparar; 12 | }; 13 | 14 | static void trocar(void* elem[], int i, int j){ 15 | void* aux = elem[i]; 16 | elem[i] = elem[j]; 17 | elem[j] = aux; 18 | } 19 | 20 | static void desce_no_heap(t_heap* h, int k){ 21 | 22 | int imaior = k; 23 | int childrenLeft = (k*2) + 1; 24 | int childrenRight = (k*2) + 2; 25 | 26 | if ((childrenLeft < h->ocupacao) && (h->comparar(h->elem[imaior],h->elem[childrenLeft])<0)){ 27 | imaior = childrenLeft; 28 | } 29 | if ((childrenRight < h->ocupacao) && (h->comparar(h->elem[imaior],h->elem[ childrenRight ])<0)){ 30 | imaior = childrenRight; 31 | } 32 | if (imaior!=k){ 33 | trocar(h->elem, k, imaior); 34 | desce_no_heap(h,imaior); 35 | } 36 | 37 | } 38 | 39 | static void sobe_no_heap(t_heap* h, int k){ 40 | 41 | int kancestral= (k-1)/2; 42 | 43 | if ((kancestral>=0)&&(h->comparar(h->elem[kancestral],h->elem[k])<0)){ 44 | trocar(h->elem, k, kancestral); 45 | sobe_no_heap(h, kancestral); 46 | } 47 | } 48 | 49 | static void heapifica(t_heap* heap){ 50 | int n = heap->ocupacao; 51 | int k = (n-1)/2; 52 | 53 | do{ 54 | desce_no_heap(heap,k); 55 | k--; 56 | 57 | }while(k>0); 58 | } 59 | 60 | t_heap* criar_heap(int tam, TCompararHeap comparar){ 61 | t_heap* h = malloc(sizeof(t_heap)); 62 | h->tamanho = (tam>0?tam:2); 63 | h->e_infinito = (tam<=0?1:0); 64 | h->ocupacao = 0; 65 | h->elem = malloc(sizeof(void*)*h->tamanho); 66 | 67 | h->comparar = comparar; 68 | 69 | return h; 70 | } 71 | 72 | int inserir_heap(t_heap* h, void* elem){ 73 | 74 | int inseriu = popular_heap(h, elem); 75 | 76 | if (inseriu) 77 | sobe_no_heap(h,h->ocupacao-1); 78 | 79 | return inseriu; 80 | } 81 | 82 | void* remover_heap(t_heap* h){ 83 | 84 | if(h->ocupacao <= 0) return NULL; // Se a fila estiver vazia nem continua. 85 | 86 | trocar(h->elem, 0, h->ocupacao-1); 87 | h->ocupacao--; 88 | desce_no_heap(h,0); 89 | 90 | return h->elem[h->ocupacao]; 91 | } 92 | 93 | void* raiz_heap(t_heap* h){ 94 | return (h->ocupacao==0?NULL:h->elem[0]); 95 | } 96 | 97 | int popular_heap(t_heap* h, void* elem){ 98 | int status = 0; // fals0 99 | 100 | if ((h->e_infinito) && (h->ocupacao == h->tamanho)){ 101 | h->tamanho = h->tamanho*2; 102 | h->elem = realloc(h->elem,sizeof(void*)*h->tamanho); 103 | } 104 | if(h->ocupacaotamanho){ 105 | h->elem[h->ocupacao] = elem; 106 | h->ocupacao++; 107 | status = 1; // verdade 108 | } 109 | return status; 110 | } 111 | 112 | int ocupacao_heap(t_heap* h){ 113 | return h->ocupacao; 114 | } 115 | 116 | int tamanho_heap(t_heap* h){ 117 | return h->tamanho; 118 | } -------------------------------------------------------------------------------- /Modulo02/src/202301/usabb.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "stdio.h" 3 | #include "wchar.h" 4 | #include "locale.h" 5 | #include "abb.h" 6 | 7 | typedef struct { 8 | int hashing; 9 | wchar_t palavra[80]; 10 | int tamanho; 11 | }t_palavra; 12 | 13 | t_palavra* criar_palavra(wchar_t palavra[], unsigned int hashing, int tamanho){ 14 | t_palavra* nova = malloc(sizeof (t_palavra)); 15 | nova->hashing = hashing; 16 | nova->tamanho = tamanho; 17 | wcscpy(nova->palavra,palavra); 18 | return nova; 19 | } 20 | 21 | int comparar_palavra(void *pp1, void *pp2){ 22 | t_palavra* p1=pp1; 23 | t_palavra* p2 = pp2; 24 | return (p1->hashing - p2->hashing); 25 | } 26 | 27 | void destruir_palavra(void *p1){ 28 | free((t_palavra*) p1); 29 | } 30 | 31 | void imprimir_palavra(void *p){ 32 | t_palavra *pp = p; 33 | wprintf(pp->palavra); 34 | printf(" %u %d\n", pp->hashing, pp->tamanho); 35 | } 36 | 37 | static short _e_pontuacao(wint_t c){ 38 | if ((c<=47)){ 39 | return 1; 40 | }else if((c>=58) && (c<=63)){ 41 | return 1; 42 | }else if ((c>=91) && (c<=96)){ 43 | return 1; 44 | }else if((c>=123) && (c<=127)){ 45 | return 1; 46 | }else if((c>=48) && (c<=57)){ 47 | return 1; 48 | }else{ 49 | return 0; 50 | } 51 | } 52 | 53 | 54 | t_palavra* ler_palavra(FILE* f){ 55 | wchar_t palavra[600]; 56 | int pesos[] = {179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281, 57 | 283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409, 58 | 419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541}; 59 | int i=0; 60 | unsigned int codigo=0; 61 | for (wint_t c; (c = fgetwc(f)) != WEOF;){ 62 | 63 | //printf("%d\n", c); 64 | if ((c==10) || (c==32) || (_e_pontuacao(c))){ 65 | palavra[i]='\0'; 66 | if (i>=2){ 67 | t_palavra *nova = criar_palavra(palavra, codigo, i); 68 | return nova; 69 | } 70 | i=0; 71 | codigo=0; 72 | 73 | }else{ 74 | codigo += c * pesos[i]; 75 | palavra[i++] = c; 76 | } 77 | } 78 | palavra[i]='\0'; 79 | if (i>=2){ 80 | t_palavra *nova = criar_palavra(palavra, codigo, i); 81 | return nova; 82 | } 83 | return NULL; 84 | } 85 | 86 | 87 | int main(int argc, char const *argv[]) 88 | { 89 | setlocale(LC_ALL, "C.UTF-8"); 90 | 91 | FILE *f = fopen(argv[1], "r, ccs=UTF-8"); 92 | if (!f) 93 | return 1; 94 | 95 | t_abb *obra = criar_abb(comparar_palavra, destruir_palavra, imprimir_palavra); 96 | 97 | int continua =1; 98 | do{ 99 | t_palavra* nova = ler_palavra(f); 100 | if (nova==NULL) 101 | continua = 0; 102 | else{ 103 | if( buscar_abb(obra,nova) == NULL){ 104 | inserir_abb(obra,nova); 105 | }else{ 106 | destruir_palavra(nova); 107 | } 108 | } 109 | } while(continua); 110 | 111 | imprimir_abb(obra); 112 | 113 | fclose(f); 114 | return 0; 115 | } -------------------------------------------------------------------------------- /Modulo02/src/202301/usavl.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "stdio.h" 3 | #include "wchar.h" 4 | #include "locale.h" 5 | #include "avl.h" 6 | 7 | typedef struct { 8 | int hashing; 9 | wchar_t palavra[80]; 10 | int tamanho; 11 | }t_palavra; 12 | 13 | t_palavra* criar_palavra(wchar_t palavra[], unsigned int hashing, int tamanho){ 14 | t_palavra* nova = malloc(sizeof (t_palavra)); 15 | nova->hashing = hashing; 16 | nova->tamanho = tamanho; 17 | wcscpy(nova->palavra,palavra); 18 | return nova; 19 | } 20 | 21 | int comparar_palavra(void *pp1, void *pp2){ 22 | t_palavra* p1=pp1; 23 | t_palavra* p2 = pp2; 24 | return (p1->hashing - p2->hashing); 25 | } 26 | 27 | void destruir_palavra(void *p1){ 28 | free((t_palavra*) p1); 29 | } 30 | 31 | void imprimir_palavra(void *p){ 32 | t_palavra *pp = p; 33 | wprintf(pp->palavra); 34 | printf(" %u %d\n", pp->hashing, pp->tamanho); 35 | } 36 | 37 | static short _e_pontuacao(wint_t c){ 38 | if ((c<=47)){ 39 | return 1; 40 | }else if((c>=58) && (c<=63)){ 41 | return 1; 42 | }else if ((c>=91) && (c<=96)){ 43 | return 1; 44 | }else if((c>=123) && (c<=127)){ 45 | return 1; 46 | }else if((c>=48) && (c<=57)){ 47 | return 1; 48 | }else{ 49 | return 0; 50 | } 51 | } 52 | 53 | 54 | t_palavra* ler_palavra(FILE* f){ 55 | wchar_t palavra[600]; 56 | int pesos[] = {179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281, 57 | 283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409, 58 | 419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541}; 59 | int i=0; 60 | unsigned int codigo=0; 61 | for (wint_t c; (c = fgetwc(f)) != WEOF;){ 62 | 63 | //printf("%d\n", c); 64 | if ((c==10) || (c==32) || (_e_pontuacao(c))){ 65 | palavra[i]='\0'; 66 | if (i>=2){ 67 | t_palavra *nova = criar_palavra(palavra, codigo, i); 68 | return nova; 69 | } 70 | i=0; 71 | codigo=0; 72 | 73 | }else{ 74 | codigo += c * pesos[i]; 75 | palavra[i++] = c; 76 | } 77 | } 78 | palavra[i]='\0'; 79 | if (i>=2){ 80 | t_palavra *nova = criar_palavra(palavra, codigo, i); 81 | return nova; 82 | } 83 | return NULL; 84 | } 85 | 86 | 87 | int main(int argc, char const *argv[]) 88 | { 89 | setlocale(LC_ALL, "C.UTF-8"); 90 | 91 | FILE *f = fopen(argv[1], "r, ccs=UTF-8"); 92 | if (!f) 93 | return 1; 94 | 95 | t_avl *obra = criar_avl(comparar_palavra, destruir_palavra, imprimir_palavra); 96 | 97 | int continua =1; 98 | do{ 99 | t_palavra* nova = ler_palavra(f); 100 | if (nova==NULL) 101 | continua = 0; 102 | else{ 103 | if( buscar_avl(obra,nova) == NULL){ 104 | inserir_avl(obra,nova); 105 | }else{ 106 | destruir_palavra(nova); 107 | } 108 | } 109 | } while(continua); 110 | 111 | imprimir_avl(obra); 112 | 113 | fclose(f); 114 | return 0; 115 | } -------------------------------------------------------------------------------- /Modulo03/heap.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "math.h" 3 | #include "heap.h" 4 | #include "stdio.h" 5 | 6 | struct heap{ 7 | void* *elems; 8 | int tamanho; 9 | int ocupacao; 10 | t_heap_comparar comparar; 11 | }; 12 | 13 | static void trocar(void* elems[], int i, int j){ 14 | void* aux = elems[i]; 15 | elems[i] = elems[j]; 16 | elems[j] = aux; 17 | } 18 | 19 | t_heap* criar_heap(int tamanho, t_heap_comparar comparar){ 20 | t_heap* heap = malloc(sizeof(t_heap)); 21 | heap->elems = malloc(sizeof(void*)*tamanho); 22 | heap->tamanho = tamanho; 23 | heap->ocupacao = 0; 24 | heap->comparar = comparar; 25 | 26 | return heap; 27 | } 28 | 29 | void* primeiro_heap(t_heap* heap){ 30 | void* elem = NULL; 31 | if (heap->ocupacao > 0){ 32 | elem = heap->elems[0]; 33 | } 34 | return elem; 35 | } 36 | 37 | static void desce_heap(void* elems[], int ocupa, int i, t_heap_comparar comparar){ 38 | int imaior = i; 39 | 40 | if ( (2*i+1 < ocupa) && (comparar(elems[imaior],elems[2*i+1])<0) ){ 41 | imaior = 2*i + 1; 42 | } 43 | if ( (2*i+2 < ocupa) && (comparar(elems[imaior],elems[2*i+2])<0) ){ 44 | imaior = 2*i + 2; 45 | } 46 | if (imaior != i){ 47 | trocar(elems,imaior,i); 48 | desce_heap(elems, ocupa, imaior,comparar); 49 | } 50 | } 51 | 52 | void* remover_heap(t_heap* heap){ 53 | void* elem = NULL; 54 | if (heap->ocupacao > 0){ 55 | elem = heap->elems[0]; 56 | heap->ocupacao--; 57 | if (heap->ocupacao>=1){ 58 | trocar(heap->elems,0,heap->ocupacao); 59 | desce_heap(heap->elems, heap->ocupacao, 0, heap->comparar); 60 | } 61 | } 62 | return elem; 63 | } 64 | 65 | void sobe_heap(void* elems[], int i, t_heap_comparar comparar){ 66 | if (i > 0){ 67 | int anc_i = (int)floor((i-1)/2); 68 | if (comparar(elems[anc_i],elems[i])<0){ 69 | trocar(elems,anc_i,i); 70 | sobe_heap(elems,anc_i,comparar); 71 | } 72 | } 73 | } 74 | 75 | void inserir_heap(t_heap* heap, void* elem){ 76 | heap->elems[heap->ocupacao] = elem; 77 | sobe_heap(heap->elems, heap->ocupacao, heap->comparar); 78 | heap->ocupacao++; 79 | 80 | } 81 | 82 | void colocar_heap(t_heap* heap, void* elem){ 83 | heap->elems[heap->ocupacao] = elem; 84 | heap->ocupacao++; 85 | } 86 | 87 | void heapifica(t_heap* heap){ 88 | int k = floor(heap->ocupacao/2.0) - 1; 89 | k=(k<0?0:k); 90 | for(int i=k;i>=0;i--){ 91 | desce_heap(heap->elems,heap->ocupacao,i,heap->comparar); 92 | } 93 | } 94 | 95 | heap_sort(void* elems[], int tam, t_heap_comparar comparar){ 96 | t_heap* heap = criar_heap(tam,comparar); 97 | for (int i=0; i=0;i--){ 104 | elems[i] = remover_heap(heap); 105 | } 106 | 107 | free(heap->elems); 108 | free(heap); 109 | } 110 | int comparar_int(int* p1, int* p2){ 111 | return (*p1 - *p2); 112 | } 113 | 114 | int* ler_int(){ 115 | int* inteiro = malloc(4); 116 | scanf("%d", inteiro); 117 | return inteiro; 118 | } 119 | 120 | int main(){ 121 | int* inteiros[10]; 122 | for(int i=0;i<10;i++){ 123 | inteiros[i] = ler_int(); 124 | } 125 | heap_sort(inteiros, 10, comparar_int); 126 | 127 | for(int i=0;i<10;i++){ 128 | printf("%d ", *inteiros[i]); 129 | } 130 | printf("\n"); 131 | 132 | } -------------------------------------------------------------------------------- /Modulo02/src/202301/ent02.txt: -------------------------------------------------------------------------------- 1 | 22050788 ABNER_AUGUSTO_NEVES_DE_LIMA IE08 ICC003 ICC061 ICC000 2 | 21600490 ALEXANDRE_MENEZES_DE_BARROS FT05 ICC003 ICC061 ICC000 3 | 21551621 ANA_LIDIA_ROLIM_DE_LIMA IE17 ICC003 ICC061 ICC000 4 | 22251133 ANDRE_KAORU_LINS_HIROSAKI IE08 ICC003 ICC061 ICC000 5 | 22251132 ANDRE_VALENTE_DE_CRISTO IE08 ICC003 ICC061 ICC000 6 | 21950083 DIOGO_ABREU_DA_SILVA FT05 ICC003 ICC061 ICC000 7 | 21650358 ELENKARLA_VASCONCELOS_DA_SILVA IE17 ICC003 ICC061 ICC000 8 | 22150001 EMILLY_FERNANDA_PRESTES_SALES IE08 ICC003 ICC061 ICC000 9 | 21750017 ENYA_GUIMARAES_DA_SILVA IE08 ICC003 ICC061 ICC000 10 | 22154532 ERICK_BRENNO_TROVAO_GONZAGA IE08 ICC003 ICC061 ICC000 11 | 22251136 ERIN_DANTE_DE_OLIVEIRA_VASCONCELOS IE08 ICC003 ICC061 ICC000 12 | 22152252 ERLLISON_DE_QUEIROZ_REIS IE08 ICC003 ICC061 ICC000 13 | 22051330 GABRIEL_BENTO_DA_SILVA FT02-E ICC003 ICC061 ICC000 14 | 21954446 GABRIEL_FLORENCIO_MILLER IE08 ICC003 ICC061 ICC121 ICC000 15 | 22154584 GIOVANY_DA_SILVEIRA_FEITOSA IE08 ICC003 ICC061 ICC121 ICC000 16 | 22152256 HENRIQUE_SAMIR_DOS_SANTOS_NASCIMENTO IE08 ICC003 ICC061 ICC121 ICC000 17 | 22251131 HUGO_CARVALHO_DE_MORAES IE08 ICC003 ICC061 ICC121 ICC000 18 | 21952367 IAGO_SANTIAGO_PIRES IE08 ICC003 ICC061 ICC121 ICC000 19 | 21953633 INGRID_ADINE_NILO_VASCONCELOS IE08 ICC003 ICC061 ICC121 ICC000 20 | 22252719 ISMAEL_LINCOLN_RODRIGUES_DA_SILVA IE08 ICC003 ICC061 ICC121 ICC000 21 | 22053593 JANSER_MEIRELLES_DE_SOUZA_BEIRA_MAR IE08 ICC003 ICC061 ICC121 ICC000 22 | 22154600 JEAN_SEIXAS_DE_SOUZA IE08 ICC003 ICC061 ICC121 ICC000 23 | 22251129 JHONNATHA_LUIZ_DE_SOUZA_CARVALHO IE08 ICC003 ICC061 ICC121 ICC000 24 | 22250546 JOSÉ_EDUARDO_VIEIRA_GOMES IE08 ICC003 ICC061 ICC121 IEF028 ICC000 25 | 22051492 JOSE_LEANDRO_DE_MELO_SOUSA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 26 | 22251895 JOSUE_SILVA_FONTENELE IE08 ICC003 ICC061 ICC121 IEF028 ICC000 27 | 22251135 JUILE_YOSHIE_SARKIS_HANADA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 28 | 22250538 KAIKE_RIBAS_DA_SILVA_MACIEL IE08 ICC003 ICC061 ICC121 IEF028 ICC000 29 | 22250541 KAREN_HAPUQUE_FERREIRA_PONCE_DE_LEAO IE08 ICC003 ICC061 ICC121 IEF028 ICC000 30 | 22250552 LUCAS_DO_NASCIMENTO_SILVA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 31 | 22251137 LUCAS_EDUARDO_SIQUEIRA_DOS_SANTOS IE08 ICC003 ICC061 ICC121 IEF028 ICC000 32 | 22252570 LUCAS_LEITE_MARTINI IE08 ICC003 ICC061 ICC121 IEF028 ICC000 33 | 21753483 LUCAS_LEONA_MARTEL_CAVALCANTE IE17 ICC003 ICC061 ICC121 IEF028 ICC000 34 | 22251141 LUÍS_EDUARDO_BENTES_NEGREIROS IE08 ICC003 ICC061 ICC121 IEF028 ICC000 35 | 22250554 LUIS_FELIPE_DOS_SANTOS_LIMA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 36 | 22153622 MAIKON_DOUGLAS_GALVAO_DOS_SANTOS IE08 ICC003 ICC061 ICC121 IEF028 ICC000 37 | 21953111 MARCELO_FERREIRA_LEDA_FILHO IE08 ICC003 ICC061 ICC121 IEF028 ICC000 38 | 22250537 MARIA_GABRIELA_MORAIS_DE_SA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 39 | 22251138 MARIA_GIOVANNA_GONCALVES_SALES IE08 ICC003 ICC061 ICC121 IEF028 ICC000 40 | 22050053 NICHOLAS_GUERINO_STIVALETI IE08 ICC003 ICC061 ICC121 IEF028 ICC000 41 | 22154599 PAULO_HENRIQUE_OLIVEIRA_GOMES IE08 ICC003 ICC061 ICC121 IEF028 ICC000 42 | 22052575 PAULO_RICARDO_LIMA_DE_SOUZA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 43 | 22052576 REBEKA_RIBEIRO_GOMES IE08 ICC003 ICC061 ICC121 IEF028 ICC000 44 | 22250556 RICARDO_ELIEL_XAVIER_DA_SILVA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 45 | 22251127 RICARDO_OLIVEIRA_PINHO_DE_LIMA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 46 | 22250551 THIAGO_VITOR_GOMES_PEREIRA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 47 | 22250548 VINICIUS_LIMA_SILVEIRA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 48 | 21950561 VITOR_FERNANDES_ANTUNES FT12 ICC003 ICC061 ICC121 IEF028 ICC000 49 | 22250543 WELLINGTON_DE_SOUZA_BEZERRA IE08 ICC003 ICC061 ICC121 IEF028 ICC000 50 | 0 51 | 22250543 52 | 22050788 53 | -------------------------------------------------------------------------------- /Modulo02/src/202301/diciodinamico.c: -------------------------------------------------------------------------------- 1 | #include "stdlib.h" 2 | #include "vetordinamico.h" 3 | #include "diciodinamico.h" 4 | #include "../../../Modulo01/src/202301/listase.h" 5 | #include "math.h" 6 | 7 | struct dicio_dinamico{ 8 | void* *elems; 9 | int fator_carga; 10 | int tamanho; 11 | t_comparar_dd comparar; 12 | }; 13 | 14 | typedef int(*t_comparar_dd)(void*, void*); 15 | typedef struct colisao{ 16 | int chave; 17 | void* carga; 18 | }t_colisao; 19 | 20 | 21 | t_colisao* criar_colisao(int chave, void* carga){ 22 | t_colisao* c = malloc(sizeof(t_colisao)); 23 | c->chave = chave; 24 | c->carga = carga; 25 | 26 | return c; 27 | } 28 | 29 | int comparar_colisao(void* c1, void* c2){ 30 | t_colisao* cc1 = c1; 31 | t_colisao* cc2 = c2; 32 | 33 | return cc1->chave - cc2->chave; 34 | } 35 | 36 | static int funcao_hashing(t_dd *dd , int chave){ 37 | return chave % dd->tamanho; 38 | } 39 | 40 | 41 | t_dd* criar_dd(int fator_carga, int tam){ 42 | t_dd* dd = malloc(sizeof(t_dd)); 43 | dd->tamanho = tam; 44 | 45 | dd->elems = malloc(sizeof(void*)*dd->tamanho); 46 | for(int i=0;itamanho;i++){ 47 | dd->elems[i] = criar_lse(NULL, comparar_colisao); 48 | } 49 | dd->fator_carga = fator_carga; 50 | dd->comparar = comparar_colisao; 51 | 52 | return dd; 53 | }; 54 | 55 | 56 | int inserir_dd(t_dd *dd, int chave, void*carga){ 57 | int k = funcao_hashing(dd, chave); 58 | t_lse* colisoes = dd->elems[k]; 59 | t_colisao* colisao = buscar_lse(colisoes, (void*) &chave); 60 | if (colisao == NULL){ 61 | inserir_lse(colisoes,criar_colisao(chave, carga)); 62 | return 1; 63 | } 64 | return 0; 65 | } 66 | 67 | void* consultar_dd(t_dd *dd, int chave){ 68 | 69 | int k = funcao_hashing(dd, chave); 70 | t_lse* colisoes = dd->elems[k]; 71 | t_colisao* colisao = buscar_lse(colisoes, (void*) &chave); 72 | if (colisao != NULL){ 73 | return colisao->carga; 74 | } 75 | return NULL; 76 | } 77 | 78 | void* remover_dd(t_dd *dd, int chave){ 79 | int k = funcao_hashing(dd, chave); 80 | t_lse* colisoes = dd->elems[k]; 81 | t_colisao* colisao = remover_lse(colisoes, (void*) &chave); 82 | void* carga = NULL; 83 | if (colisao != NULL){ 84 | carga = colisao->carga; 85 | free(colisao); 86 | } 87 | return carga; 88 | } 89 | 90 | static int primo(int partida){ 91 | int novo_primo; 92 | int tentativa=0; 93 | do{ 94 | tentativa++; 95 | int k = floor((partida*k-1)/2); 96 | int A[k]; 97 | for(int i=0;itamanho); 119 | t_dd* novo = criar_dd(velho->fator_carga, novo_tamanho); 120 | 121 | for (int i=0;itamanho;i++){ 122 | t_lse *colisoes = velho->elems[i]; 123 | t_colisao *colisao = remover_inicio_lse(colisoes); 124 | while(colisao){ 125 | inserir_dd(novo, colisao->chave, colisao->carga); 126 | free(colisao); 127 | colisao = remover_inicio_lse(colisoes); 128 | } 129 | } 130 | 131 | return novo; 132 | } -------------------------------------------------------------------------------- /Modulo02/src/202301/ab.c: -------------------------------------------------------------------------------- 1 | #include "time.h" 2 | #include "stdio.h" 3 | #include "stdlib.h" 4 | #include "ab.h" 5 | 6 | typedef struct no t_no; 7 | struct no{ 8 | void* info; 9 | t_no* ancestral; 10 | t_no* sae; 11 | t_no* sad; 12 | }; 13 | 14 | static t_no* criar_no(void* info, t_no* ancestral){ 15 | t_no* novo = malloc(sizeof(t_no)); 16 | novo->info = info; 17 | novo->sad = NULL; 18 | novo->sae = NULL; 19 | novo->ancestral = ancestral; 20 | 21 | return novo; 22 | } 23 | 24 | struct ab{ 25 | t_no* raiz; 26 | int tamanho; 27 | t_comparar_ab comparar; 28 | }; 29 | 30 | t_ab* criar_ab(t_comparar_ab comparar){ 31 | t_ab *ab = malloc(sizeof(t_ab)); 32 | ab->raiz = NULL; 33 | ab->tamanho = 0; 34 | ab->comparar = comparar; 35 | return ab; 36 | } 37 | 38 | #define MAX(a,b) (a>b?a:b) 39 | static int _altura_ab(t_no* raiz){ 40 | if (raiz != NULL){ 41 | return MAX(_altura_ab(raiz->sae), _altura_ab(raiz->sad)) + 1; 42 | }else{ 43 | return -1; 44 | } 45 | } 46 | 47 | int altura_ab(t_ab *ab){ 48 | 49 | return _altura_ab(ab->raiz); 50 | } 51 | 52 | static int _tamanho_ab(t_no* no){ 53 | if (no == NULL) 54 | return 0; 55 | return _tamanho_ab(no->sae) + _tamanho_ab(no->sad) + 1; 56 | } 57 | 58 | int tamanho_ab(t_ab *ab){ 59 | return ab->tamanho; 60 | } 61 | 62 | void* _buscar_ab(t_no* raiz, t_comparar_ab comparar, void* chave){ 63 | if(raiz == NULL){ 64 | return NULL; 65 | }else if(comparar(raiz->info, chave) == 0){ 66 | return raiz->info; 67 | }else{ 68 | void* buscado =_buscar_ab(raiz->sae,comparar,chave); 69 | if (buscado == NULL){ 70 | buscado =_buscar_ab(raiz->sad,comparar,chave); 71 | } 72 | return buscado; 73 | } 74 | } 75 | 76 | void* buscar_ab(t_ab *ab, void* chave){ 77 | return _buscar_ab(ab->raiz, ab->comparar, chave); 78 | } 79 | 80 | static int sorteio(){ 81 | static int primeira_vez = 1; 82 | if (primeira_vez){ 83 | primeira_vez = 0; 84 | srand(time(NULL)); 85 | } 86 | return (rand() % 2); // gera o valor entre [0,1] 87 | } 88 | 89 | static t_no* _inserir_ab(t_no* raiz, t_no* ancestral, void* info){ 90 | if (raiz == NULL){ 91 | return criar_no(info, ancestral); 92 | }else{ 93 | 94 | if (sorteio()==0){ // inserir SAE 95 | raiz->sae = _inserir_ab(raiz->sae, raiz, info); 96 | }else{ // SAD 97 | raiz->sad = _inserir_ab(raiz->sad, raiz, info); 98 | } 99 | return raiz; 100 | } 101 | } 102 | 103 | void inserir_ab(t_ab *ab, void* info){ 104 | ab->raiz = _inserir_ab(ab->raiz,NULL,info); 105 | ab->tamanho++; 106 | } 107 | 108 | t_no* _podar_ab(t_no *raiz, int *tamanho){ 109 | if(raiz==NULL){ 110 | return; 111 | } 112 | _podar_ab(raiz->sae, tamanho); 113 | _podar_ab(raiz->sad, tamanho); 114 | free(raiz->info); 115 | free(raiz); 116 | *tamanho = *tamanho-1; 117 | return NULL; 118 | } 119 | 120 | void podar_ab(t_ab *ab, void* podavel){ 121 | t_no* raiz = _buscar_ab(ab->raiz,ab->comparar, podavel); 122 | if(raiz->ancestral != NULL){ 123 | if (raiz->ancestral->sad == raiz){ 124 | raiz->ancestral->sad = NULL; 125 | }else{ 126 | raiz->ancestral->sae = NULL; 127 | } 128 | } 129 | // ab->tamanho -= _tamanho_ab(raiz); 130 | _podar_ab(raiz, &(ab->tamanho)); 131 | 132 | } 133 | 134 | void _imprimir_ab(t_no* raiz){ 135 | if (raiz == NULL){ 136 | return; 137 | } 138 | _imprimir_ab(raiz->sae); 139 | _imprimir_ab(raiz->sad); 140 | printf("%p\n", raiz->info); 141 | 142 | } 143 | 144 | void imprimir_ab(t_ab *ab){ 145 | _imprimir_ab(ab->raiz); 146 | } 147 | 148 | -------------------------------------------------------------------------------- /Modulo01/src/202301/listase.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "listase.h" 4 | 5 | typedef struct elem_se{ 6 | void* carga_util; 7 | struct elem_se* prox; 8 | } t_elemento_lse; 9 | 10 | /** 11 | * cria um elemento da LSE 12 | */ 13 | t_elemento_lse* criar_elemento_lse(void* carga_util){ 14 | t_elemento_lse* novo = malloc(sizeof(t_elemento_lse)); 15 | novo->carga_util = carga_util; 16 | novo->prox = NULL; 17 | 18 | //printf("Criando: %p %p %p\n", novo, novo->carga_util, novo->prox); 19 | 20 | return novo; 21 | } 22 | 23 | typedef struct lse t_lse; 24 | struct lse{ 25 | t_elemento_lse* inicio; 26 | t_elemento_lse* fim; 27 | int tamanho; 28 | // operacoes 29 | t_imprimir_lse imprimir; 30 | t_comparar_lse comparar; 31 | 32 | }; 33 | 34 | t_lse* criar_lse(t_imprimir_lse imprimir, t_comparar_lse comparar){ 35 | t_lse *l = malloc(sizeof(t_lse)); 36 | l->inicio = l->fim = NULL; 37 | l->tamanho = 0; 38 | l->imprimir = imprimir; 39 | l->comparar = comparar; 40 | return l; 41 | } 42 | 43 | void inserir_lse(t_lse* lse, void* carga_util){ 44 | t_elemento_lse* novo = criar_elemento_lse(carga_util); 45 | 46 | if (lse->inicio == NULL){ 47 | lse->inicio = lse->fim = novo; 48 | }else{ 49 | novo->prox = lse->inicio; 50 | lse->inicio = novo; 51 | } 52 | 53 | lse->tamanho++; 54 | } 55 | 56 | void inserir_final_lse(t_lse* lse, void* carga_util){ 57 | 58 | t_elemento_lse* novo = criar_elemento_lse(carga_util); 59 | 60 | if (lse->inicio == NULL){ 61 | lse->inicio = lse->fim = novo; 62 | }else{ 63 | lse->fim->prox = novo; 64 | lse->fim = novo; 65 | } 66 | lse->tamanho++; 67 | 68 | } 69 | 70 | void* remover_inicio_lse(t_lse* lse){ 71 | void* carga_util = NULL; 72 | t_elemento_lse *removivel = lse->inicio; 73 | if (lse->inicio != NULL){ 74 | carga_util = removivel->carga_util; 75 | lse->inicio = removivel->prox; 76 | free(removivel); 77 | lse->tamanho--; 78 | } 79 | return carga_util; 80 | } 81 | 82 | void* remover_lse(t_lse* lse, void* chave){ 83 | t_elemento_lse* cam = lse->inicio; 84 | t_elemento_lse* ant = NULL; 85 | 86 | while( (cam!=NULL) && (lse->comparar(cam->carga_util , chave)!=0)){ 87 | ant = cam; 88 | cam = cam->prox; 89 | } 90 | 91 | void* carga = NULL; 92 | if (cam != NULL){ 93 | carga = cam->carga_util; 94 | if (cam == lse->inicio){ // inicio? 95 | lse->inicio = cam->prox; 96 | if (cam->prox == NULL) 97 | lse->fim=NULL; 98 | }else{ 99 | ant->prox = cam->prox; 100 | if (cam->prox == NULL) 101 | lse->fim = ant; 102 | } 103 | free(cam); 104 | lse->tamanho--; 105 | } 106 | return carga; 107 | 108 | } 109 | 110 | 111 | void* acessar_lse(t_lse* lse, int pos){ 112 | pos = (pos>lse->tamanho?pos%lse->tamanho:pos); 113 | t_elemento_lse *cam = lse->inicio; 114 | void* carga_util=NULL; 115 | 116 | if (lse->inicio){ 117 | int i=1; 118 | while(iprox; 120 | i++; 121 | } 122 | carga_util = cam->carga_util; 123 | } 124 | return carga_util; 125 | } 126 | 127 | void imprimir_lse(t_lse *lse){ 128 | t_elemento_lse *cam = lse->inicio; 129 | while(cam){ 130 | lse->imprimir(cam->carga_util); 131 | cam = cam->prox; 132 | } 133 | } 134 | 135 | void* buscar_lse(t_lse* lse, void* chave){ 136 | t_elemento_lse* cam=lse->inicio; 137 | 138 | while( (cam!=NULL) && (lse->comparar(cam->carga_util, chave)!=0)){ 139 | cam = cam->prox; 140 | } 141 | if (cam != NULL) 142 | return cam->carga_util; 143 | else 144 | return NULL; 145 | } 146 | -------------------------------------------------------------------------------- /Modulo01/docs/imgs/elemento_lse.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
Carga
Util
Carga...
Próximo
PróximoText is not SVG - cannot display -------------------------------------------------------------------------------- /Modulo03/docs/sobreArvores.md: -------------------------------------------------------------------------------- 1 | # Introdução 2 | 3 | Neste trabalho você e sua equipe irão implementar e comparar dois algoritmos para balanceamento de árvores binárias de busca. 4 | 5 | Os algoritmos implementados serão testados usando uma base de dados qualquer (mais detalhes a seguir), e o conjunto de operações típicos envolvendo as árvores: Inserção, Remoção e Busca. 6 | 7 | Para cada uma dessas operações você vai precisar registrar as comparações realizadas envolvendo os elementos armazenados na árvore. 8 | 9 | Para tanto a sua implementação dos algoritmos precisar ser argumentada com código que realize a contagem das comparações, e permita a apresentação dos valores das contagens. Além disso, a sua implementação deve está preparada para receber qualquer tipo de dado. 10 | 11 | # Argumentações nos algoritmos 12 | 13 | Será necessário dotar as implementações com código que permita a contagem das comparações realizadas em cada operação (busca, remoção e inserção) realizada na árvore. 14 | 15 | Para isso, considere a incorporação de estruturas na definição do tipo árvore, que permita armazenar: 16 | 17 | 1) O número de operações (busca, inserção e remoção); 18 | 2) O número de comparações realizadas por cada tipo de operação; 19 | 3) O número de manipulações (rotações) nas operações de inserção e remoção. 20 | 21 | # As bases de dados 22 | 23 | Sua implementação deve está preparada para manipular qualquer tipo de dado, portanto deve está neutralizada com relação aos dados armazenados. 24 | 25 | Considere que para qualquer base de dados que veja ser utilizada, será necessário desacoplar a solução que usa a árvore, da implementação da árvore. 26 | 27 | Para a realização de testes será disponibilizadas uma base contendo as seguintes informações: 28 | 29 | ```json 30 | { timestamp:inteiro, 31 | dia:inteiro, 32 | mes:inteiro, 33 | ano:inteiro, 34 | hora:inteiro, 35 | minuto:inteiro, 36 | radiacao_solar:inteiro, 37 | temperatura:double, 38 | umidade_relativa: double 39 | } 40 | ``` 41 | 42 | # Sobre a submissão 43 | 44 | Você e sua equipe precisarão submeter a implementação da sua solução, seguindo as orientações dadas a seguir: 45 | 46 | 1) O nome do arquivo de cada implementação arv_<*>.c arv_<*>.h 47 | 2) Os tipos árvores precisam ser nomeados t_<*>, onde * deve ser: 48 | i) **red** para árvore vermelho e preto; 49 | ii) **avl** para árvore AVL. 50 | 2) O relatório apresentado: 51 | 2.1) Introdução - Apresentação do problema 52 | 2.2) Métodos - Algoritmos implementados 53 | 2.3) Resultados - As estatísticas coletadas e comentários 54 | 2.4) Conclusão - Observações gerais sobre a realização do trabalho. 55 | 56 | Na nomeação do arquivo, o (*) asterísco deve ser substituído pelas (03) três primeiras letras do nome do algoritmo implementado, naquele arquivo. Os arquivos arv_avl.c e arv_avl.h são os nomes que você precisa usar para implementar a árvore AVL. Nos arquivos arv_red.c arv_red.h são os nomes que você precisa usar para implementar a árvore RED. 57 | 58 | ![width:600px center](./estrutura.drawio.svg) 59 | 60 | 61 | Os algoritmos que podem ser implementados: 62 | 63 | - AVL (avl) [visualização](https://www.cs.usfca.edu/~galles/visualization/AVLtree.html) [apresentação](https://www.geeksforgeeks.org/what-is-avl-tree-avl-tree-meaning/) 64 | - Red-Black (red) [visualização](https://www.cs.usfca.edu/~galles/visualization/RedBlack.html) [apresentação](https://www.geeksforgeeks.org/introduction-to-red-black-tree/) 65 | 66 | 67 | # Critérios para avaliação 68 | 69 | Os critérios para avaliar o seu trabalho será como segue: 70 | 71 | 1) Implementou os dois Algoritmos (nota máxima 10 (dez)) 72 | 2) Implementou apenas UM algoritmo (nota máxima 06 (seis)) 73 | 74 | Será ainda considerado: 75 | 76 | 1) Relatório apresentado; 77 | 2) Funcionalidades implementadas; 78 | 3) A neutralização das estruturas; 79 | 80 | # Sobre as equipes 81 | 82 | O trabalho deve ser implementado em equipe. As equipes podem ter ATÉ 4(quatro) membros. 83 | 84 | No final do relatório, deve-se listar a contribuição de cada membro na elaboração do trabalho. Por exemplo, *Maria Júlia concebeu as estruturas de argumentação (ampliação) de funcionalidade de estatísticas*; *Pedro Paulo implementou a operação de inserção e remoção em uma AVL*. 85 | 86 | Data de entrega: 28-06-2023. -------------------------------------------------------------------------------- /Modulo02/prova/radix.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | 6 | 7 | // Definição da estrutura para os nós da lista encadeada 8 | 9 | typedef struct Node { 10 | 11 | int value; 12 | 13 | struct Node* next; 14 | 15 | } Node; 16 | 17 | 18 | 19 | // Função auxiliar para criar um novo nó da lista 20 | 21 | Node* createNode(int value) { 22 | 23 | Node* newNode = (Node*)malloc(sizeof(Node)); 24 | 25 | newNode->value = value; 26 | 27 | newNode->next = NULL; 28 | 29 | return newNode; 30 | 31 | } 32 | 33 | 34 | 35 | // Função para inserir um nó no final da lista encadeada 36 | 37 | void insertNode(Node** head, int value) { 38 | 39 | Node* newNode = createNode(value); 40 | 41 | if (*head == NULL) { 42 | 43 | *head = newNode; 44 | 45 | } else { 46 | 47 | Node* current = *head; 48 | 49 | while (current->next != NULL) { 50 | 51 | current = current->next; 52 | 53 | } 54 | 55 | current->next = newNode; 56 | 57 | } 58 | 59 | } 60 | 61 | 62 | 63 | // Função para concatenar duas listas encadeadas 64 | 65 | Node* concatenateLists(Node* head1, Node* head2) { 66 | 67 | if (head1 == NULL) { 68 | 69 | return head2; 70 | 71 | } 72 | 73 | Node* current = head1; 74 | 75 | while (current->next != NULL) { 76 | 77 | current = current->next; 78 | 79 | } 80 | 81 | current->next = head2; 82 | 83 | return head1; 84 | 85 | } 86 | 87 | 88 | 89 | // Função para imprimir os valores de uma lista encadeada 90 | 91 | void printList(Node* head) { 92 | 93 | Node* current = head; 94 | 95 | while (current != NULL) { 96 | 97 | printf("%d ", current->value); 98 | 99 | current = current->next; 100 | 101 | } 102 | 103 | printf("\n"); 104 | 105 | } 106 | 107 | 108 | 109 | // Função para liberar a memória alocada para a lista encadeada 110 | 111 | void freeList(Node* head) { 112 | 113 | Node* current = head; 114 | 115 | while (current != NULL) { 116 | 117 | Node* temp = current; 118 | 119 | current = current->next; 120 | 121 | free(temp); 122 | 123 | } 124 | 125 | } 126 | 127 | 128 | 129 | // Função para realizar o radix-sort 130 | 131 | void radixSort(int arr[], int n) { 132 | 133 | // Encontra o maior valor absoluto no vetor 134 | 135 | int max = abs(arr[0]); 136 | 137 | for (int i = 1; i < n; i++) { 138 | 139 | if (abs(arr[i]) > max) { 140 | 141 | max = abs(arr[i]); 142 | 143 | } 144 | 145 | } 146 | 147 | 148 | 149 | // Executa o radix-sort para cada dígito 150 | 151 | for (int exp = 1; max / exp > 0; exp *= 10) { 152 | 153 | // Cria listas encadeadas vazias para cada dígito 154 | 155 | Node* buckets[20] = {NULL}; 156 | 157 | 158 | 159 | // Distribui os valores para as listas encadeadas 160 | 161 | for (int i = 0; i < n; i++) { 162 | 163 | int digit = (arr[i] / exp) % 10; 164 | 165 | int index = digit + 9; // Mapeia o intervalo [-9, 9] para [0, 18] 166 | 167 | insertNode(&buckets[index], arr[i]); 168 | 169 | } 170 | 171 | 172 | 173 | // Reconstrói o vetor original observando os agrupamentos nas listas encadeadas 174 | 175 | int index = 0; 176 | 177 | for (int i = 0; i < 20; i++) { 178 | 179 | Node* currentBucket = buckets[i]; 180 | 181 | while (currentBucket != NULL) { 182 | 183 | arr[index++] = currentBucket->value; 184 | 185 | Node* temp = currentBucket; 186 | 187 | currentBucket = currentBucket->next; 188 | 189 | free(temp); 190 | 191 | } 192 | 193 | } 194 | 195 | } 196 | 197 | } 198 | 199 | 200 | 201 | int main() { 202 | 203 | int n; 204 | 205 | 206 | 207 | printf("Digite o tamanho do vetor: "); 208 | 209 | scanf("%d", &n); 210 | 211 | 212 | 213 | int arr[n]; 214 | 215 | printf("Digite os elementos do vetor:\n"); 216 | 217 | for (int i = 0; i < n; i++) { 218 | 219 | scanf("%d", &arr[i]); 220 | 221 | } 222 | 223 | 224 | 225 | printf("Array antes da ordenacao: "); 226 | 227 | for (int i = 0; i < n; i++) { 228 | 229 | printf("%d ", arr[i]); 230 | 231 | } 232 | 233 | printf("\n"); 234 | 235 | 236 | 237 | radixSort(arr, n); 238 | 239 | 240 | 241 | printf("Array apos a ordenacao: "); 242 | 243 | for (int i = 0; i < n; i++) { 244 | 245 | printf("%d ", arr[i]); 246 | 247 | } 248 | 249 | printf("\n"); 250 | 251 | 252 | 253 | return 0; 254 | 255 | } -------------------------------------------------------------------------------- /Modulo01/docs/atividades.md: -------------------------------------------------------------------------------- 1 | --- 2 | marp: true 3 | title: Atividade com Vetor 4 | author: César Melo 5 | theme: gaia 6 | --- 7 | # Variáveis 8 | 9 | def. __Uma variável representa um conceito presente no contexto em que a rotina computacional está sendo implementada.__ 10 | 11 | Ex. __idade, nota, matricula__ 12 | 13 | - Uma variável possui 14 | - tipo; 15 | - nome; 16 | - escopo (local, global) 17 | --- 18 | # Declaração das variáveis 19 | Sintaxe geral: 20 | ```C 21 | 22 | ``` 23 | Exemplo: 24 | ```C 25 | int idade; 26 | double nota; 27 | char nome[60]; 28 | ``` 29 | 30 | --- 31 | # Mais sobre variável 32 | 33 | - Pelo nome acessamos o valor associado 34 | 35 | ```C 36 | printf("%d", idade); 37 | printf("%s", nome); 38 | printf("%.2lf", nota); 39 | ``` 40 | 41 | - Pelo nome acessamos o endereço de memória associado (operador unário __&__ ) 42 | 43 | ```C 44 | printf("%p", &idade); 45 | printf("%p", &nome); 46 | printf("%p", ¬a); 47 | ``` 48 | --- 49 | # Escopos de variáveis 50 | arquivo.c 51 | ```C 52 | double media; 53 | 54 | void calcular_media(double nota_1, double nota_2){ 55 | media = (nota_1+nota_2)/2.0 56 | if ((media > 7.8) && (media < 8.0)){ 57 | media = 8.0 58 | } 59 | } 60 | int main(){ 61 | double nota_1, nota_2, media=10.0; 62 | calcular_media(8.0,8.5); 63 | printf("%.2lf %lf %lf", media, nota_1, nota_2); 64 | } 65 | ``` 66 | --- 67 | # Declarações de variáveis 68 | ```C 69 | double nota; // reserva memória e associa o nome. 70 | 71 | double* p_nota; // reserva memória e associa nome. 72 | 73 | nota = 9.0; // atribui valor 74 | p_nota = ¬a; // atribui valor (endereço da variável) 75 | 76 | printf("%lf\n", nota); // qual é o valor? 77 | printf("%p\n", p_nota); 78 | printf("%lf\n", *p_nota); 79 | 80 | ``` 81 | --- 82 | # Alocação dinâmica de memória 83 | - Variável anônima 84 | - criada em tempo de execução; 85 | - apenas o seu endereço é conhecido 86 | - Declaração 87 | - malloc(); 88 | - manipulação via ponteiros; 89 | - Ponteiros são variáveis ``especiais''' 90 | - int* p_idade; 91 | - double* p_nota; 92 | --- 93 | Exemplos: 94 | ```C 95 | #include "stdlib.h"" 96 | 97 | int* criar_variavel(){ 98 | return malloc(sizeof(int)); 99 | } 100 | 101 | int main(){ 102 | int* p = criar_variavel(); 103 | 104 | p = 10; 105 | *p = 10; 106 | printf("%d", p); 107 | printf("%p", *p); 108 | printf("%d", *p); 109 | } 110 | `````` 111 | 112 | ___ 113 | # Vetores 114 | 115 | __Definição__. Variável composta Homogênea que agrupa valores de um __mesmo tipo__ sob a referência de um único __nome__. 116 | 117 | 1. Considere que: 118 | * Valores são acessados individualmente 119 | * O acesso é feito por meio de índice 120 | * Os índices variam entre [0,N-1], *N* é o tamanho do vetor 121 | 122 | 2. Sintaxe 123 | * Nome_do_vetor [];* 124 | --- 125 | # Vetores (II) 126 | 127 | 1. Exemplos de definição 128 | ```C 129 | int faltas[62]; 130 | double notas[62]; 131 | char nome_aluno[62][100]; 132 | ``` 133 | 134 | 2. Exemplos de acesso 135 | ```C 136 | printf("%d", faltas[0]); 137 | printf("%s", nome_aluno[5]); 138 | ``` 139 | 140 | --- 141 | # Atividade: O maior 142 | 143 | Escreva um algoritmos que encontre o Maior valor em um vetor não ordenado, que representa o número de faltas dos alunos da disciplina. 144 | 145 | Seu programa deve imprimir o maior valor encontrado, seguido pelo índices dos elementos do vetor que tem valor igual ao valor indicado. 146 | 147 | Considere o seguinte vetor V={10,3,5,6,7,10}, com 6 elementos. O seu programa deve produzir como saida o seguinte resultado: 148 | * maior: 10 149 | * indice(s): 0 5 150 | 151 | --- 152 | # Atividade: O Endereço 153 | Defina um vetor com 10 elementos dos tipos __double__, __int__, e __char__. 154 | 155 | Em seguida realize a seguintes operações: 156 | ```C 157 | printf("%p\n", nome_do_vetor_de_int); 158 | printf("%p\n", nome_do_vetor_de_double); 159 | printf("%p\n", nome_do_vetor_de_char); 160 | 161 | printf("%p\n", nome_do_vetor_de_double); 162 | printf("%p\n", nome_do_vetor_de_double+9); 163 | printf("%lf\n", *nome_do_vetor_de_double); 164 | ``` 165 | 166 | Aponte ao colega as saídas. Se ele discordar, qual é a visão dele? 167 | 168 | --- 169 | # Atividade: Intercalação 170 | Um vetor __V__ de inteiros foi divido em duas partes indexadas pelas variávies __k, l e m__. A primeira parte do vetor é indexada no intervalo [k,l] e a segunda parte do vetor é indexada no intervalo [l+1,m]. Escreva um programa que intercale essas duas partes armazenando o resultado da intercalação no vetor __V__. 171 | 172 | --- 173 | # Atividade: Intercalação (Instância) 174 | | Instância | | Resultado | 175 | |-------------------- |----- |--- | 176 | ![width:500px](imgs/vetor-intercalar.svg)| |![width:500px](imgs/vetor-intercalar-res.svg) 177 | 178 | 179 | 180 | -------------------------------------------------------------------------------- /Modulo04/src/bfs.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "assert.h" 4 | //#include "../../Modulo01/src/202301/fila.h" 5 | #include "fila.h" 6 | 7 | typedef struct grafo 8 | { 9 | int tam_vertice; 10 | int tam_aresta; 11 | void* **matriz; 12 | 13 | /* data */ 14 | } t_grafo; 15 | 16 | t_grafo* criar_grafo(int nro_vertices){ 17 | t_grafo* g = malloc(sizeof(t_grafo)); 18 | g->tam_vertice = nro_vertices; 19 | g->tam_aresta = 0; 20 | 21 | g->matriz = malloc(sizeof(int*)*g->tam_vertice); 22 | for(int i=0;itam_vertice;i++){ 23 | g->matriz[i] = malloc(sizeof(void*)*g->tam_vertice); 24 | 25 | } 26 | for(int i=0;itam_vertice;i++){ 27 | for(int j=0;jtam_vertice;j++){ 28 | g->matriz[i][j] = NULL; 29 | } 30 | } 31 | return g; 32 | } 33 | 34 | void adicionar_aresta_grafo(t_grafo *g, int u, int v, void* info){ 35 | assert((u>=0 && utam_vertice)); 36 | assert((v>=0 && vtam_vertice)); 37 | 38 | g->matriz[u][v] = info; 39 | 40 | } 41 | 42 | int adjs_vertice_grafo(t_grafo *g, int u, int adjs[]){ 43 | int nro_adjs = 0; 44 | for(int v=0; vtam_vertice; v++ ){ 45 | if( g->matriz[u][v] != NULL ){ 46 | nro_adjs++; 47 | adjs[nro_adjs-1] = v; 48 | } 49 | 50 | } 51 | return nro_adjs; 52 | } 53 | 54 | int nro_vertice_grafo(t_grafo *G){ 55 | return G->tam_vertice; 56 | } 57 | 58 | void print_grafo(t_grafo *G){ 59 | for (int i=0;itam_vertice;i++){ 60 | for (int j=0;jtam_vertice;j++){ 61 | printf(" (%02d, %02d) %c", i,j,(G->matriz[i][j]?'T':'F')); 62 | } 63 | printf("\n"); 64 | } 65 | } 66 | 67 | 68 | // contexto BFS 69 | #define BRANCO 1 70 | #define CINZA 2 71 | #define PRETO 3 72 | 73 | #define INFINITO 999999 74 | #define NIL -1 75 | 76 | typedef struct info_bfs{ 77 | int id; 78 | int pi; 79 | int cor; 80 | int distancia; 81 | } t_info_bfs; 82 | 83 | t_info_bfs* criar_info_bfs(int id){ 84 | t_info_bfs* v = malloc(sizeof(t_info_bfs)); 85 | v->id = id; 86 | v->pi = NIL; 87 | v->cor = BRANCO; 88 | v->distancia = INFINITO; 89 | return v; 90 | } 91 | 92 | void mostrar_info_bfs(t_info_bfs* v){ 93 | printf("%d %d %d %d\n", v->id, v->pi, v->cor, v->distancia); 94 | } 95 | 96 | t_info_bfs** bfs(t_grafo *G, int fonte){ 97 | 98 | int nro_vertices = nro_vertice_grafo(G); 99 | t_info_bfs** vertices_bfs = malloc(sizeof(t_info_bfs)*nro_vertices); 100 | 101 | for(int i=0;icor = CINZA; 108 | s->distancia = 0; 109 | 110 | enfileirar(no_explorados,s); 111 | 112 | while (tamanho_fila(no_explorados)>0){ 113 | t_info_bfs* u = desenfileirar(no_explorados); 114 | 115 | int adjs[nro_vertices]; 116 | int nro_adjs = adjs_vertice_grafo(G, u->id, adjs); 117 | 118 | printf("iniciou a exploração: %d ", u->id); 119 | printf("nro_adjs: %d\n", nro_adjs); 120 | 121 | for(int i=0;i< nro_adjs;i++){ 122 | //printf("adj: (%d %d)\n", u->id, adjs[i]); 123 | 124 | t_info_bfs* v = vertices_bfs[ adjs[i] ]; 125 | if (v->cor == BRANCO){ 126 | v->cor = CINZA; 127 | v->pi = u->id; 128 | v->distancia = u->distancia + 1; 129 | 130 | enfileirar(no_explorados,v); 131 | } 132 | } 133 | u->cor = PRETO; 134 | printf("Encerrou exploração: %d\n", u->id); 135 | } 136 | printf("Encerrou exploração\n"); 137 | 138 | return vertices_bfs; 139 | } 140 | 141 | void __print_caminho_bfs(t_info_bfs* u, t_info_bfs* grafo_bfs[]){ 142 | if (u->pi == NIL){ 143 | printf("%d ", u->id ); 144 | return; 145 | } 146 | __print_caminho_bfs( grafo_bfs[u->pi],grafo_bfs); 147 | printf("%d ", u->id); 148 | } 149 | 150 | void print_grafo_bfs(t_info_bfs* vertices_bfs[], int nro_vertices){ 151 | 152 | for(int i=0;ipi != NIL){ 155 | __print_caminho_bfs(dest,vertices_bfs); 156 | printf("\n"); 157 | }else{ 158 | printf("%d Sem caminho\n", dest->id); 159 | } 160 | } 161 | } 162 | 163 | int main(){ 164 | int *info = malloc(sizeof(int)); *info = 1; 165 | int u,v, nro_vertices; 166 | printf("informe nro vertices: "); 167 | scanf("%d", &nro_vertices); 168 | t_grafo *G = criar_grafo(nro_vertices); 169 | 170 | do{ 171 | printf("informe aresta (u,v):"); 172 | scanf("%d %d", &u, &v); 173 | if ((u>=0) && (v>=0)){ 174 | adicionar_aresta_grafo(G,u,v,info); 175 | adicionar_aresta_grafo(G,v,u,info); 176 | } 177 | }while ((u>=0) && (v>=0)); 178 | 179 | printf("iniciando a busca....\n"); 180 | printf("informe o nó fonte: "); scanf("%d", &u); 181 | 182 | print_grafo(G); 183 | 184 | t_info_bfs** grafo_bfs = bfs(G,u); 185 | print_grafo_bfs(grafo_bfs, nro_vertices); 186 | 187 | return 0; 188 | 189 | } -------------------------------------------------------------------------------- /Modulo02/src/202301/abb.c: -------------------------------------------------------------------------------- 1 | #include "time.h" 2 | #include "stdio.h" 3 | #include "stdlib.h" 4 | #include "abb.h" 5 | 6 | typedef struct no t_no; 7 | struct no{ 8 | void* info; 9 | t_no* ancestral; 10 | t_no* sae; 11 | t_no* sad; 12 | }; 13 | 14 | static t_no* criar_no(void* info, t_no* ancestral){ 15 | t_no* novo = malloc(sizeof(t_no)); 16 | novo->info = info; 17 | novo->sad = NULL; 18 | novo->sae = NULL; 19 | novo->ancestral = ancestral; 20 | 21 | return novo; 22 | } 23 | 24 | struct abb{ 25 | t_no* raiz; 26 | int tamanho; 27 | t_comparar_abb comparar; 28 | t_destruir_abb destruir; 29 | t_imprimir_abb imprimir; 30 | }; 31 | 32 | 33 | t_abb* criar_abb(t_comparar_abb comparar, t_destruir_abb destruir, t_imprimir_abb imprimir){ 34 | t_abb *abb = malloc(sizeof(t_abb)); 35 | abb->raiz = NULL; 36 | abb->tamanho = 0; 37 | abb->comparar = comparar; 38 | abb->destruir = destruir; 39 | abb->imprimir = imprimir; 40 | 41 | return abb; 42 | } 43 | 44 | #define MAX(a,b) (a>b?a:b) 45 | static int _altura_abb(t_no* raiz){ 46 | if (raiz != NULL){ 47 | return MAX(_altura_abb(raiz->sae), _altura_abb(raiz->sad)) + 1; 48 | }else{ 49 | return -1; 50 | } 51 | } 52 | 53 | int altura_abb(t_abb *abb){ 54 | 55 | return _altura_abb(abb->raiz); 56 | } 57 | 58 | static int _tamanho_abb(t_no* no){ 59 | if (no == NULL) 60 | return 0; 61 | return _tamanho_abb(no->sae) + _tamanho_abb(no->sad) + 1; 62 | } 63 | 64 | int tamanho_abb(t_abb *abb){ 65 | return abb->tamanho; 66 | } 67 | 68 | void* _buscar_abb(t_no* raiz, t_comparar_abb comparar, void* chave){ 69 | if(raiz == NULL){ 70 | return NULL; 71 | } 72 | int status = comparar(raiz->info, chave); 73 | if( status == 0){ 74 | return raiz->info; 75 | }else if (status > 0){ 76 | return _buscar_abb(raiz->sae,comparar,chave); 77 | }else{ 78 | return _buscar_abb(raiz->sad,comparar,chave); 79 | } 80 | } 81 | 82 | void* buscar_abb(t_abb *abb, void* chave){ 83 | return _buscar_abb(abb->raiz, abb->comparar, chave); 84 | } 85 | 86 | static t_no* _inserir_abb(t_no* raiz, t_no* ancestral, void* info, t_comparar_abb comparar){ 87 | if (raiz == NULL){ 88 | return criar_no(info, ancestral); 89 | }else{ 90 | int status = comparar(raiz->info, info); 91 | if (status > 0){ // inserir SAE 92 | raiz->sae = _inserir_abb(raiz->sae, raiz, info, comparar); 93 | }else{ // SAD 94 | raiz->sad = _inserir_abb(raiz->sad, raiz, info, comparar); 95 | } 96 | return raiz; 97 | } 98 | } 99 | 100 | void inserir_abb(t_abb *abb, void* info){ 101 | abb->raiz = _inserir_abb(abb->raiz,NULL,info,abb->comparar); 102 | abb->tamanho++; 103 | } 104 | 105 | t_no* _podar_abb(t_no *raiz, int *tamanho, t_destruir_abb destruir){ 106 | if(raiz==NULL){ 107 | return NULL; 108 | } 109 | _podar_abb(raiz->sae, tamanho, destruir); 110 | _podar_abb(raiz->sad, tamanho, destruir); 111 | destruir(raiz->info); 112 | free(raiz); 113 | *tamanho = *tamanho-1; 114 | return NULL; 115 | } 116 | 117 | void podar_abb(t_abb *abb, void* podavel){ 118 | t_no* raiz = _buscar_abb(abb->raiz,abb->comparar, podavel); 119 | if(raiz->ancestral != NULL){ 120 | if (raiz->ancestral->sad == raiz){ 121 | raiz->ancestral->sad = NULL; 122 | }else{ 123 | raiz->ancestral->sae = NULL; 124 | } 125 | } 126 | // ab->tamanho -= _tamanho_ab(raiz); 127 | _podar_abb(raiz, &(abb->tamanho), abb->destruir); 128 | 129 | } 130 | 131 | void _imprimir_abb(t_no* raiz, t_imprimir_abb imprimir){ 132 | if (raiz == NULL){ 133 | return; 134 | } 135 | _imprimir_abb(raiz->sae, imprimir); 136 | imprimir(raiz->info); 137 | _imprimir_abb(raiz->sad, imprimir); 138 | 139 | } 140 | 141 | void imprimir_abb(t_abb *abb){ 142 | _imprimir_abb(abb->raiz, abb->imprimir); 143 | } 144 | 145 | static void _trocar(t_no *n1, t_no* n2){ 146 | void* info = n1->info; 147 | n1->info = n2->info; 148 | n2->info = info; 149 | } 150 | 151 | static t_no* _remover_abb(t_no* raiz, t_comparar_abb comparar, t_destruir_abb destruir, void *buscado){ 152 | if (raiz == NULL){ 153 | return NULL; 154 | } 155 | int status = comparar(raiz->info, buscado); 156 | if(status > 0){ 157 | raiz->sae = _remover_abb(raiz->sae,comparar, destruir,buscado); 158 | }else if(status < 0){ 159 | raiz->sad = _remover_abb(raiz->sad, comparar, destruir, buscado); 160 | }else{ 161 | if ((raiz->sae == NULL) && (raiz->sad == NULL)){ // folha 162 | destruir(raiz->info); 163 | free(raiz); 164 | return NULL; 165 | }else if (raiz->sae == NULL){ //descendente dir 166 | raiz->sad->ancestral = raiz->ancestral; 167 | t_no* sad = raiz->sad; 168 | destruir(raiz->info); 169 | free(raiz); 170 | 171 | raiz = sad; 172 | } else if(raiz->sad == NULL){ //descendente esq 173 | raiz->sae->ancestral = raiz->ancestral; 174 | t_no* sae = raiz->sae; 175 | destruir(raiz->info); 176 | free(raiz); 177 | 178 | raiz = sae; 179 | }else{ // tem descendentes sae sad 180 | t_no* maior = raiz->sae; 181 | while(maior->sad != NULL){ 182 | maior = maior->sad; 183 | } 184 | _trocar(raiz, maior); 185 | raiz->sae = _remover_abb(raiz->sae,comparar,destruir,buscado); 186 | } 187 | } 188 | return raiz; 189 | } 190 | 191 | void remover_abb(t_abb *abb, void* chave){ 192 | abb->raiz = _remover_abb(abb->raiz, abb->comparar, abb->destruir, chave); 193 | } -------------------------------------------------------------------------------- /Modulo01/src/202202/listase.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "string.h" 4 | #include "listase.h" 5 | 6 | /* Tipo elemento da LSE*/ 7 | typedef struct elem_lse t_elemento_lse; 8 | struct elem_lse{ 9 | void* cargautil;// carga util 10 | struct elem_lse* prox;// endereco prox 11 | }; 12 | 13 | /** 14 | * cria um elemento da LSE 15 | */ 16 | t_elemento_lse* criar_elemento_lse(void* cargautil){ 17 | t_elemento_lse* novo = malloc(sizeof(t_elemento_lse)); 18 | novo->cargautil = cargautil; 19 | novo->prox = NULL; 20 | 21 | printf("Criando: %p %p %p\n", novo, novo->cargautil, novo->prox); 22 | 23 | return novo; 24 | } 25 | 26 | /** 27 | * Definição do tipo Lista Simplesmente Encadeada 28 | */ 29 | struct lse{ 30 | 31 | t_elemento_lse* inicio; // Primeiro elemento 32 | t_elemento_lse* fim; 33 | int tamanho; 34 | t_imprimir_lse impressora; 35 | t_comparar_lse comparar; 36 | }; 37 | 38 | t_lse* criar_lse(t_imprimir_lse impressora, t_comparar_lse comparar){ 39 | t_lse* nova; 40 | 41 | nova = malloc(sizeof(t_lse)); 42 | nova->inicio = NULL; 43 | nova->tamanho=0; 44 | nova->impressora = impressora; 45 | nova->comparar = comparar; 46 | 47 | return nova; 48 | } 49 | 50 | // operacoes baseadas em posicao 51 | void inserir_inicio_lse(t_lse* lse, void* carga){ 52 | 53 | t_elemento_lse* novo = criar_elemento_lse(carga); 54 | 55 | novo->prox = lse->inicio; 56 | lse->inicio = novo; 57 | lse->tamanho++; 58 | 59 | } 60 | 61 | void* remover_inicio_lse(t_lse* lse){ 62 | void* carga=NULL; 63 | t_elemento_lse* removivel = lse->inicio; 64 | if (lse->inicio != NULL){ 65 | lse->inicio = removivel->prox; 66 | lse->tamanho--; 67 | carga = removivel->cargautil; 68 | 69 | free(removivel); 70 | } 71 | return carga; 72 | } 73 | 74 | void* acessar_lse(t_lse* lse, int pos){ 75 | int i=1; 76 | void* carga=NULL; // entrada invalida 77 | if (pos<0){ 78 | pos = (pos % lse->tamanho) + (lse->tamanho+1); 79 | pos = (pos==0?1:pos); 80 | }else if(pos>0){ 81 | pos = pos % lse->tamanho; 82 | pos = (pos==0?lse->tamanho:pos); 83 | }else{ 84 | return carga; 85 | } 86 | 87 | t_elemento_lse* cam = lse->inicio; 88 | if ((pos<=lse->tamanho)){ 89 | while(iprox; 91 | i++; 92 | } 93 | carga = cam->cargautil; 94 | } 95 | return carga; 96 | } 97 | 98 | void inserir_final_lse(t_lse* lse, void* carga){ 99 | t_elemento_lse* novo = criar_elemento_lse(carga); 100 | if(lse->tamanho == 0){ // lse->inicio == NULL 101 | lse->inicio = novo; 102 | lse->fim = novo; 103 | }else{ 104 | // t_elemento_lse* cam = lse->inicio; 105 | // while(cam->prox!=NULL){ 106 | // cam=cam->prox; 107 | // } 108 | // cam->prox = novo; 109 | lse->fim->prox = novo; 110 | lse->fim = novo; 111 | } 112 | lse->tamanho++; 113 | } 114 | 115 | void* remover_final_lse(t_lse* lse){ 116 | void* carga=NULL; 117 | 118 | t_elemento_lse* ant=NULL; 119 | t_elemento_lse* cam=lse->inicio; 120 | if (lse->tamanho == 0){ 121 | return carga; 122 | }else if(lse->tamanho == 1){ 123 | cam = lse->inicio; 124 | lse->inicio=NULL; 125 | lse->fim = NULL; 126 | }else{ 127 | while(cam->prox!=NULL){ 128 | ant = cam; 129 | cam = cam->prox; 130 | } 131 | ant->prox = NULL; 132 | lse->fim = ant; 133 | } 134 | carga = cam->cargautil; 135 | free(cam); 136 | lse->tamanho--; 137 | return carga; 138 | } 139 | 140 | void imprimir_lse(t_lse *lse){ 141 | t_elemento_lse* cam = lse->inicio; 142 | while(cam!=NULL){ 143 | lse->impressora(cam->cargautil); 144 | cam = cam->prox; 145 | } 146 | } 147 | 148 | void inserir_lse(t_lse* lse, void* nova_carga){ 149 | t_elemento_lse* cam = lse->inicio; 150 | t_elemento_lse* ant=NULL; 151 | 152 | lse->tamanho++; 153 | t_elemento_lse* novo = criar_elemento_lse(nova_carga); 154 | if (lse->inicio == NULL){ // lista vazia 155 | lse->inicio = novo; 156 | }else{ 157 | while( (cam!=NULL) && (lse->comparar(cam->cargautil, nova_carga)<0)){ 158 | ant = cam; 159 | cam = cam->prox; 160 | } 161 | // inicio 162 | if(cam == lse->inicio){ 163 | novo->prox = cam; 164 | lse->inicio = novo; 165 | }else{ 166 | ant->prox = novo; 167 | novo->prox = cam; 168 | if (cam == NULL) 169 | lse->fim = novo; 170 | } 171 | } 172 | } 173 | 174 | void* buscar_lse(t_lse* lse, void* chave){ 175 | t_elemento_lse* cam=lse->inicio; 176 | 177 | while( (cam!=NULL) && (lse->comparar(cam->cargautil, chave)!=0)){ 178 | cam = cam->prox; 179 | } 180 | if (cam != NULL) 181 | return cam->cargautil; 182 | else 183 | return NULL; 184 | } 185 | 186 | void* remover_lse(t_lse* lse, void* chave){ 187 | t_elemento_lse* cam = lse->inicio; 188 | t_elemento_lse* ant = NULL; 189 | 190 | while( (cam!=NULL) && (lse->comparar(cam->cargautil , chave)!=0)){ 191 | ant = cam; 192 | cam = cam->prox; 193 | } 194 | 195 | void* carga = NULL; 196 | if (cam != NULL){ 197 | carga = cam->cargautil; 198 | if (cam == lse->inicio){ // inicio? 199 | lse->inicio = cam->prox; 200 | if (cam->prox == NULL) 201 | lse->fim=NULL; 202 | }else{ 203 | ant->prox = cam->prox; 204 | if (cam->prox == NULL) 205 | lse->fim = ant; 206 | } 207 | free(cam); 208 | lse->tamanho--; 209 | } 210 | return carga; 211 | 212 | } 213 | // Lista no contexto neutralizado (genérico) 214 | 215 | -------------------------------------------------------------------------------- /Modulo02/docs/slides.md/tfidf.md: -------------------------------------------------------------------------------- 1 | --- 2 | marp: true 3 | theme: gaia 4 | title: Como calcular TF-IDF 5 | --- 6 | 7 | # **Calculando TF-IDF** 8 | implementação do Índice Remissivo 9 | 10 | --- 11 | # Suposições para esse exemplo 12 | 13 | 1. Considere um livro com três páginas; 14 | 2. Todo o texto será considerado; 15 | 3. Cada página terá os seguintes textos 16 | - Página 1: Maria vai para praia tomar sol. 17 | - Página 2: Na praia havia uma barraca e uma cadeira . 18 | - Página 3: Praia e Sol combina com domingo. 19 | --- 20 | # Os passos 21 | 22 | 1. Limpeza dos dados 23 | 2. Calcule a frequência das palavras, nas páginas e na obra; 24 | 3. Encontre o TF das palavras; 25 | 4. Encontre o IDF das palavras; 26 | 5. Encontre o TF-IDF das palavras; 27 | --- 28 | # Passo 1: Limpeza 29 | 30 | Palavra| 31 | ------ | 32 | maria | 33 | vai | 34 | para | 35 | praia| 36 | tomar | 37 | sol | 38 | na | 39 | havia | 40 | uma | 41 | barraca | 42 | e | 43 | cadeira | 44 | combina | 45 | com | 46 | domingo | 47 | 48 | --- 49 | 50 | # Passo 2: frequência 51 | 52 | Palavra| Frequência | 53 | ------ | ---------- | 54 | maria | 1 | 55 | vai | 1 | 56 | para | 1 | 57 | praia| 3 | 58 | tomar | 1 | 59 | sol | 2 | 60 | na | 1 | 61 | havia | 1 | 62 | uma | 2 | 63 | barraca | 1 | 64 | e | 2 | 65 | cadeira | 1 | 66 | combina | 1 | 67 | com | 1 | 68 | domingo | 1 | 69 | 70 | --- 71 | # Passo 3: Encontrar o TF das palavras nas páginas 72 | 73 | \# de ocorrências da palavra na página dividido pelo # de palavras na página 74 | 75 | Página 1: Maria vai para praia tomar sol 76 | 77 | Palavra| TF | 78 | -------| -- | 79 | maria | 0.16 | 80 | vai | 0.16 | 81 | para | 0.16 | 82 | praia | 0.16 | 83 | tomar | 0.16 | 84 | sol | 0.16 | 85 | 86 | --- 87 | # Passo 3: TF em todo o texto 88 | 89 | Palavra| Frequência | Página 1| Página 2 | Página 3| 90 | ------ | ---------- | --------| ------| ------ | 91 | maria | 1 | 0.16 | 0.0 | 0.0 | 92 | vai | 1 | 0.16 | 0.0 | 0.0 | 93 | para | 1 | 0.16 | 0.0 | 0.0 | 94 | praia| 3 | 0.16 | 0.12 | 0.16 | 95 | tomar | 1 | 0.16 | 0.0 | 0.0 | 96 | sol | 2 | 0.16 | 0.0 | 0.16 | 97 | na | 1 | 0.0 | 0.12 | 0.0 | 98 | havia | 1 | 0.0 | 0.12 | 0.0 | 99 | uma | 2 | 0.0 | 0.25 | 0.0 | 100 | barraca | 1 | 0.0 | 0.12 | 0.0 | 101 | e | 2 | 0.0 |0.12 | 0.16 | 102 | cadeira | 1 | 0.0 | 0.12 | 0.0 | 103 | combina | 1 | 0.0 | 0.0| 0.16 | 104 | com | 1 | 0.0 | 0.0 | 0.16 | 105 | domingo | 1 | 0.0 | 0.00| 0.16 | 106 | 107 | --- 108 | 109 | # Passo 4: Encontrar IDF das palavras 110 | 111 | IDF = $ln(\#\_de\_páginas/\#\_de\_páginas\_que\_contém\_palavra) $ 112 | 113 | Palavra| IDF | 114 | ------ | ---------- | 115 | maria | $ln(3/1) = 1.09$ | 116 | vai | 1.09 | 117 | para | 1.09 | 118 | praia| $ln(3/3) = 0$ | 119 | tomar | 1.09 | 120 | sol | $ln(3/2) = 0.41$ | 121 | na | 1.09 | 122 | havia | 1.09 | 123 | uma | 1.09 | 124 | barraca | 1.09 | 125 | e | 0.41 | 126 | cadeira | 1.09 | 127 | combina | 1.09 | 128 | com | 1.09 | 129 | domingo | 1.09 | 130 | 131 | --- 132 | # Passo 5: Encontrar TF-IDF das palavras em cada página 133 | 134 | IDF = $ln(\#\_de\_páginas/\#\_de\_páginas\_que\_contém\_palavra) $ 135 | 136 | Palavra| Página 1 | Página 2 | Página 3 | 137 | ------ | -------- | -------- | -------- | 138 | maria | $0.16\times1.09 = 0.1744$ | 139 | vai | $0.1744$ | 140 | para | $0.1744$ | 141 | praia| $0.16\times0.0 = 0.0$ | $0.12\times0.0 = 0.0$ | $0.16\times0.0 = 0.0$ | 142 | tomar | $0.16\times1.09 = 0.1744$ | 143 | sol | $0.16\times0.41 = 0.0656$ | 144 | na | | $0.12\times1.09 = 0.1308$ | 145 | havia | | $0.1308$ | | 146 | uma | | $0.1308$ | 147 | barraca | | $0.12\times1.09=0.1208$ | 148 | e | | $0.12\times0.41 = 0.0492$ | $0.16\times0.41=0,0656$| 149 | cadeira | | $0.12\times1.09=0.1208$ | | 150 | combina | | | $0.16\times1.09= 0.1744$ | 151 | com | | | $0.1744$ | 152 | domingo| | | $0.1744$ | 153 | 154 | ---- 155 | 156 | # Analise do TF-IDF Calculado 157 | 158 | Palavra\pagina | maria|vai|para|praia|tomar|sol|na|havia|uma|barraca|e|cadeira|combina|com|domingo| 159 | ------- | -----|---|----|-----|-----|---|--|-----|---|-------|-|-------|-------|---|-------| 160 | \# 1|0.1744|0.1744|0.1744|0|0.1744|0.0656|0|0|0|0|0|0|0|0|0 161 | \# 2|0|0|0|0|0|0|0.1308|0.1308|0.1308|0.1208|0.0492|0.1208|0|0|0 162 | \# 3|0|0|0|0|0||0|0|0|0|0.0656|0|0.1744|0.1744|0.1744 163 | 164 | --- 165 | 166 | # Critério de seleção por agrupamento 167 | 168 | Palavra|Pagina 1|Pagina 2|Pagina 3 | Limite superior | Limite inferior (75\%)| 169 | -------|--------|--------|--------| ------ | ------ | 170 | B | ||| 0.1208 | 0.0906 171 | barraca|0|$0.1208$|0| || 172 | C ||| | 0.1744 | 0.1308 173 | cadeira|0|0.1208|0 || 174 | com|0|0|$0.1744$ | | | 175 | combina|0|0|0.1744| | 176 | D|0|0|| 0.1744 | 0.1308 177 | domingo|0|0||| 178 | E|0||| 0.0656 | 0.0492 179 | e|0|0.0492||| 180 | H|||| 0.1308 | 0.0981 181 | havia|0|$0.1308$|0|| 182 | M|||| 0.1744 | 0.1308 183 | maria|0.1744|0|0|| 184 | N|||| 0.1308 | 0.0981 185 | na|0|$0.1308$|0|| 186 | P|||| 0.1744 | 0.1308 187 | para|$0.1744$|0|0| 0.1744 | 0.1308 188 | praia|0|0|0| | 189 | S|||| 0.0656 | 0.0492 190 | sol|$0.0656$|0|0| | 191 | T|||| 0.1744 | 0.1308 192 | tomar|$0.1744$|0|0| 0.1744 | 0.1308 193 | U|||| 0.1308 | 0.0981 194 | uma|0|$0.1308$|0|| 195 | V|||| 0.1744 | 0.1308 196 | vai|0.1744|0|0|| 197 | 198 | --- 199 | # Critério de seleção global 200 | 201 | Palavra|Pagina 1|Pagina 2|Pagina 3 | Limite superior | Limite inferior (85\%)| 202 | -------|--------|--------|--------| ------ | ------ | 203 | | ||| | 0.1744 | 0.1482 204 | B | ||| | 205 | barraca|0|$0.1208$|0| || 206 | C ||| | | 207 | cadeira|0|0.1208|0 || 208 | com|0|0|$0.1744$ | | | 209 | combina|0|0|0.1744| | 210 | D|0|0|| | 211 | domingo|0|0||| 212 | E|0||| | 213 | e|0|0.0492||| 214 | H|||| | 215 | havia|0|$0.1308$|0|| 216 | M|||| | 217 | maria|0.1744|0|0|| 218 | N|||| | 219 | na|0|$0.1308$|0|| 220 | P|||| | 221 | para|$0.1744$|0|0| 0.1744 | 0.1308 222 | praia|0|0|0| | 223 | S|||| 0.0656 | 0.0492 224 | sol|$0.0656$|0|0| | 225 | T|||| | 226 | tomar|$0.1744$|0|0| 0.1744 | 0.1308 227 | U|||| | 228 | uma|0|$0.1308$|0|| 229 | V|||| | 230 | vai|0.1744|0|0|| 231 | --- 232 | 233 | 234 | # Obrigado! 235 | boa sorte -------------------------------------------------------------------------------- /Modulo03/202202/src/ab.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "time.h" 4 | #include "string.h" 5 | 6 | typedef struct no TNo; 7 | struct no{ 8 | void* info; 9 | TNo* sae; 10 | TNo* sad; 11 | TNo* ancestral; 12 | }; 13 | 14 | TNo* criar_no(TNo* ascentral, void* info){ 15 | TNo* novo = malloc(sizeof(TNo)); 16 | novo->info = info; 17 | novo->sae = NULL; 18 | novo->sad = NULL; 19 | novo->ancestral = ascentral; 20 | 21 | return novo; 22 | } 23 | 24 | typedef void(*TImprimirAB)(void* info); 25 | typedef int(*TCompararAB)(void* s1, void* s2); 26 | typedef struct ab{ 27 | TNo* raiz; 28 | TImprimirAB imprimir; 29 | TCompararAB comparar; 30 | // removerInfoNo 31 | } t_ab; 32 | 33 | t_ab* criarAB(TImprimirAB imprimir, TCompararAB comparar){ 34 | t_ab* ab = malloc(sizeof(t_ab)); 35 | 36 | ab->raiz = NULL; 37 | ab->imprimir = imprimir; 38 | ab->comparar = comparar; 39 | 40 | return ab; 41 | } 42 | 43 | 44 | static void conectaRaizSAE(TNo *raiz, TNo* sae){ 45 | raiz->sae = sae; 46 | sae->ancestral = raiz; 47 | } 48 | 49 | static void conectaRaizSAD(TNo *raiz, TNo* sad){ 50 | raiz->sad = sad; 51 | sad->ancestral = raiz; 52 | } 53 | 54 | static TNo* __inserirAB(TNo* raiz, void* info){ 55 | //printf("Iniciou inserção \n"); 56 | if (raiz == NULL){ 57 | //printf("Inseriu no \n"); 58 | TNo* novo = criar_no(raiz,info); 59 | return novo; 60 | } 61 | if ((rand()%2) == 1){ // relação aleatória 62 | TNo* sae = __inserirAB(raiz->sae, info); 63 | conectaRaizSAE(raiz, sae); 64 | }else{ 65 | TNo* sad = __inserirAB(raiz->sad, info); 66 | conectaRaizSAD(raiz, sad); 67 | } 68 | 69 | return raiz; 70 | } 71 | 72 | void inserirAB(t_ab *ab, void* info){ 73 | 74 | ab->raiz = __inserirAB(ab->raiz, info); 75 | //printf("Terminou insercao\n"); 76 | 77 | } 78 | 79 | #define MAX(a,b) (a>b?a:b) 80 | 81 | static int __alturaAB(TNo *raiz){ 82 | if (raiz == NULL) 83 | return -1; 84 | return MAX(__alturaAB(raiz->sae), __alturaAB(raiz->sad))+1; 85 | } 86 | 87 | int alturaAB(t_ab *ab){ 88 | return __alturaAB(ab->raiz); 89 | } 90 | 91 | static int __tamanhoAB(TNo* raiz){ 92 | if (raiz == NULL) 93 | return 0; 94 | return (__tamanhoAB(raiz->sae)+__tamanhoAB(raiz->sad))+1; 95 | } 96 | 97 | int tamanhoAB(t_ab *ab){ 98 | return __tamanhoAB(ab->raiz); 99 | 100 | } 101 | 102 | static void __imprimirAB(TNo* raiz, TImprimirAB imprimir){ 103 | if (raiz == NULL) 104 | return; 105 | __imprimirAB(raiz->sae, imprimir); 106 | imprimir(raiz->info); 107 | __imprimirAB(raiz->sad, imprimir); 108 | } 109 | 110 | void imprimirAB(t_ab* ab){ 111 | __imprimirAB(ab->raiz, ab->imprimir); 112 | } 113 | 114 | TNo* __buscarAB(TNo* raiz, void* buscado, TCompararAB comparar){ 115 | // base da recursão 116 | if (raiz == NULL){ 117 | return NULL; 118 | }else if( comparar(raiz->info, buscado) == 0){ 119 | return raiz; 120 | } 121 | 122 | // caminhar na AB 123 | TNo* no = __buscarAB(raiz->sae, buscado, comparar); 124 | if (no == NULL){ 125 | no = __buscarAB(raiz->sad, buscado, comparar); 126 | } 127 | return no; 128 | } 129 | 130 | void* buscarAB(t_ab *ab, void* buscado){ 131 | TNo* no = __buscarAB(ab->raiz, buscado, ab->comparar); 132 | return (no != NULL?no->info:NULL); 133 | 134 | } 135 | 136 | 137 | static void __podarAB(TNo* raiz){ 138 | if (raiz == NULL){ 139 | return; 140 | } 141 | __podarAB(raiz->sae); 142 | __podarAB(raiz->sad); 143 | free(raiz->info); // precisa ajuste 144 | free(raiz); 145 | } 146 | 147 | void podarAB(t_ab* ab, void* info){ 148 | TNo* no = __buscarAB(ab->raiz, info, ab->comparar); 149 | if (no != NULL){ // encontrou a info 150 | if (no == ab->raiz) { // poda drástica 151 | ab->raiz = NULL; 152 | } else { 153 | TNo* ancestral = no->ancestral; 154 | if (ancestral->sae == no){ 155 | ancestral->sae = NULL; 156 | } else { 157 | ancestral->sad = NULL; 158 | } 159 | } 160 | __podarAB(no); 161 | } 162 | } 163 | 164 | //====== USA AB 165 | 166 | typedef struct carro{ 167 | char placa[8]; 168 | int anoFabricacao; 169 | int hora, min; 170 | }t_carro; 171 | 172 | 173 | t_carro* criar_carro(char placa[], int hora, int min, int anoFab){ 174 | t_carro *c = malloc(sizeof(t_carro)); 175 | 176 | strcpy(c->placa,placa); 177 | c->hora = hora; 178 | c->min = min; 179 | c->anoFabricacao = anoFab; 180 | 181 | return c; 182 | } 183 | 184 | void destroy_carro(t_carro *c){ 185 | free(c); 186 | } 187 | 188 | void imprimir_carro(t_carro* c){ 189 | 190 | printf("Placa: %s %d:%d %d\n", c->placa, c->hora, c->min, c->anoFabricacao); 191 | 192 | } 193 | 194 | int comparar_carro(t_carro* c1, t_carro* c2){ 195 | return strcmp(c1->placa,c2->placa); 196 | } 197 | 198 | int main(int argc, char const *argv[]) 199 | { 200 | char placa[9]; 201 | int hora, min, anoFab; 202 | 203 | srand(time(NULL)); 204 | 205 | t_ab *carros = criarAB(imprimir_carro, comparar_carro); 206 | 207 | // leitura para inserir os dados AB; 208 | scanf("%s", placa); 209 | while(strcmp(placa,"FIM")!=0){ 210 | scanf("%d", &hora); 211 | scanf("%d", &min); 212 | scanf("%d", &anoFab); 213 | t_carro* novo = criar_carro(placa, hora, min, anoFab); 214 | 215 | inserirAB(carros, novo); 216 | 217 | scanf("%s", placa); 218 | } 219 | 220 | imprimirAB(carros); 221 | printf("Altura: %d\n", alturaAB(carros)); 222 | printf("Tamanho: %d\n", tamanhoAB(carros)); 223 | 224 | printf("INforme a placa: "); 225 | scanf("%s",placa); 226 | 227 | t_carro* buscado = buscarAB(carros, placa); 228 | 229 | imprimir_carro(buscado); 230 | 231 | do{ 232 | printf("informe placa para podar:"); 233 | scanf("%s", placa); 234 | 235 | podarAB(carros, placa); 236 | buscado = buscarAB(carros, placa); 237 | if (buscado == NULL){ 238 | printf("Ramo podado\n"); 239 | }else{ 240 | printf("Tem erro na poda\n"); 241 | } 242 | }while(strcmp(placa,"FIM")!=0); 243 | 244 | return 0; 245 | } 246 | -------------------------------------------------------------------------------- /Modulo03/202202/src/arv_bb.c: -------------------------------------------------------------------------------- 1 | #include "stdio.h" 2 | #include "stdlib.h" 3 | #include "time.h" 4 | #include "string.h" 5 | #include "arv_bb.h" 6 | 7 | typedef struct no TNo; 8 | struct no{ 9 | void* info; 10 | TNo* sae; 11 | TNo* sad; 12 | TNo* ancestral; 13 | }; 14 | 15 | TNo* criar_no(TNo* ascentral, void* info){ 16 | TNo* novo = malloc(sizeof(TNo)); 17 | novo->info = info; 18 | novo->sae = NULL; 19 | novo->sad = NULL; 20 | novo->ancestral = ascentral; 21 | 22 | return novo; 23 | } 24 | 25 | typedef struct stat{ 26 | int i_nro; 27 | int b_nro; 28 | int r_nro; 29 | int b_cmps; 30 | int i_cmps; 31 | int r_cmps; 32 | } t_stats; 33 | 34 | struct abb{ 35 | TNo* raiz; 36 | TImprimirABB imprimir; 37 | TCompararABB comparar; 38 | // removerInfoNo 39 | t_stats stats; 40 | }; 41 | 42 | t_abb* criarABB(TImprimirABB imprimir, TCompararABB comparar){ 43 | t_abb* abb = malloc(sizeof(t_abb)); 44 | 45 | abb->raiz = NULL; 46 | abb->imprimir = imprimir; 47 | abb->comparar = comparar; 48 | abb->stats = (t_stats){.b_cmps=0,.i_cmps=0,.r_cmps=0,.i_nro=0,.b_nro=0,.r_nro=0}; 49 | return abb; 50 | } 51 | 52 | 53 | static TNo* __inserirABB(TNo* raiz, void* info, TCompararABB comparar, t_stats* stats){ 54 | //printf("Iniciou inserção \n"); 55 | if (raiz == NULL){ 56 | //printf("Inseriu no \n"); 57 | stats->i_cmps++; 58 | TNo* novo = criar_no(raiz,info); 59 | return novo; 60 | } 61 | if (comparar(raiz->info, info) > 0){ // uso da propriedade ordem 62 | raiz->sae = __inserirABB(raiz->sae, info, comparar, stats); 63 | raiz->sae->ancestral = raiz; 64 | stats->i_cmps+=2; 65 | }else{ 66 | raiz->sad = __inserirABB(raiz->sad, info, comparar, stats); 67 | raiz->sad->ancestral = raiz; 68 | stats->i_cmps+=3; 69 | } 70 | 71 | return raiz; 72 | } 73 | 74 | void estatisticaABB(t_abb *abb){ 75 | t_stats* stats = &(abb->stats); 76 | printf("Estatísticas:\n"); 77 | double i_media = (double)(stats->i_cmps)/(stats->i_nro); 78 | printf("Inserções: %d\n", stats->i_nro); 79 | printf("cmps nas inserções: %d media: %.2lf\n", stats->i_cmps, i_media); 80 | 81 | double b_media = (double)(stats->b_cmps)/(stats->b_nro); 82 | printf("Buscas: %d\n", stats->b_nro); 83 | printf("cmps nas buscas: %d media: %.2lf\n", stats->b_cmps, b_media); 84 | 85 | double r_media = (double)(stats->r_cmps)/(stats->r_nro); 86 | printf("Remoções: %d\n", stats->r_nro); 87 | printf("cmps nas remoções: %d media: %.2lf\n", stats->r_cmps, r_media); 88 | 89 | } 90 | 91 | void inserirABB(t_abb *abb, void* info){ 92 | t_stats* stats = &(abb->stats); 93 | stats->i_nro++; 94 | abb->raiz = __inserirABB(abb->raiz, info, abb->comparar, stats); 95 | //printf("Terminou insercao\n"); 96 | 97 | } 98 | 99 | TNo* __buscarABB(TNo* raiz, void* buscado, TCompararABB comparar, t_stats* stats){ 100 | // base da recursão 101 | if (raiz == NULL){ 102 | return NULL; 103 | } 104 | int status = comparar(raiz->info, buscado); 105 | if (status == 0){ 106 | stats->b_cmps+=1; 107 | return raiz; 108 | }else if(status < 0){ 109 | stats->b_cmps+=2; 110 | return __buscarABB(raiz->sad, buscado, comparar, stats); 111 | }else{ 112 | stats->b_cmps+=3; 113 | return __buscarABB(raiz->sae, buscado, comparar, stats); 114 | } 115 | 116 | } 117 | 118 | void* buscarABB(t_abb *abb, void* buscado){ 119 | t_stats* stats = &(abb->stats); 120 | stats->b_nro++; 121 | 122 | TNo* no = __buscarABB(abb->raiz, buscado, abb->comparar, stats); 123 | return (no != NULL?no->info:NULL); 124 | 125 | } 126 | 127 | static void trocar(TNo* no, TNo* no2){ 128 | void* aux = no->info; 129 | no->info = no2->info; 130 | no2->info = aux; 131 | } 132 | 133 | 134 | TNo * __removerABB(TNo* raiz, void* removivel, TCompararABB comparar, t_stats* stats){ 135 | if (raiz == NULL){ 136 | return NULL; 137 | }else if (comparar(raiz->info, removivel)>0){ // caminha para a SAE 138 | stats->r_cmps++; 139 | raiz->sae = __removerABB(raiz->sae, removivel, comparar, stats); 140 | return raiz; 141 | }else if (comparar(raiz->info, removivel)<0){ // caminha para a SAD 142 | stats->r_cmps+=2; 143 | raiz->sad = __removerABB(raiz->sad, removivel, comparar, stats); 144 | return raiz; 145 | }else{ // achou 146 | stats->r_cmps+=3; 147 | if ( (raiz->sae == NULL) && (raiz->sad == NULL)){ 148 | free(raiz->info); 149 | free(raiz); 150 | return NULL; 151 | 152 | }else if (raiz->sae == NULL){ 153 | raiz->sad->ancestral = raiz->ancestral; 154 | TNo* sad = raiz->sad; 155 | free(raiz->info); 156 | free(raiz); 157 | return sad; 158 | 159 | }else if (raiz->sad == NULL){ 160 | raiz->sae->ancestral = raiz->ancestral; 161 | TNo* sae = raiz->sae; 162 | free(raiz->info); 163 | free(raiz); 164 | return sae; 165 | 166 | }else{ // Dois descendentes 167 | TNo* maior = raiz->sae; 168 | while(maior->sad!=NULL){ 169 | maior = maior->sad; 170 | } 171 | trocar(raiz, maior); 172 | raiz->sae = __removerABB(raiz->sae, removivel, comparar, stats); 173 | return raiz; 174 | 175 | } 176 | 177 | } 178 | 179 | } 180 | 181 | void removerABB(t_abb *abb, void* removivel){ 182 | t_stats* stats = &(abb->stats); 183 | stats->r_nro++; 184 | 185 | abb->raiz = __removerABB(abb->raiz, removivel, abb->comparar, stats); 186 | } 187 | 188 | static void __podarABB(TNo* raiz){ 189 | if (raiz == NULL){ 190 | return; 191 | } 192 | __podarABB(raiz->sae); 193 | __podarABB(raiz->sad); 194 | free(raiz->info); // precisa ajuste 195 | free(raiz); 196 | } 197 | 198 | void podarABB(t_abb* abb, void* info){ 199 | t_stats* stats = &(abb->stats); 200 | TNo* no = __buscarABB(abb->raiz, info, abb->comparar, stats); 201 | if (no != NULL){ // encontrou a info 202 | if (no == abb->raiz) { // poda drástica 203 | abb->raiz = NULL; 204 | } else { 205 | TNo* ancestral = no->ancestral; 206 | if (ancestral->sae == no){ 207 | ancestral->sae = NULL; 208 | } else { 209 | ancestral->sad = NULL; 210 | } 211 | } 212 | __podarABB(no); 213 | } 214 | } 215 | 216 | 217 | 218 | #define MAX(a,b) (a>b?a:b) 219 | 220 | static int __alturaABB(TNo *raiz){ 221 | if (raiz == NULL) 222 | return -1; 223 | return MAX(__alturaABB(raiz->sae), __alturaABB(raiz->sad))+1; 224 | } 225 | 226 | int alturaABB(t_abb *abb){ 227 | return __alturaABB(abb->raiz); 228 | } 229 | 230 | static int __tamanhoABB(TNo* raiz){ 231 | if (raiz == NULL) 232 | return 0; 233 | return (__tamanhoABB(raiz->sae)+__tamanhoABB(raiz->sad))+1; 234 | } 235 | 236 | int tamanhoABB(t_abb *abb){ 237 | return __tamanhoABB(abb->raiz); 238 | 239 | } 240 | 241 | static void __imprimirABB(TNo* raiz, TImprimirABB imprimir){ 242 | if (raiz == NULL) 243 | return; 244 | __imprimirABB(raiz->sae, imprimir); 245 | imprimir(raiz->info); 246 | __imprimirABB(raiz->sad, imprimir); 247 | } 248 | 249 | void imprimirABB(t_abb* abb){ 250 | __imprimirABB(abb->raiz, abb->imprimir); 251 | } 252 | 253 | -------------------------------------------------------------------------------- /Modulo02/src/202301/avl.c: -------------------------------------------------------------------------------- 1 | #include "time.h" 2 | #include "stdio.h" 3 | #include "stdlib.h" 4 | #include "avl.h" 5 | 6 | typedef struct no t_no; 7 | struct no{ 8 | void* info; 9 | t_no* ancestral; 10 | t_no* sae; 11 | t_no* sad; 12 | int fb; 13 | }; 14 | 15 | static t_no* criar_no(void* info, t_no* ancestral){ 16 | t_no* novo = malloc(sizeof(t_no)); 17 | novo->info = info; 18 | novo->sad = NULL; 19 | novo->sae = NULL; 20 | novo->ancestral = ancestral; 21 | novo->fb = 0; 22 | 23 | return novo; 24 | } 25 | 26 | struct avl{ 27 | t_no* raiz; 28 | int tamanho; 29 | t_comparar_avl comparar; 30 | t_destruir_avl destruir; 31 | t_imprimir_avl imprimir; 32 | }; 33 | 34 | 35 | t_avl* criar_avl(t_comparar_avl comparar, t_destruir_avl destruir, t_imprimir_avl imprimir){ 36 | t_avl *avl = malloc(sizeof(t_avl)); 37 | avl->raiz = NULL; 38 | avl->tamanho = 0; 39 | avl->comparar = comparar; 40 | avl->destruir = destruir; 41 | avl->imprimir = imprimir; 42 | 43 | return avl; 44 | } 45 | 46 | #define MAX(a,b) (a>b?a:b) 47 | static int _altura_avl(t_no* raiz){ 48 | if (raiz != NULL){ 49 | return MAX(_altura_avl(raiz->sae), _altura_avl(raiz->sad)) + 1; 50 | }else{ 51 | return -1; 52 | } 53 | } 54 | 55 | int altura_avl(t_avl *avl){ 56 | 57 | return _altura_avl(avl->raiz); 58 | } 59 | 60 | static int _tamanho_avl(t_no* no){ 61 | if (no == NULL) 62 | return 0; 63 | return _tamanho_avl(no->sae) + _tamanho_avl(no->sad) + 1; 64 | } 65 | 66 | int tamanho_avl(t_avl *avl){ 67 | return avl->tamanho; 68 | } 69 | 70 | 71 | 72 | void* _buscar_avl(t_no* raiz, t_comparar_avl comparar, void* chave){ 73 | if(raiz == NULL){ 74 | return NULL; 75 | } 76 | int status = comparar(raiz->info, chave); 77 | if( status == 0){ 78 | return raiz->info; 79 | }else if (status > 0){ 80 | return _buscar_avl(raiz->sae,comparar,chave); 81 | }else{ 82 | return _buscar_avl(raiz->sad,comparar,chave); 83 | } 84 | } 85 | 86 | void* buscar_avl(t_avl *avl, void* chave){ 87 | return _buscar_avl(avl->raiz, avl->comparar, chave); 88 | } 89 | 90 | 91 | static int _calcular_fb(t_no* raiz){ 92 | return (_altura_avl(raiz->sad) - _altura_avl(raiz->sae)); 93 | } 94 | 95 | static t_no* _RSD(t_no* A, t_no* B){ 96 | A->sae = B->sad; 97 | B->sad = A; 98 | 99 | B->ancestral = A->ancestral; 100 | A->ancestral = B; 101 | 102 | if (A->sae) 103 | A->sae->ancestral = A; 104 | 105 | return B; 106 | } 107 | 108 | static t_no* _RSE(t_no* A, t_no* B){ 109 | A->sad = B->sae; 110 | B->sae = A; 111 | 112 | B->ancestral = A->ancestral; 113 | A->ancestral = B; 114 | 115 | if (A->sad) 116 | A->sad->ancestral = A; 117 | 118 | return B; 119 | } 120 | 121 | 122 | static t_no* _inserir_avl(t_no* raiz, t_no* ancestral, void* info, t_comparar_avl comparar){ 123 | if (raiz == NULL){ 124 | return criar_no(info, ancestral); 125 | }else{ 126 | int status = comparar(raiz->info, info); 127 | if (status > 0){ // inserir SAE 128 | raiz->sae = _inserir_avl(raiz->sae, raiz, info, comparar); 129 | int fb = _calcular_fb(raiz); 130 | if (fb == -2){ 131 | if (_calcular_fb(raiz->sae) == 1) { 132 | // rotação dupla para esquerda 133 | t_no* sad = _RSE(raiz->sae, raiz->sae->sad); 134 | raiz = _RSD(raiz,sad); 135 | } else { 136 | // rotação para direita 137 | raiz = _RSD(raiz, raiz->sae); 138 | } 139 | } 140 | } else { // SAD 141 | raiz->sad = _inserir_avl(raiz->sad, raiz, info, comparar); 142 | int fb = _calcular_fb(raiz); 143 | if (fb == 2){ 144 | if (_calcular_fb(raiz->sad) == -1) { 145 | // rotação dupla para direita 146 | t_no* sae = _RSD(raiz->sad, raiz->sad->sae); 147 | raiz = _RSE(raiz,sae); 148 | }else{ 149 | // rotacao para esquerda 150 | raiz = _RSE(raiz, raiz->sad); 151 | } 152 | } 153 | } 154 | return raiz; 155 | } 156 | } 157 | 158 | void inserir_avl(t_avl *avl, void* info){ 159 | avl->raiz = _inserir_avl(avl->raiz,NULL,info,avl->comparar); 160 | avl->tamanho++; 161 | } 162 | 163 | 164 | static void _trocar(t_no *n1, t_no* n2){ 165 | void* info = n1->info; 166 | n1->info = n2->info; 167 | n2->info = info; 168 | } 169 | 170 | static t_no* _remover_avl(t_no* raiz, t_comparar_avl comparar, t_destruir_avl destruir, void *buscado){ 171 | if (raiz == NULL){ 172 | return NULL; 173 | } 174 | int status = comparar(raiz->info, buscado); 175 | if(status > 0){ 176 | raiz->sae = _remover_avl(raiz->sae,comparar, destruir,buscado); 177 | // revisitar FB 178 | 179 | }else if(status < 0){ 180 | raiz->sad = _remover_avl(raiz->sad, comparar, destruir, buscado); 181 | // Revisitar FB 182 | 183 | }else{ 184 | if ((raiz->sae == NULL) && (raiz->sad == NULL)){ // folha 185 | destruir(raiz->info); 186 | free(raiz); 187 | return NULL; 188 | }else if (raiz->sae == NULL){ //descendente dir 189 | raiz->sad->ancestral = raiz->ancestral; 190 | t_no* sad = raiz->sad; 191 | destruir(raiz->info); 192 | free(raiz); 193 | 194 | raiz = sad; 195 | } else if(raiz->sad == NULL){ //descendente esq 196 | raiz->sae->ancestral = raiz->ancestral; 197 | t_no* sae = raiz->sae; 198 | destruir(raiz->info); 199 | free(raiz); 200 | 201 | raiz = sae; 202 | }else{ // tem descendentes sae sad 203 | t_no* maior = raiz->sae; 204 | while(maior->sad != NULL){ 205 | maior = maior->sad; 206 | } 207 | _trocar(raiz, maior); 208 | raiz->sae = _remover_avl(raiz->sae,comparar,destruir,buscado); 209 | // Revisitar o FB 210 | } 211 | } 212 | return raiz; 213 | } 214 | 215 | void remover_avl(t_avl *avl, void* chave){ 216 | avl->raiz = _remover_avl(avl->raiz, avl->comparar, avl->destruir, chave); 217 | } 218 | 219 | t_no* _podar_avl(t_no *raiz, int *tamanho, t_destruir_avl destruir){ 220 | if(raiz==NULL){ 221 | return NULL; 222 | } 223 | _podar_avl(raiz->sae, tamanho, destruir); 224 | _podar_avl(raiz->sad, tamanho, destruir); 225 | destruir(raiz->info); 226 | free(raiz); 227 | *tamanho = *tamanho-1; 228 | return NULL; 229 | } 230 | 231 | void podar_avl(t_avl *avl, void* podavel){ 232 | t_no* raiz = _buscar_avl(avl->raiz,avl->comparar, podavel); 233 | if(raiz->ancestral != NULL){ 234 | if (raiz->ancestral->sad == raiz){ 235 | raiz->ancestral->sad = NULL; 236 | }else{ 237 | raiz->ancestral->sae = NULL; 238 | } 239 | } 240 | // ab->tamanho -= _tamanho_ab(raiz); 241 | _podar_avl(raiz, &(avl->tamanho), avl->destruir); 242 | 243 | } 244 | 245 | void _imprimir_avl(t_no* raiz, t_imprimir_avl imprimir){ 246 | if (raiz == NULL){ 247 | return; 248 | } 249 | _imprimir_avl(raiz->sae, imprimir); 250 | printf("raiz: %p sae: %p ancestral: %p sad: %p \n", raiz, raiz->sae, raiz->ancestral, raiz->sad); 251 | imprimir(raiz->info); 252 | _imprimir_avl(raiz->sad, imprimir); 253 | 254 | } 255 | 256 | void imprimir_avl(t_avl *avl){ 257 | _imprimir_avl(avl->raiz, avl->imprimir); 258 | } 259 | 260 | 261 | -------------------------------------------------------------------------------- /Modulo01/docs/imgs/refatorar.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
Listase.c
Listase.c
Listase.h
Listase.h
Listase.c
Listase.c
  • t_lse* criar_lse(){}
  • void inserir_inicio_lse(t_lse* lse, void* ){}
  • void inserir_final_lse(t_lse* lse, void* carga){}
  • void* remover_inicio_lse(t_lse* lse){}
  • void* remover_final_lse(t_lse* lse){}
  • void* acessar(t_lse* lse){}
t_lse* criar_lse(){}...
  • typedef struct lse t_lse; 
  • typedef void (*t_imprimir_lse)(void*);
  • assinatura das funções
typedef struct lse t_lse; typedef void (*t_imp...Text is not SVG - cannot display -------------------------------------------------------------------------------- /Modulo01/docs/imgs/vetor-intercalar-res.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
7
7
10
10
11
11
17
17
21
21
28
28
V[] = 
V[] = Text is not SVG - cannot display -------------------------------------------------------------------------------- /Modulo01/docs/imgs/representa.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
Carga
Util
Carga...
Carga
Util
Carga...
Carga
Util
Carga...
PRIMEIRO
PRIMEIRO
ÚLTIMO
ÚLTIMO
LSE
LSEText is not SVG - cannot display -------------------------------------------------------------------------------- /Modulo01/docs/imgs/void.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
void*
void*
int*
int*
char*
char*
double*
double*
struct *
struct *
cast
castText is not SVG - cannot display -------------------------------------------------------------------------------- /Modulo03/docs/estrutura.drawio.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 |
AVL
AVL
ABB
ABB
RED
RED
USA_ARV.c
USA_ARV.c
criarAVL()
InserirAVL()
removerAVL()
buscarAVL()
estatisticaAVL()
criarAVL()...
criarRED()
inserirRED()
removerRED()
buscarRED()
estatisticaRED()
criarRED()...
ESPAÇO DE SOLUÇÃO
ESPAÇO DE SOLUÇÃO
ESPAÇO DE
ED
ESPAÇO DE...Text is not SVG - cannot display -------------------------------------------------------------------------------- /Modulo01/docs/projetos.md: -------------------------------------------------------------------------------- 1 | # Atividades 2 | Aqui você vai encontrar os enunciados de todos os trabalhos apresentados neste semestre. 3 | 4 | --- 5 | # Atividade: LSE 6 | 7 | Nesta atividade você precisa implementar uma lista simplesmente encadeada (LSE) que armazena as seguintes informações em seus elementos: 8 | 9 | - Idade (inteiro) 10 | - Peso (real) 11 | - Altura (real) 12 | --- 13 | ## LSE: Operações 14 | 15 | A lista precisa implementar as seguintes operações: 16 | - Criar a lista 17 | - Inserir no final da lista 18 | - Remover no inicio da lista 19 | - Informar o tamanho da lista. 20 | 21 | 22 | ## Operações e restrições 23 | - criar 24 | - __Essa operação deve criar (instanciar) uma LSE vazia.__ 25 | 26 | - Inserir no final 27 | 28 | - __Essa operação deve inserir um novo elemento no final da lista.__ 29 | - Garanta que a operação ocorra somente se a lista tenha sido criada 30 | 31 | - Remover do inicio 32 | - __Essa operação deve remover um elemento no inicio da lista.__ 33 | 34 | - Garanta que a operação ocorra somente se ainda houve elementos na lista 35 | - Tamanho da lista 36 | - __Essa operação deve retornar o número de elementos armazenado na lista__ 37 | - Garanta que a operação ocorra somente se a lista tiver sido criada 38 | 39 | 40 | 41 | # Uso de listas neutralizadas 42 | 43 | Neste trabalho você precisará implementar listas que serão capazes de armazenar um conjunto de dados gerado por diferentes sensores que detectam e registram os eventos em uma área monitorada. 44 | 45 | Os sensores foram distribuídos para medir condições ambientais, e.g., temperatura e das massas de ar. Cada sensor portanto registra medições distintas que tem seus atributos. 46 | 47 | Sua tarefa consiste em ler todas as medidas, armazenadas em um arquivo, e incluí-las na lista de eventos. 48 | 49 | As medidas relacionadas a __temperatura__ têm os seguintes atributos: 50 | 51 | ```json 52 | { seq :inteiro, 53 | dia:inteiro, 54 | mes:inteiro, 55 | ano:inteiro, 56 | hora:inteiro, 57 | minuto:inteiro, 58 | radiacao_solar:inteiro, 59 | temperatura:double, 60 | umidade_relativa: double 61 | } 62 | ``` 63 | 64 | As medidas relacionadas as massas de ar têm os seguintes atributos: 65 | 66 | ```json 67 | { seq:inteiro, 68 | dia:inteiro, 69 | mes:inteiro, 70 | ano:inteiro, 71 | hora:inteiro, 72 | minuto:inteiro, 73 | velocidade_media:double, 74 | velocidade_instantanea:double, 75 | direcao: inteiro 76 | } 77 | ``` 78 | ### O que fazer? 79 | 80 | Após armazenar os eventos nas suas respectivas listas, seu programa deve manipular os eventos armazenados nas listas, conforme os seguintes comandos: 81 | 82 | 1) R dia/mes/ano hora:min - Remover o evento que ocorreu na data especificada. 83 | 2) I x y - Imprimir os elementos no intervalo $[x,y]$ 84 | 3) A x - Acessar o elemento $x$ 85 | 4) B dia/mes/ano hora:min - Buscar um evento que ocorreu na data especificada 86 | 5) P x y - Podar(remover) todos os elementos no intervalo $[x, y]$ 87 | 5) F - Fim dos comandos 88 | 89 | ### Considerações: 90 | 91 | 1) Os valores de $x$ e $y$ podem ser negativos, o que deve levar o acesso a acontecer do último para o primeiro elemento; 92 | 2) A lista de *todos* os eventos será criada sempre inserindo os novos eventos no __final__; 93 | 3) Existem dois momentos de entrada do programa: 94 | * informe do tipo de sensor (1 - temperatura; 2 - massas de ar) e nome do arquivo onde estão as informações; 95 | * Informe dos Comandos que precisam ser executados; 96 | 97 | Veja abaixo os exemplos de como o seu programa será executado: 98 | ```csh 99 | > sensor 1 nome_arquivo_temperatura.txt 100 | ``` 101 | ```csh 102 | > sensor 2 nome_arquivo_massas_de_ar.txt 103 | ``` 104 | 105 | 106 | ### Nomeclaturas 107 | 108 | 1) O arquivo com o seu programa (solução) deve ter o seguinte nome: sensor.c 109 | 110 | ### Como submeter o seu programa 111 | 112 | 1) Deve ser submetido via colab. 113 | 2) Somente o arquivo __sensor.c__ precisa ser enviado. 114 | 115 | ### Comandos extras. 116 | 117 | A seguir você vai ver algumas dicas de como a linguagem C dá suporte a leitura de dados via arquivo e como você pode ler informações passadas via linha de comando. 118 | 119 | ```C 120 | #include "stdio.h" 121 | #include "listase.h" 122 | 123 | int main(int argc, char const *argv[]){ 124 | 125 | const int tipo = atoi(argv[1]); 126 | 127 | const char* nome_arquivo = argv[2]; 128 | 129 | FILE *arq = fopen(nome_arquivo, "r"); 130 | 131 | fscanf(arq,,); 132 | } 133 | ``` 134 | 135 | ### Resumo da tarefa 136 | 1. Instanciar a lista para o tipo de medição informado 137 | 2. Ler e armazenar todas as informações do arquivo na lista 138 | 3. Processar todos os comandos Conforme indicado na seção "O que fazer?" 139 | 140 | ### Exemplos 141 | 142 | ![exemplo01](imgs/exemplo01.png "Exemplo01") 143 | 144 | O Exemplo acima mostra a utilização das funções I, R e F. 145 | 146 | ![exemplo03](imgs/exemplo02.png "Exemplo02") 147 | 148 | O Exemplo acima mostra a utilização das funções I, P e F. 149 | 150 | ![exemplo03](imgs/exemplo03.png "Exemplo03") 151 | 152 | O Exemplo acima mostra a utilização das funções I, A, B, E e F. 153 | 154 | 155 | 156 | 157 | # Uso de TAD - Tipo Abstrato de Dados 158 | 159 | Neste trabalho você precisará implementar as três possibilidades de representar uma fila com prioridade, isto é: 160 | - Container (vetor/lista) não ordenado 161 | - Container (vetor/lista) totalmente ordenado 162 | - Container (heap) parcialmente ordenado 163 | 164 | Ao final da implementação você precisará compara-las sob a perspectiva do número de comparações entre elementos armazenados no container. Especificamente, as operações em que ocorre comparações entre elementos na fila com prioridade são estas: 165 | 166 | - Inserir_FCP(): inserir um novo elemento 167 | - Remover_FCP(): retirar o maior/menor elemento 168 | - Primeiro_FCP(): retornar o maior/menor elemento 169 | 170 | e para cada uma dessas operações, você precisará indicar quantas comparações foram realizadas em cada uma dessas operações, ao final do uso do container. Para isso, implemente instrumentalizações na estrutura de dados usadas que vai contar, sempre que cada operação citada anteriormente for executada, o número de comparações entre elementos. Para o caso do heap 171 | 172 | ```C 173 | struct heap{ 174 | void* *elem; 175 | int ocupacao; 176 | int tamanho; 177 | int e_infinito; 178 | 179 | int nro_cmp_ins; // contador para comparações na inserção 180 | int nro_cmp_pri; // contador para comparações retornar o primeiro 181 | int nro_cmp_rem; // contador para comparações na remoção 182 | 183 | TCompararHeap comparar; 184 | }; 185 | 186 | static void desce_no_heap(t_heap* h, int k){ 187 | int imaior = k; 188 | 189 | if ((2*k+1ocupacao) && (h->comparar(h->elem[imaior],h->elem[2*k+1])<0)){ 190 | imaior = 2*k+1; 191 | } 192 | if ((2*k+2ocupacao) && (h->comparar(h->elem[imaior],h->elem[2*k+2])<0)){ 193 | imaior = 2*k+2; 194 | } 195 | 196 | h->nro_cmp_rem += 2; // contando na remoção dois por operação 197 | if (imaior!=k){ 198 | trocar(h->elem, k, imaior); 199 | desce_no_heap(h,imaior); 200 | } 201 | 202 | } 203 | 204 | static void sobe_no_heap(t_heap* h, int k){ 205 | int kancestral=(k-1)/2; 206 | 207 | h->nro_cmp_ins++; // contando na inserção 208 | if ((kancestral>=0)&&(h->comparar(h->elem[kancestral],h->elem[k])<0)){ 209 | trocar(h->elem, k, kancestral); 210 | sobe_no_heap(h, kancestral); 211 | } 212 | } 213 | 214 | ``` 215 | 216 | Faça definições e instrumentalize o código de forma similar para as demais estruturas usadas nas implementações das outras duas formas de construir fila de prioridade (vetor não ordenado/vetor ordenado). 217 | 218 | Para a implementação feita com o vetor não ordenado, a definição do tipo é como segue: 219 | 220 | ```C 221 | struct vetor_nao_ordenado{ 222 | void* *elem 223 | int ocupacao; 224 | int tamanho; 225 | int e_infinito; 226 | 227 | int nro_cmp_ins; // contador para comparações na inserção 228 | int nro_cmp_pri; // contador para comparações retornar o primeiro 229 | int nro_cmp_rem; // contador para comparações na remoção 230 | 231 | TCompararVNOrd comparar; 232 | } 233 | ``` 234 | 235 | É preciso que você implemente as seguintes interfaces: 236 | 237 | - criar_vnordenado() // instanciar o vetor não ordenado 238 | - inserir_vnordenado() // inserir um novo elemento 239 | - remover_vnordenado() // remover um elemento específico do vetor 240 | - maior_vnordenado() // descobre e retorna qual é o elemento de maior valor do vetor 241 | - menor_vnordenado() // descobre e retorna qual é o elemento de menor valor no vetor 242 | 243 | Para a implementação feita com o __vetor completamente ordenado__, a definição do tipo é similar a apresentada para o vetor não ordenado. 244 | 245 | 246 | ```C 247 | struct vetor_ordenado{ 248 | void* *elem 249 | int ocupacao; 250 | int tamanho; 251 | int e_infinito; 252 | 253 | int nro_cmp_ins; // contador para comparações na inserção 254 | int nro_cmp_pri; // contador para comparações retornar o primeiro 255 | int nro_cmp_rem; // contador para comparações na remoção 256 | 257 | TCompararVOrd comparar; 258 | } 259 | ``` 260 | 261 | Também será necessário criar interfaces para manipular o vetor complemente ordenado, como segue: 262 | 263 | - criar_vordenado() // instanciar o vetor completamente ordenado 264 | - inserir_vordenado() // inserir um novo elemento 265 | - remover_vordenado() // remover um elemento específico do vetor 266 | - maior_vordenado() // descobre e retorna qual é o elemento de maior valor do vetor 267 | - menor_vordenado() // descobre e retorna qual é o elemento de menor valor no vetor 268 | 269 | 270 | Os valores armazenados naquelas variáveis (__nro_cmp_ins, nro_cmp_pri, nro_cmp_rem__) precisam ser acessadas por meio de interfaces chamadas: 271 | 272 | - estatistica_vnordenado() // imprimir nro comparações 273 | - estatistica_vordenado() // imprimir nro comparações 274 | - estatistica_heap() // imprimir nro comparações 275 | 276 | ```C 277 | nro comparações inserção: 278 | nro comparações remoção: 279 | nro comparações primeiro: 280 | ```` 281 | 282 | ## Nomeclaturas 283 | 284 | Nomei os arquivos conforme indicado abaixo: 285 | - vordenado.c e vordenado.h 286 | - vnordenado.c e vnordenado.h 287 | - heap.c e heap.h 288 | 289 | para cada uma dessas implementações, implemente uma solução com os seguintes nomes: 290 | - usaordenado.c 291 | - usavnordenado.c 292 | - usaheap.c 293 | 294 | Para as soluções que você implementar, use as seguintes definições: 295 | 296 | ```C 297 | typedef struct carro{ 298 | char placa[9]; 299 | int hora, min; 300 | }t_carro; 301 | 302 | t_carro* criar_carro(char placa[], int hora, int min){ 303 | t_carro *c = malloc(sizeof(t_carro)); 304 | 305 | strcpy(c->placa,placa); 306 | c->hora = hora; 307 | c->min = min; 308 | 309 | return c; 310 | } 311 | 312 | int compararCarro(void* c1, void* c2){ 313 | t_carro* cc1 = c1; 314 | t_carro* cc2 = c2; 315 | 316 | return strcmp(cc1->placa, cc2->placa); 317 | } 318 | 319 | void destroy_carro(t_carro *c){ 320 | free(c); 321 | } 322 | 323 | void imprimir_carro(t_carro* c){ 324 | 325 | printf("Placa: %s %d:%d\n", c->placa, c->hora, c->min); 326 | 327 | } 328 | ``` 329 | 330 | Implemente nas soluções uma dinâmica de leitura e de uso dos dados, permitindo que as operações de inserção e remoção ocorram na estrutura, e que você verifique as diferenças, em termos de números de comparação entre elementos, que as três implementações solicitadas apresentam. 331 | 332 | -------------------------------------------------------------------------------- /Modulo02/docs/slides.md/Algoritmos e Estruturas de Dados II.md: -------------------------------------------------------------------------------- 1 | --- 2 | marp: true 3 | title: Sobre listas 4 | style: | 5 | section{ 6 | justify-content: flex-start; 7 | } 8 | img[alt~="center"] { 9 | display: block; 10 | margin: 0 auto; 11 | } 12 | --- 13 | # Algoritmos e Estruturas de Dados II 14 | 15 | 16 | 17 | 18 | ---- 19 | # Ementa 20 | 21 | Noções de complexidade de algoritmos. Algoritmos de ordenação 22 | 23 | quadráticos, lineares e de custo ótimo. Algoritmos de busca sequencial 24 | 25 | e binária. Tabela Hash. Processamento de cadeias de caracteres. 26 | 27 | Árvores (Árvores Binárias de Busca e Árvore Balanceadas). 28 | 29 | Representação de grafos e Algoritmos de Caminhamento, Aplicações: 30 | 31 | Ordenação topológica e menor caminho. 32 | 33 | 34 | --- 35 | # Objetivo 36 | 37 | Avaliar a eficiência de rotinas computacionais construídas com estruturas 38 | 39 | de dados básicas e avançadas. Experimentar formas diferentes de 40 | 41 | implementação de algoritmos, em especial o emprego do conceito de 42 | 43 | encapsulamento de dados. Comparar os diversos algoritmos de busca e 44 | 45 | ordenação. Contribuir para o desenvolvimento da criatividade e do 46 | 47 | pensamento lógico do aluno, peças chaves para a construção de rotinas 48 | 49 | computacionais eficientes. 50 | 51 | 52 | --- 53 | # Procedimentos de avaliação 54 | 55 | Trabalho Prático: TP Avaliação Teóricas: AT 56 | 57 | Nota Parcial: NP = $(0.75 * TP + 0.25 * AT)$ 58 | Média Parcial: MP = $(NP1 + NP2 + NP3 + NP4)/4$ 59 | Media Final = $(2*MP + Prova final)/3$ 60 | 61 | 1. Prova de segunda chamada serão realizadas somente com 62 | apresentação de devida justificativa, em data única. 63 | 2. Será considerado aprovado o aluno que obtiver média final maior 64 | igual a 5(cinco). 65 | 66 | 67 | --- 68 | # Procedimento de Ensino e de Aprendizagem 69 | 70 | * Aulas serão realizadas me modalidade híbrida; 71 | * Locais: 72 | * Às segunda-feiras no laboratório 1, prédio do ICOMP 73 | * Às quarta-feiras e às sexta-feiras no auditório 2, prédio do ICOMP-TEC. 74 | 75 | * Conteúdo teórico ficará disponível em vídeo no colabweb 76 | https://colabweb.ufam.edu.br/course/view.php?id=781. 77 | 78 | * As atividades práticas serão desenvolvidas em equipes e submetidas via 79 | colab. 80 | 81 | * O código implementado deve seguir padrões de documentação e construção apresentado na primeira semana de aula do curso. 82 | 83 | 84 | 85 | --- 86 | # Referências 87 | 88 | * CELES, Waldemar; CERQUEIRA, Renato; RANGEL, José Lucas. Introdução a Estrutura de Dados: com Técnicas de Programação em C. Editora Campus, 2008. 89 | 90 | * Zivianni, N. Projeto de Algoritmos com Implementação em Pascal e C. Cengage Learning, 2010. 91 | 92 | * Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest. 93 | 94 | * Algoritmos - Teoria e Prática -, Campus Editora, 2008. 95 | 96 | 97 | --- 98 | # Conteúdo Programático 99 | 100 | * Quatro módulos 101 | * Todos os módulos têm o mesmo peso na nota obtida; 102 | * Complexidade de cada módulo é inerente ao assunto 103 | * 03 módulos 10 aulas e 01 módulo com 15 aulas; 104 | 105 | 106 | 107 | --- 108 | # Conteúdo Programático: TAD 109 | 110 | * Tipo Abstrato de Dados; Encapsulamento (dados privados + interface públicas) 111 | 112 | * Array Dinâmico, revisão de vetor; 113 | 114 | * Fila, Fila de Prioridade, revisão lista + novidade heap 115 | * Pilha, pilha neutra (void \*) 116 | 117 | 118 | --- 119 | # Conteúdo Programático: Dicionários 120 | 121 | * Dicionários Estáticos (Busca Sequencial, Binária) 122 | * Dicionários Semi-Estáticos (Espalhamento Perfeito, e com Endereçamento Aberto) 123 | * Dicionário Dinâmico: Tabelas de Dispersão com Encadeamento. 124 | * Dicionários Dinâmico: Árvores Binárias, Árvores Balanceadas (AVL, Trie) 125 | 126 | --- 127 | # Conteúdo Programático: Ordenação 128 | 129 | * Bolha, Inserção, Seleção O(n2) 130 | * HeapSort, QuickSort, MergeSort O(nlog(n)) Divisão e Conquista, Estruturas de Dados ótimas 131 | * CountingSort, Radix, BucketSort O(n) 132 | 133 | --- 134 | # Conteúdo Programático: Grafo 135 | 136 | * Grafos: Representação em Matriz e Lista de Adjacência; 137 | 138 | * Caminhamento em Profundidade e em largura 139 | 140 | * Aplicação: Menor Caminho 141 | 142 | --- 143 | # Sobre Eficiência 144 | 145 | Contexto 146 | 147 | * O maior salário da empresa? 148 | * Melhor rota entre dois locais de uma cidade? 149 | * Qual é o melhor algoritmo? 150 | * Uma lista de alunos ordenada por nota de prova? 151 | * Quais são as lojas com os melhores preços de computadores? 152 | * É aquele que consigo implementar no menor tempo? 153 | * É aquele que o livro me indicou? 154 | 155 | 156 | --- 157 | # Eficácia versus Eficiência 158 | 159 | s. f. Qualidade daquilo que alcança os resultados planejados; característica do que produz os efeitos esperados, do que é eficaz.Capacidade de desenvolver tarefas ou objetivos de modo competente; produtividade.Etimologia (origem da palavra eficácia). Do latim efficacia.ae. 160 | 161 | s. f. Capacidade de realizar tarefas ou trabalhos de modo eficaz e com o mínimo de desperdício; produtividade.Tendência ou aptidão para ser efetivo; capacidade de realizar ou desenvolver alguma coisa demonstrando eficácia; efetividade. Particularidade demonstrada por pessoas que conseguem produzir um ótimo rendimento, quando realizam alguma coisa; característica do que é eficaz. 162 | 163 | Etimologia (origem da palavra eficiência). Do latim efficientia.ae. 164 | 165 | --- 166 | # Eficiência 167 | 168 | Como medir a eficiência de um algoritmo? 169 | 170 | 1. Quais são os recursos? 171 | * Processador 172 | * Memória 173 | 174 | 2. Que operações demandam esses recursos? 175 | * Ler e escrever na memória 176 | * Comparar valores 177 | * Manter valores armazenados em memória 178 | 179 | É impossível ou muito difícil considerar __Todos__ as operações 180 | 181 | 182 | --- 183 | # O algoritmo que calcula a média de notas de uma turma 184 | 185 | ```C 186 | int main() { 187 | int n; 188 | scanf("%d", &n); 189 | for (int i=0;i 0$, tal que $f(n) < c*g(n)$ para $n >= N_o$ 319 | 320 | --- 321 | # Notação Assintótica: Ozão O(.) 322 | 323 | Descreve o limite superior de um comportamento. 324 | 325 | A função de custo $f(.)$ será limitada superiormente a partir de um certo tamanho de problema. 326 | 327 | * entre 1 e $N_o$; 328 | 329 | * entre $N_o$ e $N$; 330 | 331 | 332 | --- 333 | # Retomando o exemplo: Análise de pior caso 334 | 335 | Um programa simples 336 | 337 | ```C 338 | int conta = 0; 339 | 340 | for (int i=0; i=0) && (vetor[j] > aux) ){ 415 | vetor[j+1]=vetor[j]; 416 | j--; 417 | } 418 | vetor[j+1] = aux; 419 | } 420 | ``` 421 | 422 | --- 423 | # Ordenação Bolha 424 | ```C 425 | for (i=0;ii;j--){ // i limita o conjunto NO 427 | if (vetor[j]>vetor[j-1]){ 428 | trocar(vetor,j,j-1); 429 | } 430 | } 431 | } 432 | ``` 433 | --- 434 | 435 | --------------------------------------------------------------------------------