├── Bag ├── Bag.c ├── Bag.h ├── main.c └── Bag.cbp ├── Set ├── Set.c ├── main.c ├── ArvoreAVL.c ├── ArvoreAVL.h ├── Set.h └── ProjSet.cbp ├── Grafo ├── Grafo.c ├── Grafo.h ├── main.c └── ProjGrafo.cbp ├── TAD Ponto ├── Ponto.c ├── Ponto.h ├── main.c └── ProjPonto.cbp ├── SkipList ├── SkipList.c ├── SkipList.h ├── main.c └── ProjSkipList.cbp ├── Arvore AVL ├── ArvoreAVL.c ├── ArvoreAVL.h ├── ProjArvoreAVL.cbp └── main.c ├── Fila Dinamica ├── FilaDin.c ├── FilaDin.h ├── main.c └── ProjFilaDin.cbp ├── Pilha Dinamica ├── PilhaDin.c ├── PilhaDin.h ├── main.c └── ProjPilhaDin.cbp ├── Tabela Hash ├── TabelaHash.c ├── TabelaHash.h ├── main.c └── ProjTabelaHash.cbp ├── Arvore Binaria ├── ArvoreBinaria.c ├── main.c ├── ArvoreBinaria.h └── ProjArvoreBinaria.cbp ├── Busca e Ordenacao ├── ProjBusca.c ├── ProjOrdenacao.c ├── ProjOrdenacao_Quick.c └── ProjOrdenacao_Heap.c ├── Deque Dinamico ├── DequeDinamico.c ├── DequeDinamico.h ├── ProjDequeDinamico.cbp └── main.c ├── Deque Estatico ├── DequeEstatico.c ├── DequeEstatico.h ├── ProjDeque.cbp └── main.c ├── Fila Estatica ├── FilaEstatica.c ├── FilaEstatica.h ├── main.c └── ProjFilaEst.cbp ├── Arvore Rubro Negra ├── ArvoreLLRB.c ├── ArvoreLLRB.h ├── ProjArvoreLLRB.cbp └── main.c ├── Fila Prioridade ├── FilaPrioridade.c ├── FilaPrioridade.h ├── main.c └── ProjFilaPrioridade.cbp ├── Pilha Estatica ├── PilhaSequencial.c ├── PilhaSequencial.h ├── main.c └── ProjPilhaSequencial.cbp ├── Lista Sequencial ├── ListaSequencial.c ├── main.c ├── ListaSequencial.h └── ProjListaSequencial.cbp ├── Lista Estatica Generica ├── ListaEstGen.c ├── ListaEstGen.h ├── main.c └── ProjListaEstGen.cbp ├── Lista Dinamica Encadeada ├── ListaDinEncad.c ├── ListaDinEncad.h ├── main.c └── ProjListaDinEncad.cbp ├── Fila Prioridade usando Heap ├── FilaPrioridadeHeap.c ├── FilaPrioridadeHeap.h ├── ProjFilaPrioridadeHeap.cbp └── main.c ├── Lista Dinamica Encadeada Circular ├── ListaDinEncadCirc.c ├── ListaDinEncadCirc.h ├── main.c └── ProjListaDinEncadCirc.cbp ├── Lista Dinamica Duplamente Encadeada ├── ListaDinEncadDupla.c ├── ListaDinEncadDupla.h ├── main.c └── ProjListaDinEncadDupla.cbp ├── Lista Dinamica Encadeada com No Descritor ├── ListaDinEncadDesc.c ├── ListaDinEncadDesc.h ├── ProjListaDinEncadDesc.cbp └── main.c ├── TAD Complexos ├── Complexos.h ├── main.c ├── ProjComplexos.cbp └── Complexos.c ├── Compressao RLE └── codificacao_RLE.c ├── README.md └── Ordenacao Externa └── MergeSortExterno.c /Bag/Bag.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Bag/Bag.c -------------------------------------------------------------------------------- /Set/Set.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Set/Set.c -------------------------------------------------------------------------------- /Set/main.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Set/main.c -------------------------------------------------------------------------------- /Grafo/Grafo.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Grafo/Grafo.c -------------------------------------------------------------------------------- /Set/ArvoreAVL.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Set/ArvoreAVL.c -------------------------------------------------------------------------------- /Set/ArvoreAVL.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Set/ArvoreAVL.h -------------------------------------------------------------------------------- /TAD Ponto/Ponto.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/TAD Ponto/Ponto.c -------------------------------------------------------------------------------- /TAD Ponto/Ponto.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/TAD Ponto/Ponto.h -------------------------------------------------------------------------------- /SkipList/SkipList.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/SkipList/SkipList.c -------------------------------------------------------------------------------- /Arvore AVL/ArvoreAVL.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Arvore AVL/ArvoreAVL.c -------------------------------------------------------------------------------- /Fila Dinamica/FilaDin.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Fila Dinamica/FilaDin.c -------------------------------------------------------------------------------- /Pilha Dinamica/PilhaDin.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Pilha Dinamica/PilhaDin.c -------------------------------------------------------------------------------- /Tabela Hash/TabelaHash.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Tabela Hash/TabelaHash.c -------------------------------------------------------------------------------- /Tabela Hash/TabelaHash.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Tabela Hash/TabelaHash.h -------------------------------------------------------------------------------- /Arvore Binaria/ArvoreBinaria.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Arvore Binaria/ArvoreBinaria.c -------------------------------------------------------------------------------- /Busca e Ordenacao/ProjBusca.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Busca e Ordenacao/ProjBusca.c -------------------------------------------------------------------------------- /Deque Dinamico/DequeDinamico.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Deque Dinamico/DequeDinamico.c -------------------------------------------------------------------------------- /Deque Estatico/DequeEstatico.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Deque Estatico/DequeEstatico.c -------------------------------------------------------------------------------- /Fila Estatica/FilaEstatica.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Fila Estatica/FilaEstatica.c -------------------------------------------------------------------------------- /Arvore Rubro Negra/ArvoreLLRB.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Arvore Rubro Negra/ArvoreLLRB.c -------------------------------------------------------------------------------- /Fila Prioridade/FilaPrioridade.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Fila Prioridade/FilaPrioridade.c -------------------------------------------------------------------------------- /Pilha Estatica/PilhaSequencial.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Pilha Estatica/PilhaSequencial.c -------------------------------------------------------------------------------- /Busca e Ordenacao/ProjOrdenacao.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Busca e Ordenacao/ProjOrdenacao.c -------------------------------------------------------------------------------- /Lista Sequencial/ListaSequencial.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Lista Sequencial/ListaSequencial.c -------------------------------------------------------------------------------- /Lista Estatica Generica/ListaEstGen.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Lista Estatica Generica/ListaEstGen.c -------------------------------------------------------------------------------- /Lista Dinamica Encadeada/ListaDinEncad.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Lista Dinamica Encadeada/ListaDinEncad.c -------------------------------------------------------------------------------- /Fila Prioridade usando Heap/FilaPrioridadeHeap.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Fila Prioridade usando Heap/FilaPrioridadeHeap.c -------------------------------------------------------------------------------- /Lista Dinamica Encadeada Circular/ListaDinEncadCirc.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Lista Dinamica Encadeada Circular/ListaDinEncadCirc.c -------------------------------------------------------------------------------- /Lista Dinamica Duplamente Encadeada/ListaDinEncadDupla.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Lista Dinamica Duplamente Encadeada/ListaDinEncadDupla.c -------------------------------------------------------------------------------- /Lista Dinamica Encadeada com No Descritor/ListaDinEncadDesc.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/arbackes/Estrutura-de-Dados-em-C/HEAD/Lista Dinamica Encadeada com No Descritor/ListaDinEncadDesc.c -------------------------------------------------------------------------------- /Arvore Binaria/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ArvoreBinaria.h" 4 | int main(){ 5 | int N = 8, dados[8] = {50,100,30,20,40,45,35,37}; 6 | 7 | ArvBin* raiz = cria_ArvBin(); 8 | 9 | int i; 10 | for(i=0; i < N; i++) 11 | insere_ArvBin(raiz,dados[i]); 12 | 13 | libera_ArvBin(raiz); 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /Bag/Bag.h: -------------------------------------------------------------------------------- 1 | //Arquivo Bag.h 2 | 3 | typedef struct descritor Bag; 4 | 5 | Bag* criaBag(); 6 | void liberaBag(Bag* b); 7 | int insereBag(Bag* b, int num); 8 | int removeBag(Bag* b, int num); 9 | int tamanhoBag(Bag* b); 10 | void imprimeBag(Bag* b); 11 | int consultaBag(Bag* b, int num); 12 | 13 | void beginBag(Bag *b); 14 | int endBag(Bag *b); 15 | void nextBag(Bag *b); 16 | void getItemBag(Bag *b, int *num); 17 | -------------------------------------------------------------------------------- /TAD Ponto/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Ponto.h" 4 | int main(){ 5 | float d; 6 | Ponto *p,*q; 7 | //Ponto r; //ERRO 8 | p = pto_cria(10,21); 9 | q = pto_cria(7,25); 10 | //q->x = 2; //ERRO 11 | d = pto_distancia(p,q); 12 | printf("Distancia entre pontos: %f\n",d); 13 | 14 | pto_libera(q); 15 | pto_libera(p); 16 | 17 | system("pause"); 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /Lista Estatica Generica/ListaEstGen.h: -------------------------------------------------------------------------------- 1 | //Arquivo ListaEstGen.h 2 | #define MAX 100 3 | 4 | typedef struct lista Lista; 5 | 6 | Lista* criaLista(int TAMANHO_TIPO); 7 | 8 | void liberaLista(Lista* li); 9 | 10 | int buscaLista(Lista* li, int chave, void *dados); 11 | 12 | int insereLista(Lista* li, int chave, void *dados); 13 | 14 | int removeLista(Lista* li, int chave); 15 | 16 | void imprimeLista(Lista* li, void (*formato_impressao)(void *)); 17 | 18 | -------------------------------------------------------------------------------- /SkipList/SkipList.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct SkipList SkipList; 3 | 4 | SkipList* criaSkipList(int MAXLVL, float P); 5 | void liberaSkipList(SkipList* sk); 6 | int insereSkipList(SkipList *sk, int key); 7 | int removeSkipList(SkipList *sk, int key); 8 | int buscaSkipList(SkipList *sk, int key); 9 | int tamanhoSkipList(SkipList* sk); 10 | int vaziaSkipList(SkipList* sk); 11 | void imprimeSkipList(SkipList *sk); 12 | 13 | //struct NO* novoNo(int key, int level); 14 | -------------------------------------------------------------------------------- /Set/Set.h: -------------------------------------------------------------------------------- 1 | //Arquivo Set.h 2 | 3 | typedef struct set Set; 4 | 5 | Set* criaSet(); 6 | void liberaSet(Set* s); 7 | int insereSet(Set* s, int num); 8 | int removeSet(Set* s, int num); 9 | int tamanhoSet(Set* s); 10 | void imprimeSet(Set* s); 11 | int consultaSet(Set* s, int num); 12 | 13 | Set* uniaoSet(Set* A, Set* B); 14 | Set* interseccaoSet(Set* A, Set* B); 15 | 16 | void beginSet(Set *s); 17 | int endSet(Set *s); 18 | void nextSet(Set *s); 19 | void getItemSet(Set *s, int *num); 20 | -------------------------------------------------------------------------------- /Arvore AVL/ArvoreAVL.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct NO* ArvAVL; 3 | 4 | ArvAVL* cria_ArvAVL(); 5 | void libera_ArvAVL(ArvAVL *raiz); 6 | int insere_ArvAVL(ArvAVL *raiz, int data); 7 | int remove_ArvAVL(ArvAVL *raiz, int valor); 8 | int estaVazia_ArvAVL(ArvAVL *raiz); 9 | int altura_ArvAVL(ArvAVL *raiz); 10 | int totalNO_ArvAVL(ArvAVL *raiz); 11 | int consulta_ArvAVL(ArvAVL *raiz, int valor); 12 | void preOrdem_ArvAVL(ArvAVL *raiz); 13 | void emOrdem_ArvAVL(ArvAVL *raiz); 14 | void posOrdem_ArvAVL(ArvAVL *raiz); 15 | -------------------------------------------------------------------------------- /Fila Dinamica/FilaDin.h: -------------------------------------------------------------------------------- 1 | //Arquivo FilaDin.h 2 | struct aluno{ 3 | int matricula; 4 | char nome[30]; 5 | float n1,n2,n3; 6 | }; 7 | 8 | typedef struct fila Fila; 9 | 10 | Fila* cria_Fila(); 11 | void libera_Fila(Fila* fi); 12 | int consulta_Fila(Fila* fi, struct aluno *al); 13 | int insere_Fila(Fila* fi, struct aluno al); 14 | int remove_Fila(Fila* fi); 15 | int tamanho_Fila(Fila* fi); 16 | int Fila_vazia(Fila* fi); 17 | int Fila_cheia(Fila* fi); 18 | void imprime_Fila(Fila* fi); 19 | 20 | 21 | -------------------------------------------------------------------------------- /Arvore Binaria/ArvoreBinaria.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct NO* ArvBin; 3 | 4 | ArvBin* cria_ArvBin(); 5 | void libera_ArvBin(ArvBin *raiz); 6 | int insere_ArvBin(ArvBin* raiz, int valor); 7 | int remove_ArvBin(ArvBin *raiz, int valor); 8 | int estaVazia_ArvBin(ArvBin *raiz); 9 | int altura_ArvBin(ArvBin *raiz); 10 | int totalNO_ArvBin(ArvBin *raiz); 11 | int consulta_ArvBin(ArvBin *raiz, int valor); 12 | void preOrdem_ArvBin(ArvBin *raiz); 13 | void emOrdem_ArvBin(ArvBin *raiz); 14 | void posOrdem_ArvBin(ArvBin *raiz); 15 | 16 | -------------------------------------------------------------------------------- /Fila Prioridade/FilaPrioridade.h: -------------------------------------------------------------------------------- 1 | //Arquivo FilaPrioridade.h 2 | #define MAX 100 3 | 4 | typedef struct fila_prioridade FilaPrio; 5 | 6 | FilaPrio* cria_FilaPrio(); 7 | void libera_FilaPrio(FilaPrio* fp); 8 | int consulta_FilaPrio(FilaPrio* fp, char* nome); 9 | int insere_FilaPrio(FilaPrio* fp, char *nome, int prioridade); 10 | int remove_FilaPrio(FilaPrio* fp); 11 | int tamanho_FilaPrio(FilaPrio* fp); 12 | int estaCheia_FilaPrio(FilaPrio* fp); 13 | int estaVazia_FilaPrio(FilaPrio* fp); 14 | void imprime_FilaPrio(FilaPrio* fp); 15 | -------------------------------------------------------------------------------- /Fila Estatica/FilaEstatica.h: -------------------------------------------------------------------------------- 1 | //Arquivo FilaEstatica.h 2 | #define MAX 4 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct fila Fila; 10 | 11 | Fila* cria_Fila(); 12 | void libera_Fila(Fila* fi); 13 | int consulta_Fila(Fila* fi, struct aluno *al); 14 | int insere_Fila(Fila* fi, struct aluno al); 15 | int remove_Fila(Fila* fi); 16 | int tamanho_Fila(Fila* fi); 17 | int Fila_vazia(Fila* fi); 18 | int Fila_cheia(Fila* fi); 19 | void imprime_Fila(Fila* fi); 20 | 21 | -------------------------------------------------------------------------------- /Pilha Dinamica/PilhaDin.h: -------------------------------------------------------------------------------- 1 | //Arquivo PilhaDin.h 2 | 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct elemento* Pilha; 10 | 11 | Pilha* cria_Pilha(); 12 | void libera_Pilha(Pilha* pi); 13 | int consulta_topo_Pilha(Pilha* pi, struct aluno *al); 14 | int insere_Pilha(Pilha* pi, struct aluno al); 15 | int remove_Pilha(Pilha* pi); 16 | int tamanho_Pilha(Pilha* pi); 17 | int Pilha_vazia(Pilha* pi); 18 | int Pilha_cheia(Pilha* pi); 19 | void imprime_Pilha(Pilha* pi); 20 | 21 | -------------------------------------------------------------------------------- /Fila Prioridade usando Heap/FilaPrioridadeHeap.h: -------------------------------------------------------------------------------- 1 | 2 | //Arquivo FilaPrioridadeHeap.h 3 | #define MAX 100 4 | 5 | typedef struct fila_prioridade FilaPrio; 6 | 7 | FilaPrio* cria_FilaPrio(); 8 | void libera_FilaPrio(FilaPrio* fp); 9 | int consulta_FilaPrio(FilaPrio* fp, char* nome); 10 | int insere_FilaPrio(FilaPrio* fp, char *nome, int prioridade); 11 | int remove_FilaPrio(FilaPrio* fp); 12 | int tamanho_FilaPrio(FilaPrio* fp); 13 | int estaCheia_FilaPrio(FilaPrio* fp); 14 | int estaVazia_FilaPrio(FilaPrio* fp); 15 | void imprime_FilaPrio(FilaPrio* fp); 16 | -------------------------------------------------------------------------------- /Pilha Estatica/PilhaSequencial.h: -------------------------------------------------------------------------------- 1 | //Arquivo PilhaSequencial.h 2 | #define MAX 100 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct pilha Pilha; 10 | 11 | Pilha* cria_Pilha(); 12 | void libera_Pilha(Pilha* pi); 13 | int consulta_topo_Pilha(Pilha* pi, struct aluno *al); 14 | int insere_Pilha(Pilha* pi, struct aluno al); 15 | int remove_Pilha(Pilha* pi); 16 | int tamanho_Pilha(Pilha* pi); 17 | int Pilha_vazia(Pilha* pi); 18 | int Pilha_cheia(Pilha* pi); 19 | void imprime_Pilha(Pilha* pi); 20 | -------------------------------------------------------------------------------- /Arvore Rubro Negra/ArvoreLLRB.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct NO* ArvLLRB; 3 | // ABB RUBRO NEGRO 2-3 4 | ArvLLRB* cria_ArvLLRB(); 5 | void libera_ArvLLRB(ArvLLRB* raiz); 6 | int insere_ArvLLRB(ArvLLRB* raiz,int valor); 7 | int remove_ArvLLRB(ArvLLRB *raiz, int valor); 8 | int estaVazia_ArvLLRB(ArvLLRB *raiz); 9 | int totalNO_ArvLLRB(ArvLLRB *raiz); 10 | int altura_ArvLLRB(ArvLLRB *raiz); 11 | int consulta_ArvLLRB(ArvLLRB *raiz, int valor); 12 | void preOrdem_ArvLLRB(ArvLLRB *raiz, int H); 13 | void emOrdem_ArvLLRB(ArvLLRB *raiz, int H); 14 | void posOrdem_ArvLLRB(ArvLLRB *raiz, int H); 15 | -------------------------------------------------------------------------------- /TAD Complexos/Complexos.h: -------------------------------------------------------------------------------- 1 | typedef struct complexo cplx; 2 | 3 | cplx* cria_cplx(float r, float i); 4 | void destroi_cplx(cplx* c); 5 | int real(cplx* c, float *r); 6 | int imag(cplx* c, float *i); 7 | int igual_cplx(cplx*c1,cplx*c2); 8 | int oposto_cplx(cplx*c,cplx*res); 9 | int soma_cplx(cplx*c1,cplx*c2,cplx*res); 10 | int subtracao_cplx(cplx*c1,cplx*c2,cplx*res); 11 | int produto_cplx(cplx*c1,cplx*c2,cplx*res); 12 | int modulo_cplx(cplx*c,float *res); 13 | int divisao_cplx(cplx*c1,cplx*c2,cplx*res); 14 | int inverso_cplx(cplx*c1,cplx*res); 15 | int conj_cplx(cplx*c1,cplx*res); 16 | -------------------------------------------------------------------------------- /Grafo/Grafo.h: -------------------------------------------------------------------------------- 1 | //Arquivo Grafo.h 2 | 3 | typedef struct grafo Grafo; 4 | 5 | Grafo* cria_Grafo(int nro_vertices, int grau_max, int eh_ponderado); 6 | void libera_Grafo(Grafo* gr); 7 | int insereAresta(Grafo* gr, int orig, int dest, int eh_digrafo, float peso); 8 | int removeAresta(Grafo* gr, int orig, int dest, int eh_digrafo); 9 | 10 | //void buscaProfundidade(Grafo *gr, int ini, int *visitado, int cont); 11 | void buscaProfundidade_Grafo(Grafo *gr, int ini, int *visitado); 12 | void buscaLargura_Grafo(Grafo *gr, int ini, int *visitado); 13 | void menorCaminho_Grafo(Grafo *gr, int ini, int *antecessor, float *distancia); 14 | 15 | void imprime_Grafo(Grafo *gr); 16 | -------------------------------------------------------------------------------- /Deque Dinamico/DequeDinamico.h: -------------------------------------------------------------------------------- 1 | //Arquivo DequeDinamico.h 2 | struct aluno{ 3 | int matricula; 4 | char nome[30]; 5 | float n1,n2,n3; 6 | }; 7 | 8 | typedef struct Deque Deque; 9 | 10 | Deque* cria_Deque(); 11 | void libera_Deque(Deque* dq); 12 | int consultaInicio_Deque(Deque* dq, struct aluno *al); 13 | int consultaFinal_Deque(Deque* dq, struct aluno *al); 14 | int insereFinal_Deque(Deque* dq, struct aluno al); 15 | int insereInicio_Deque(Deque* dq, struct aluno al); 16 | int removeInicio_Deque(Deque* dq); 17 | int removeFinal_Deque(Deque* dq); 18 | int tamanho_Deque(Deque* dq); 19 | int Deque_vazio(Deque* dq); 20 | int Deque_cheio(Deque* dq); 21 | void imprime_Deque(Deque* dq); 22 | 23 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada com No Descritor/ListaDinEncadDesc.h: -------------------------------------------------------------------------------- 1 | struct aluno{ 2 | int matricula; 3 | char nome[30]; 4 | float n1,n2,n3; 5 | }; 6 | typedef struct descritor Lista; 7 | 8 | Lista* cria_lista(); 9 | void libera_lista(Lista* li); 10 | int insere_lista_final(Lista* li, struct aluno al); 11 | int insere_lista_inicio(Lista* li, struct aluno al); 12 | int remove_lista_inicio(Lista* li); 13 | int remove_lista_final(Lista* li); 14 | int tamanho_lista(Lista* li); 15 | int lista_vazia(Lista* li); 16 | int lista_cheia(Lista* li); 17 | int consulta_lista_mat(Lista* li, int mat, struct aluno *al); 18 | int consulta_lista_pos(Lista* li, int pos, struct aluno *al); 19 | void imprime_lista(Lista* li); 20 | -------------------------------------------------------------------------------- /Deque Estatico/DequeEstatico.h: -------------------------------------------------------------------------------- 1 | //Arquivo DequeEstatico.h 2 | #define MAX 10 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct Deque Deque; 10 | 11 | Deque* cria_Deque(); 12 | void libera_Deque(Deque* dq); 13 | int consultaInicio_Deque(Deque* dq, struct aluno *al); 14 | int consultaFinal_Deque(Deque* dq, struct aluno *al); 15 | int insereFinal_Deque(Deque* dq, struct aluno al); 16 | int insereInicio_Deque(Deque* dq, struct aluno al); 17 | int removeInicio_Deque(Deque* dq); 18 | int removeFinal_Deque(Deque* dq); 19 | int tamanho_Deque(Deque* dq); 20 | int Deque_vazia(Deque* dq); 21 | int Deque_cheia(Deque* dq); 22 | void imprime_Deque(Deque* dq); 23 | -------------------------------------------------------------------------------- /Lista Sequencial/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ListaSequencial.h" 4 | int main(){ 5 | struct aluno a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Lista* li = cria_lista(); 10 | int i; 11 | for(i=0; i < 4; i++) 12 | insere_lista_ordenada(li,a[i]); 13 | 14 | imprime_lista(li); 15 | printf("\n\n\n\n"); 16 | 17 | for(i=0; i < 5; i++){ 18 | if (!remove_lista_otimizado(li,i)) 19 | printf("Erro\n"); 20 | 21 | imprime_lista(li); 22 | printf("\n\n\n\n"); 23 | } 24 | 25 | libera_lista(li); 26 | system("pause"); 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /Lista Dinamica Duplamente Encadeada/ListaDinEncadDupla.h: -------------------------------------------------------------------------------- 1 | //Arquivo ListaDinEncadDupla.h 2 | 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct elemento* Lista; 10 | 11 | Lista* cria_lista(); 12 | void libera_lista(Lista* li); 13 | int consulta_lista_pos(Lista* li, int pos, struct aluno *al); 14 | int consulta_lista_mat(Lista* li, int mat, struct aluno *al); 15 | int insere_lista_final(Lista* li, struct aluno al); 16 | int insere_lista_inicio(Lista* li, struct aluno al); 17 | int insere_lista_ordenada(Lista* li, struct aluno al); 18 | int remove_lista(Lista* li, int mat); 19 | int remove_lista_inicio(Lista* li); 20 | int remove_lista_final(Lista* li); 21 | int tamanho_lista(Lista* li); 22 | int lista_vazia(Lista* li); 23 | void imprime_lista(Lista* li); 24 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada Circular/ListaDinEncadCirc.h: -------------------------------------------------------------------------------- 1 | //Arquivo ListaDinEncadCirc.h 2 | 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct elemento* Lista; 10 | 11 | Lista* cria_lista(); 12 | void libera_lista(Lista* li); 13 | int consulta_lista_pos(Lista* li, int pos, struct aluno *al); 14 | int consulta_lista_mat(Lista* li, int mat, struct aluno *al); 15 | int insere_lista_final(Lista* li, struct aluno al); 16 | int insere_lista_inicio(Lista* li, struct aluno al); 17 | int insere_lista_ordenada(Lista* li, struct aluno al); 18 | int remove_lista(Lista* li, int mat); 19 | int remove_lista_inicio(Lista* li); 20 | int remove_lista_final(Lista* li); 21 | int tamanho_lista(Lista* li); 22 | int lista_vazia(Lista* li); 23 | void imprime_lista(Lista* li); 24 | 25 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada/ListaDinEncad.h: -------------------------------------------------------------------------------- 1 | //Arquivo ListaDinEncad.h 2 | 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct elemento* Lista; 10 | 11 | Lista* cria_lista(); 12 | void libera_lista(Lista* li); 13 | int insere_lista_final(Lista* li, struct aluno al); 14 | int insere_lista_inicio(Lista* li, struct aluno al); 15 | int insere_lista_ordenada(Lista* li, struct aluno al); 16 | int remove_lista(Lista* li, int mat); 17 | int remove_lista_inicio(Lista* li); 18 | int remove_lista_final(Lista* li); 19 | int tamanho_lista(Lista* li); 20 | int lista_vazia(Lista* li); 21 | int lista_cheia(Lista* li); 22 | void imprime_lista(Lista* li); 23 | int consulta_lista_mat(Lista* li, int mat, struct aluno *al); 24 | int consulta_lista_pos(Lista* li, int pos, struct aluno *al); 25 | -------------------------------------------------------------------------------- /Lista Sequencial/ListaSequencial.h: -------------------------------------------------------------------------------- 1 | //Arquivo ListaSequencial.h 2 | #define MAX 100 3 | struct aluno{ 4 | int matricula; 5 | char nome[30]; 6 | float n1,n2,n3; 7 | }; 8 | 9 | typedef struct lista Lista; 10 | Lista* cria_lista(); 11 | void libera_lista(Lista* li); 12 | int consulta_lista_pos(Lista* li, int pos, struct aluno *al); 13 | int consulta_lista_mat(Lista* li, int mat, struct aluno *al); 14 | int insere_lista_final(Lista* li, struct aluno al); 15 | int insere_lista_inicio(Lista* li, struct aluno al); 16 | int insere_lista_ordenada(Lista* li, struct aluno al); 17 | int remove_lista(Lista* li, int mat); 18 | int remove_lista_inicio(Lista* li); 19 | int remove_lista_final(Lista* li); 20 | int tamanho_lista(Lista* li); 21 | int lista_cheia(Lista* li); 22 | int lista_vazia(Lista* li); 23 | void imprime_lista(Lista* li); 24 | 25 | int remove_lista_otimizado(Lista* li, int mat); 26 | -------------------------------------------------------------------------------- /TAD Complexos/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Complexos.h" 4 | void imprime(cplx *z){ 5 | float x,y; 6 | real(z,&x); 7 | imag(z,&y); 8 | printf("Complexo = %.2f + %.2f i\n",x,y); 9 | } 10 | int main(){ 11 | cplx *z1,*z2=NULL; 12 | 13 | z1 = cria_cplx(12,3); 14 | z2 = cria_cplx(1,31); 15 | imprime(z1); 16 | imprime(z2); 17 | 18 | if(igual_cplx(z1,z2)==1) 19 | printf("Numeros iguais\n"); 20 | else 21 | printf("Numeros diferentes\n"); 22 | 23 | oposto_cplx(z1,z2); 24 | printf("Oposto\n"); 25 | imprime(z2); 26 | 27 | soma_cplx(z1,z1,z2); 28 | printf("Soma\n"); 29 | imprime(z2); 30 | 31 | subtracao_cplx(z2,z1,z2); 32 | printf("Subtracao\n"); 33 | imprime(z2); 34 | 35 | produto_cplx(z1,z1,z2); 36 | printf("Produto\n"); 37 | imprime(z2); 38 | 39 | destroi_cplx(z1); 40 | destroi_cplx(z2); 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /Tabela Hash/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "TabelaHash.h" 4 | 5 | int main(){ 6 | int tamanho = 1024; 7 | Hash *tabela = criaHash(tamanho); 8 | 9 | 10 | struct aluno al, a[4] = {{12352,"Andre",9.5,7.8,8.5},//64 11 | {7894,"Ricardo",7.5,8.7,6.8},//726 12 | {3451,"Bianca",9.7,6.7,8.4},//379 13 | {5293,"Ana",5.7,6.1,7.4}};//173 14 | 15 | int i; 16 | for(i=0; i < 4; i++){ 17 | insereHash_SemColisao(tabela,a[i]); 18 | } 19 | 20 | printf("------------\n\n"); 21 | 22 | buscaHash_SemColisao(tabela, 12352, &al); 23 | printf("%s, %d\n",al.nome,al.matricula); 24 | 25 | buscaHash_SemColisao(tabela, 3451, &al); 26 | printf("%s, %d\n",al.nome,al.matricula); 27 | 28 | buscaHash_SemColisao(tabela, 5293, &al); 29 | printf("%s, %d\n",al.nome,al.matricula); 30 | 31 | liberaHash(tabela); 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /Pilha Dinamica/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "PilhaDin.h" 4 | int main(){ 5 | struct aluno a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Pilha* pi = cria_Pilha(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 11 | int i; 12 | for(i=0; i < 4; i++) 13 | insere_Pilha(pi,a[i]); 14 | 15 | imprime_Pilha(pi); 16 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 17 | 18 | for(i=0; i < 4; i++) 19 | remove_Pilha(pi); 20 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 21 | imprime_Pilha(pi); 22 | 23 | for(i=0; i < 4; i++) 24 | insere_Pilha(pi,a[i]); 25 | 26 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 27 | imprime_Pilha(pi); 28 | 29 | libera_Pilha(pi); 30 | system("pause"); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /Pilha Estatica/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "PilhaSequencial.h" 4 | int main(){ 5 | struct aluno a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Pilha* pi = cria_Pilha(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 11 | int i; 12 | for(i=0; i < 4; i++) 13 | insere_Pilha(pi,a[i]); 14 | 15 | imprime_Pilha(pi); 16 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 17 | 18 | for(i=0; i < 4; i++) 19 | remove_Pilha(pi); 20 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 21 | imprime_Pilha(pi); 22 | 23 | for(i=0; i < 4; i++) 24 | insere_Pilha(pi,a[i]); 25 | 26 | printf("Tamanho: %d\n\n\n\n",tamanho_Pilha(pi)); 27 | imprime_Pilha(pi); 28 | 29 | libera_Pilha(pi); 30 | system("pause"); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ListaDinEncad.h" 4 | int main(){ 5 | struct aluno al, a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Lista* li = cria_lista(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_lista(li)); 11 | 12 | int i; 13 | for(i=0; i < 4; i++) 14 | insere_lista_ordenada(li,a[i]); 15 | 16 | imprime_lista(li); 17 | printf("\n\n\n\n Tamanho: %d\n",tamanho_lista(li)); 18 | 19 | for(i=0; i < 4; i++){ 20 | remove_lista_final(li); 21 | imprime_lista(li); 22 | printf("\n Tamanho: %d\n\n\n",tamanho_lista(li)); 23 | } 24 | 25 | for(i=0; i < 4; i++) 26 | insere_lista_ordenada(li,a[i]); 27 | imprime_lista(li); 28 | 29 | libera_lista(li); 30 | system("pause"); 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /Lista Dinamica Duplamente Encadeada/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ListaDinEncadDupla.h" 4 | int main(){ 5 | struct aluno al, a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Lista* li = cria_lista(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_lista(li)); 11 | 12 | int i; 13 | for(i=0; i < 4; i++) 14 | insere_lista_ordenada(li,a[i]); 15 | 16 | imprime_lista(li); 17 | printf("\n\n\n\n Tamanho: %d\n",tamanho_lista(li)); 18 | 19 | 20 | //remove_lista(li,3); 21 | for(i=0; i < 4; i++){ 22 | remove_lista_final(li); 23 | imprime_lista(li); 24 | printf("\nTamanho: %d\n\n\n\n",tamanho_lista(li)); 25 | } 26 | 27 | for(i=0; i < 4; i++) 28 | insere_lista_ordenada(li,a[i]); 29 | 30 | imprime_lista(li); 31 | libera_lista(li); 32 | system("pause"); 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /Bag/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Bag.h" 4 | 5 | int main(){ 6 | int numeros[10] = {10,20,30,20,10,30,5,20,90,30}; 7 | 8 | Bag* b = criaBag(); 9 | printf("Tamanho: %d\n\n\n\n",tamanhoBag(b)); 10 | 11 | int i; 12 | for(i=0; i < 10; i++) 13 | insereBag(b,numeros[i]); 14 | 15 | imprimeBag(b); 16 | printf("\n\n\n\n Tamanho: %d\n",tamanhoBag(b)); 17 | 18 | int x = 20; 19 | printf("%d ocorre: %d\n\n\n",x,consultaBag(b,x)); 20 | 21 | for(beginBag(b); !endBag(b); nextBag(b)){ 22 | getItemBag(b, &x); 23 | printf("Iterator %d: %d\n",i,x); 24 | } 25 | 26 | x = 10; 27 | printf("%d remove: %d\n\n\n",x,removeBag(b,x)); 28 | imprimeBag(b); 29 | printf("\n\n\n\n Tamanho: %d\n",tamanhoBag(b)); 30 | printf("\n"); 31 | 32 | for(beginBag(b); !endBag(b); nextBag(b)){ 33 | getItemBag(b, &x); 34 | printf("Iterator %d: %d\n",i,x); 35 | } 36 | 37 | liberaBag(b); 38 | system("pause"); 39 | 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /SkipList/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "SkipList.h" 5 | 6 | int main(){ 7 | // Seed random number generator 8 | srand((unsigned)time(0)); 9 | // create SkipList object with MAXLVL and P 10 | SkipList* sk = criaSkipList(10, 0.5); 11 | 12 | printf("Vazia = %d\n",vaziaSkipList(sk)); 13 | 14 | int i, vet[10] = {3,6,7,9,12,19,17,26,21,25}; 15 | for(i=0; i<10; i++){ 16 | insereSkipList(sk, vet[i]); 17 | printf("Tamanho = %d\n",tamanhoSkipList(sk)); 18 | } 19 | imprimeSkipList(sk); 20 | printf("Vazia = %d\n",vaziaSkipList(sk)); 21 | printf("Tamanho = %d\n",tamanhoSkipList(sk)); 22 | 23 | if(buscaSkipList(sk, 19)) 24 | printf("Achou o 19\n"); 25 | else 26 | printf("NAO achou o 19\n"); 27 | 28 | removeSkipList(sk, 19); 29 | imprimeSkipList(sk); 30 | 31 | printf("Vazia = %d\n",vaziaSkipList(sk)); 32 | printf("Tamanho = %d\n",tamanhoSkipList(sk)); 33 | 34 | liberaSkipList(sk); 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada Circular/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ListaDinEncadCirc.h" 4 | int main(){ 5 | struct aluno a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Lista* li = cria_lista(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_lista(li)); 11 | 12 | int i; 13 | for(i=0; i < 4; i++) 14 | insere_lista_inicio(li,a[i]); 15 | 16 | imprime_lista(li); 17 | printf("\n\n\n\n Tamanho: %d\n",tamanho_lista(li)); 18 | 19 | for(i=-1; i < 5; i++){ 20 | //remove_lista(li,i+1); 21 | if(!remove_lista(li,i+1)) 22 | printf("Erro!!!!!!!!!\n"); 23 | imprime_lista(li); 24 | printf("\n\n======================\n\n"); 25 | } 26 | for(i=0; i < 4; i++) 27 | insere_lista_ordenada(li,a[i]); 28 | 29 | imprime_lista(li); 30 | libera_lista(li); 31 | system("pause"); 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /Grafo/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Grafo.h" 4 | int main(){ 5 | int eh_digrafo = 1; 6 | Grafo* gr = cria_Grafo(5, 5, 0); 7 | 8 | insereAresta(gr, 0, 1, eh_digrafo, 0); 9 | insereAresta(gr, 1, 3, eh_digrafo, 0); 10 | insereAresta(gr, 1, 2, eh_digrafo, 0); 11 | insereAresta(gr, 2, 4, eh_digrafo, 0); 12 | insereAresta(gr, 3, 0, eh_digrafo, 0); 13 | insereAresta(gr, 3, 4, eh_digrafo, 0); 14 | insereAresta(gr, 4, 1, eh_digrafo, 0); 15 | 16 | imprime_Grafo(gr); 17 | printf("\nBusca \n"); 18 | int vis[5]; 19 | // http://www.thelearningpoint.net/computer-science/algorithms-graph-traversal---breadth-first-search-with-c-program-source-code 20 | //buscaProfundidade_Grafo(gr, 0, vis); 21 | //buscaLargura_Grafo(gr, 0, vis); 22 | 23 | int i,ant[5]; 24 | float dist[5]; 25 | menorCaminho_Grafo(gr, 0, ant, dist); 26 | for(i=0; i<5; i++) 27 | printf("%d: %d -> %f\n",i,ant[i],dist[i]); 28 | 29 | libera_Grafo(gr); 30 | 31 | system("pause"); 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /Fila Prioridade/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "FilaPrioridade.h" 4 | 5 | struct paciente{ 6 | char nome[30]; 7 | int prio; 8 | }; 9 | 10 | int main(){ 11 | struct paciente itens[6] = {{"Andre",1}, 12 | {"Bianca",2}, 13 | {"Carlos",5}, 14 | {"Nilza",10}, 15 | {"Inacio",9}, 16 | {"Edu",2}}; 17 | 18 | FilaPrio* fp; 19 | fp = cria_FilaPrio(); 20 | 21 | int i; 22 | for (i=0; i< 6; i++){ 23 | printf("%d) %d %s\n",i,itens[i].prio, itens[i].nome); 24 | insere_FilaPrio(fp, itens[i].nome,itens[i].prio); 25 | } 26 | 27 | printf("=================================\n"); 28 | 29 | imprime_FilaPrio(fp); 30 | 31 | printf("=================================\n"); 32 | for (i=0; i< 6; i++){ 33 | remove_FilaPrio(fp); 34 | imprime_FilaPrio(fp); 35 | printf("=================================\n"); 36 | } 37 | 38 | libera_FilaPrio(fp); 39 | 40 | system("pause"); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /Fila Estatica/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "FilaEstatica.h" 4 | int main(){ 5 | struct aluno al,a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Fila* fi = cria_Fila(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 11 | int i; 12 | for(i=0; i < 4; i++){ 13 | insere_Fila(fi,a[i]); 14 | consulta_Fila(fi,&al); 15 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 16 | } 17 | 18 | imprime_Fila(fi); 19 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 20 | 21 | for(i=0; i < 4; i++){ 22 | remove_Fila(fi); 23 | consulta_Fila(fi,&al); 24 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 25 | } 26 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 27 | imprime_Fila(fi); 28 | 29 | for(i=0; i < 4; i++) 30 | insere_Fila(fi,a[i]); 31 | 32 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 33 | imprime_Fila(fi); 34 | 35 | libera_Fila(fi); 36 | system("pause"); 37 | return 0; 38 | } 39 | 40 | 41 | -------------------------------------------------------------------------------- /Fila Dinamica/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "FilaDin.h" 4 | int main(){ 5 | struct aluno al,a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Fila* fi = cria_Fila(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 11 | int i; 12 | for(i=0; i < 4; i++){ 13 | insere_Fila(fi,a[i]); 14 | if(Fila_vazia(fi)) 15 | printf("Erro!!!!!!\n"); 16 | 17 | consulta_Fila(fi,&al); 18 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 19 | } 20 | 21 | imprime_Fila(fi); 22 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 23 | 24 | for(i=0; i < 4; i++){ 25 | remove_Fila(fi); 26 | consulta_Fila(fi,&al); 27 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 28 | } 29 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 30 | imprime_Fila(fi); 31 | 32 | for(i=0; i < 4; i++) 33 | insere_Fila(fi,a[i]); 34 | 35 | printf("Tamanho: %d\n\n\n\n",tamanho_Fila(fi)); 36 | imprime_Fila(fi); 37 | 38 | libera_Fila(fi); 39 | system("pause"); 40 | return 0; 41 | } 42 | 43 | 44 | -------------------------------------------------------------------------------- /Bag/Bag.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 47 | 48 | -------------------------------------------------------------------------------- /Grafo/ProjGrafo.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /TAD Ponto/ProjPonto.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Fila Dinamica/ProjFilaDin.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Deque Estatico/ProjDeque.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Pilha Dinamica/ProjPilhaDin.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Arvore AVL/ProjArvoreAVL.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Fila Estatica/ProjFilaEst.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /TAD Complexos/ProjComplexos.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Tabela Hash/ProjTabelaHash.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Arvore Rubro Negra/ProjArvoreLLRB.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Arvore Binaria/ProjArvoreBinaria.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Deque Dinamico/ProjDequeDinamico.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Fila Prioridade/ProjFilaPrioridade.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada/ProjListaDinEncad.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Sequencial/ProjListaSequencial.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Pilha Estatica/ProjPilhaSequencial.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Estatica Generica/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ListaEstGen.h" 4 | 5 | struct aluno{ 6 | int matricula; 7 | char nome[30]; 8 | float n1,n2,n3; 9 | }; 10 | 11 | void imprime_aluno(void *info){ 12 | struct aluno *al = info; 13 | printf("Matricula: %d\n",al->matricula); 14 | printf("Nome: %s\n",al->nome); 15 | printf("Notas: %f %f %f\n",al->n1,al->n2,al->n3); 16 | printf("-------------------------------\n"); 17 | } 18 | 19 | int main(){ 20 | struct aluno a[4] = {{2,"Andre",9.5,7.8,8.5}, 21 | {4,"Ricardo",7.5,8.7,6.8}, 22 | {1,"Zuleide",9.7,6.7,8.4}, 23 | {3,"Ana",5.7,6.1,7.4}}; 24 | 25 | Lista* li = criaLista(sizeof(struct aluno)); 26 | 27 | int i; 28 | for(i=0; i < 4; i++) 29 | insereLista(li,a[i].matricula,&a[i]); 30 | 31 | imprimeLista(li,imprime_aluno); 32 | printf("\n\n"); 33 | 34 | struct aluno al; 35 | buscaLista(li,2,&al); 36 | printf("Busca:\n"); 37 | printf("-------------------------------\n"); 38 | imprime_aluno(&al); 39 | printf("\n\n"); 40 | 41 | printf("Remove Chave 2:\n"); 42 | printf("-------------------------------\n"); 43 | removeLista(li,2); 44 | imprimeLista(li,imprime_aluno); 45 | printf("\n\n"); 46 | 47 | liberaLista(li); 48 | 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /SkipList/ProjSkipList.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 48 | 49 | -------------------------------------------------------------------------------- /Fila Prioridade usando Heap/ProjFilaPrioridadeHeap.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada Circular/ProjListaDinEncadCirc.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Dinamica Duplamente Encadeada/ProjListaDinEncadDupla.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada com No Descritor/ProjListaDinEncadDesc.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 46 | 47 | -------------------------------------------------------------------------------- /Lista Estatica Generica/ProjListaEstGen.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 48 | 49 | -------------------------------------------------------------------------------- /Fila Prioridade usando Heap/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "FilaPrioridadeHeap.h" 4 | 5 | struct paciente{ 6 | char nome[30]; 7 | int prio; 8 | }; 9 | 10 | int main(){ 11 | struct paciente itens[6] = {{"Andre",1}, 12 | {"Bianca",2}, 13 | {"Carlos",5}, 14 | {"Nilza",8}, 15 | {"Inacio",6}, 16 | {"Edu",4}}; 17 | 18 | FilaPrio* fp; 19 | fp = cria_FilaPrio(); 20 | 21 | int i; 22 | for (i=0; i< 6; i++){ 23 | printf("%d) %d %s\n",i,itens[i].prio, itens[i].nome); 24 | insere_FilaPrio(fp, itens[i].nome,itens[i].prio); 25 | } 26 | 27 | printf("=================================\n"); 28 | 29 | imprime_FilaPrio(fp); 30 | 31 | //teste 32 | printf("=================================\n"); 33 | insere_FilaPrio(fp, "Teste",9); 34 | imprime_FilaPrio(fp); 35 | 36 | printf("=================================\n"); 37 | remove_FilaPrio(fp); 38 | imprime_FilaPrio(fp); 39 | 40 | printf("=================================\n"); 41 | for (i=0; i< 6; i++){ 42 | char nome[30]; 43 | consulta_FilaPrio(fp, nome); 44 | printf("%d) %s\n",i,nome); 45 | remove_FilaPrio(fp); 46 | } 47 | 48 | libera_FilaPrio(fp); 49 | 50 | system("pause"); 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /Set/ProjSet.cbp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 51 | 52 | -------------------------------------------------------------------------------- /Lista Dinamica Encadeada com No Descritor/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ListaDinEncadDesc.h" 4 | int main(){ 5 | struct aluno a1,a[4] = {{2,"Andre",9.5,7.8,8.5}, 6 | {4,"Ricardo",7.5,8.7,6.8}, 7 | {1,"Bianca",9.7,6.7,8.4}, 8 | {3,"Ana",5.7,6.1,7.4}}; 9 | Lista* li = cria_lista(); 10 | printf("Tamanho: %d\n\n\n\n",tamanho_lista(li)); 11 | 12 | int i; 13 | for(i=0; i < 4; i++) 14 | insere_lista_final(li,a[i]); 15 | 16 | imprime_lista(li); 17 | printf("\n\n\n\n Tamanho: %d\n",tamanho_lista(li)); 18 | 19 | 20 | for(i=0; i < 4; i++){ 21 | if (consulta_lista_pos(li, i+1, &a1)) 22 | printf("ok: %s\n",a1.nome); 23 | else 24 | printf("erro: %s\n",a1.nome); 25 | 26 | } 27 | 28 | // imprime_lista(li); 29 | // printf("\n\n\n\n Tamanho: %d\n",tamanho_lista(li)); 30 | // 31 | for(i=1; i <= 6; i++){ 32 | //remove_lista(li,i+1); 33 | if(!remove_lista_final(li)) 34 | printf("Erro!!!!!!!!!\n"); 35 | imprime_lista(li); 36 | printf("\n\n======================\n\n"); 37 | } 38 | // for(i=0; i < 4; i++) 39 | // insere_lista_ordenada(li,a[i]); 40 | // 41 | // imprime_lista(li); 42 | 43 | for(i=0; i < 2; i++) 44 | insere_lista_final(li,a[i]); 45 | 46 | imprime_lista(li); 47 | 48 | libera_lista(li); 49 | system("pause"); 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /Compressao RLE/codificacao_RLE.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void encode(){ 5 | FILE *fs, *fd; 6 | fs = fopen("lena.txt","r"); 7 | if(fs == NULL) return; 8 | 9 | fd = fopen("lena_compressed.txt","w"); 10 | if(fd == NULL) return; 11 | 12 | int va, new_va, n = 1; 13 | fscanf(fs,"%d",&va); 14 | while(1) { 15 | fscanf(fs,"%d",&new_va); 16 | 17 | if(feof(fs)) break; 18 | 19 | if(va == new_va){ 20 | n++; 21 | }else{ 22 | if(n > 1 || va == 0) 23 | fprintf(fd,"0 %d %d ",va, n); 24 | else 25 | fprintf(fd,"%d ",va); 26 | 27 | va = new_va; 28 | n = 1; 29 | } 30 | } 31 | fclose(fs); 32 | fclose(fd); 33 | } 34 | 35 | void decode(){ 36 | FILE *fs, *fd; 37 | fs = fopen("lena_compressed.txt","r"); 38 | if(fs == NULL) return; 39 | 40 | fd = fopen("lena_new.txt","w"); 41 | if(fd == NULL) return; 42 | 43 | int i, va, new_va, n = 1; 44 | while(1) { 45 | fscanf(fs,"%d",&va); 46 | 47 | if(feof(fs)) break; 48 | 49 | if(va == 0){ 50 | fscanf(fs,"%d%d",&new_va,&n); 51 | for(i = 1; i <= n; i++) 52 | fprintf(fd,"%d ",new_va); 53 | }else 54 | fprintf(fd,"%d ",va); 55 | } 56 | 57 | fclose(fs); 58 | fclose(fd); 59 | } 60 | 61 | int main(){ 62 | encode(); 63 | 64 | decode(); 65 | 66 | return 0; 67 | } 68 | 69 | -------------------------------------------------------------------------------- /Arvore AVL/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ArvoreAVL.h" 4 | 5 | int main(){ 6 | ArvAVL* avl; 7 | int res,i; 8 | //int N = 10, dados[10] = {50,25,10,5,7,3,30,20,8,15}; 9 | //int N = 11, dados[11] = {50,25,10,5,5,7,3,30,20,8,15}; 10 | int N = 10, dados[10] = {1,2,3,10,4,5,9,7,8,6}; 11 | 12 | avl = cria_ArvAVL(); 13 | 14 | for(i=0;i 2 | #include 3 | #include "DequeDinamico.h" 4 | 5 | int main(){ 6 | struct aluno al,a[4] = {{2,"Andre",9.5,7.8,8.5}, 7 | {4,"Ricardo",7.5,8.7,6.8}, 8 | {1,"Bianca",9.7,6.7,8.4}, 9 | {3,"Ana",5.7,6.1,7.4}}; 10 | Deque* dq = cria_Deque(); 11 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 12 | int i; 13 | for(i=0; i < 4; i++){ 14 | if(i%2 == 0){ 15 | insereInicio_Deque(dq,a[i]); 16 | consultaInicio_Deque(dq,&al); 17 | }else{ 18 | insereFinal_Deque(dq,a[i]); 19 | consultaFinal_Deque(dq,&al); 20 | } 21 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 22 | } 23 | 24 | imprime_Deque(dq); 25 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 26 | 27 | removeInicio_Deque(dq); 28 | removeInicio_Deque(dq); 29 | imprime_Deque(dq); 30 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 31 | 32 | for(i=0; i < 4; i++){ 33 | if(i%2 == 0){ 34 | insereInicio_Deque(dq,a[i]); 35 | consultaInicio_Deque(dq,&al); 36 | }else{ 37 | insereFinal_Deque(dq,a[i]); 38 | consultaFinal_Deque(dq,&al); 39 | } 40 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 41 | } 42 | imprime_Deque(dq); 43 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 44 | 45 | removeFinal_Deque(dq); 46 | removeFinal_Deque(dq); 47 | imprime_Deque(dq); 48 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 49 | 50 | libera_Deque(dq); 51 | system("pause"); 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /Deque Estatico/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "DequeEstatico.h" 4 | 5 | int main(){ 6 | struct aluno al,a[4] = {{2,"Andre",9.5,7.8,8.5}, 7 | {4,"Ricardo",7.5,8.7,6.8}, 8 | {1,"Bianca",9.7,6.7,8.4}, 9 | {3,"Ana",5.7,6.1,7.4}}; 10 | Deque* dq = cria_Deque(); 11 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 12 | int i; 13 | for(i=0; i < 4; i++){ 14 | if(i%2 == 0){ 15 | insereInicio_Deque(dq,a[i]); 16 | consultaInicio_Deque(dq,&al); 17 | }else{ 18 | insereFinal_Deque(dq,a[i]); 19 | consultaFinal_Deque(dq,&al); 20 | } 21 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 22 | } 23 | 24 | imprime_Deque(dq); 25 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 26 | 27 | removeInicio_Deque(dq); 28 | removeInicio_Deque(dq); 29 | imprime_Deque(dq); 30 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 31 | 32 | for(i=0; i < 4; i++){ 33 | if(i%2 == 0){ 34 | insereInicio_Deque(dq,a[i]); 35 | consultaInicio_Deque(dq,&al); 36 | }else{ 37 | insereFinal_Deque(dq,a[i]); 38 | consultaFinal_Deque(dq,&al); 39 | } 40 | printf("Consulta: %d \t %s\n",al.matricula,al.nome); 41 | } 42 | imprime_Deque(dq); 43 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 44 | 45 | removeFinal_Deque(dq); 46 | removeFinal_Deque(dq); 47 | imprime_Deque(dq); 48 | printf("Tamanho: %d\n\n\n\n",tamanho_Deque(dq)); 49 | 50 | libera_Deque(dq); 51 | system("pause"); 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /Busca e Ordenacao/ProjOrdenacao_Quick.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | 6 | //============================================ 7 | void printfVet(int *V , int N){ 8 | int i; 9 | for(i = 0; i < N; i++) 10 | printf("%2d ",V[i]); 11 | printf("\n"); 12 | } 13 | 14 | void printfLinha(){ 15 | printf("----------------------------------------------\n"); 16 | } 17 | //============================================ 18 | 19 | int particiona(int *V, int inicio, int final ){ 20 | int esq, dir, pivo, aux; 21 | esq = inicio; 22 | dir = final; 23 | pivo = V[inicio]; 24 | while(esq < dir){ 25 | while(esq <= final && V[esq] <= pivo) 26 | esq++; 27 | 28 | while(dir >= 0 && V[dir] > pivo) 29 | dir--; 30 | 31 | if(esq < dir){ 32 | aux = V[esq]; 33 | V[esq] = V[dir]; 34 | V[dir] = aux; 35 | } 36 | } 37 | V[inicio] = V[dir]; 38 | V[dir] = pivo; 39 | printf("---------------\n"); 40 | return dir; 41 | } 42 | 43 | void quickSort(int *V, int inicio, int fim) { 44 | int pivo; 45 | if(fim > inicio){ 46 | pivo = particiona(V, inicio, fim); 47 | quickSort(V, inicio, pivo-1); 48 | quickSort(V, pivo+1, fim); 49 | } 50 | } 51 | 52 | //============================================ 53 | 54 | int main(){ 55 | int vet[7] = {23,4,67,-8,90,54,21}; 56 | int N = 7; 57 | 58 | printf("Sem ordenar:\n"); 59 | printfVet(vet,N); 60 | printfLinha(); 61 | 62 | quickSort(vet,0,N-1);//OK 63 | printf("Ordenado:\n"); 64 | printfVet(vet,N); 65 | 66 | system("pause"); 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /Busca e Ordenacao/ProjOrdenacao_Heap.c: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | 6 | //============================================ 7 | //void printfVet(int *V , int N){ 8 | // int i; 9 | // for(i = 0; i < N; i++) 10 | // printf("%2d ",V[i]); 11 | // printf("\n"); 12 | //} 13 | // 14 | //void printfLinha(){ 15 | // printf("----------------------------------------------\n"); 16 | //} 17 | // 18 | //void printfHeap(int *V){ 19 | // printf("\t\t%d\n",V[0]); 20 | // printf("\t%d\t\t%d\n",V[1],V[2]); 21 | // printf("%d\t%d\t\t%d\t%d\n",V[3],V[4],V[5],V[6]); 22 | // printfLinha(); 23 | //} 24 | //============================================ 25 | void criaHeap(int *vet, int i, int f){ 26 | int aux = vet[i]; 27 | int j = i * 2 + 1; 28 | while (j <= f){ 29 | if(j < f){ 30 | if(vet[j] < vet[j + 1]){ 31 | j = j + 1; 32 | } 33 | } 34 | if(aux < vet[j]){ 35 | vet[i] = vet[j]; 36 | i = j; 37 | j = 2 * i + 1; 38 | }else{ 39 | j = f + 1; 40 | } 41 | } 42 | vet[i] = aux; 43 | } 44 | 45 | void heapSort(int *vet, int N){ 46 | int i, aux; 47 | for(i=(N - 1)/2; i >= 0; i--){ 48 | criaHeap(vet, i, N-1); 49 | } 50 | for (i = N-1; i >= 1; i--){ 51 | aux = vet[0]; 52 | vet [0] = vet [i]; 53 | vet [i] = aux; 54 | criaHeap(vet, 0, i - 1); 55 | } 56 | } 57 | 58 | 59 | int main(){ 60 | //============================================================================== 61 | //int vet[11] = {1,23,4,67,-8,54,90,21,14,-5,1}; 62 | int vet[7] = {23,4,67,-8,90,54,21}; 63 | //int vet[7] = {1,2,3,4,5,6,7}; 64 | int N = 7; 65 | 66 | printf("Sem ordenar:\n"); 67 | //printfVet(vet,N); 68 | //printfLinha(); 69 | 70 | heapSort(vet,N); 71 | //printfHeap(vet); 72 | 73 | printf("Ordenado:\n"); 74 | //printfVet(vet,N); 75 | //============================================================================== 76 | 77 | system("pause"); 78 | return 0; 79 | } 80 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Bem-vindo ao Repositório de Estrutura de Dados do Canal Programação Descomplicada! 2 | 3 | Olá e seja bem-vindo ao repositório de códigos de Estrutura de Dados do nosso canal do YouTube! Aqui você encontrará uma variedade de implementações de estruturas de dados em linguagem C, disponibilizadas com o intuito de aprimorar suas habilidades de programação. 4 | 5 | ## Sobre Nós 6 | 7 | Nosso canal no YouTube é dedicado a ajudar programadores de todos os níveis a entender e dominar os conceitos de Estrutura de Dados. Nós acreditamos firmemente que entender como organizar e manipular dados é essencial para se tornar um programador eficiente e eficaz. 8 | 9 | ## O que você encontrará aqui? 10 | 11 | Neste repositório, você encontrará implementações de várias estruturas de dados, como listas ligadas, pilhas, filas, árvores, grafos e muito mais. Cada implementação é cuidadosamente comentada e explicada no nosso canal de YouTube para facilitar o entendimento, e estamos constantemente adicionando novos exemplos e recursos. 12 | 13 | ## Como Usar este Repositório 14 | 15 | - Explore os diretórios para encontrar a estrutura de dados de seu interesse. 16 | - Leia o código-fonte e os comentários para entender como cada estrutura de dados é implementada. 17 | - Experimente os exemplos fornecidos para ver como cada estrutura de dados pode ser utilizada na prática. 18 | - Não hesite em contribuir com suas próprias implementações, correções ou sugestões de melhorias! 19 | 20 | ## Fique Conectado 21 | 22 | Não se esqueça de se inscrever em nosso canal do YouTube para receber mais conteúdo sobre Estrutura de Dados, dicas de programação e tutoriais práticos. Você também pode nos seguir nas redes sociais para se manter atualizado sobre as últimas novidades e anúncios. 23 | 24 | - [YouTube](https://www.youtube.com/user/progdescomplicada) 25 | - [Twitter](https://twitter.com/progdescomp) 26 | - [LinkeIn](https://www.linkedin.com/in/andr%C3%A9-backes-a839b421b/) 27 | - [Lattes](https://lattes.cnpq.br/8590140337571249) 28 | 29 | Esperamos que este repositório seja útil para você em sua jornada de aprendizado e desenvolvimento como programador. Se tiver alguma dúvida ou sugestão, sinta-se à vontade para entrar em contato conosco. Boa codificação! 🚀 30 | -------------------------------------------------------------------------------- /Arvore Rubro Negra/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "ArvoreLLRB.h" 4 | int main(){ 5 | ArvLLRB * raiz = cria_ArvLLRB(); 6 | //system ("color C"); 7 | //https://www.youtube.com/watch?v=rcDF8IqTnyI 8 | 9 | //int i, N = 7, val[7] ={20,15,30,85,50,21,70}; 10 | int i, N = 9, val[9] = {11,2,1,5,4,7,8,14,15}; 11 | //int i, N = 10, val[10] ={10,15,10,20,30,70,70,85,50,50}; 12 | 13 | for(i=0; i< N; i++){ 14 | /* 15 | if(insere_ArvLLRB(raiz,val[i])) 16 | printf("Insercao: %d -> OK\n",val[i]); 17 | else 18 | printf("Insercao: %d -> ERRO\n",val[i]); 19 | */ 20 | //printf("Insercao: %d -> OK\n",val[i]); 21 | insere_ArvLLRB(raiz,val[i]); 22 | //emOrdem_ArvLLRB(raiz,0); 23 | //printf("\n\n==========================\n\n"); 24 | } 25 | 26 | //printf("Tamanho: %d \n",totalNO_ArvLLRB(raiz)); 27 | emOrdem_ArvLLRB(raiz,0); 28 | 29 | printf("\n\n==========================\n\n"); 30 | 31 | remove_ArvLLRB(raiz,4); 32 | emOrdem_ArvLLRB(raiz,0); 33 | printf("\n\n==========================\n\n"); 34 | remove_ArvLLRB(raiz,1); 35 | emOrdem_ArvLLRB(raiz,0); 36 | 37 | return 0; 38 | } 39 | 40 | /* 41 | 42 | #include 43 | #include 44 | #include "ArvoreAVL.h" 45 | 46 | int main(){ 47 | ArvAVL* avl; 48 | int res,i; 49 | int N = 10, dados[10] = {50,25,10,5,7,3,30,20,8,15}; 50 | //int N = 11, dados[11] = {50,25,10,5,5,7,3,30,20,8,15}; 51 | 52 | avl = cria_ArvAVL(); 53 | 54 | for(i=0;i 2 | #include 3 | #include "Complexos.h" 4 | struct complexo{ 5 | float r,i; 6 | }; 7 | 8 | cplx* cria_cplx(float r, float i){ 9 | cplx* c; 10 | c = (cplx*) malloc(sizeof(struct complexo)); 11 | if(c!=NULL){ 12 | c->r = r; 13 | c->i = i; 14 | } 15 | return c; 16 | } 17 | void destroi_cplx(cplx* c){ 18 | free(c); 19 | } 20 | 21 | int real(cplx* c, float *r){ 22 | if(c == NULL) 23 | return 0; 24 | *r = c->r; 25 | return 1; 26 | } 27 | int imag(cplx* c, float *i){ 28 | if(c == NULL) 29 | return 0; 30 | *i = c->i; 31 | return 1; 32 | } 33 | 34 | int igual_cplx(cplx*c1,cplx*c2){ 35 | //if(!c1 || !c2) 36 | if(c1 == NULL || c2 == NULL) 37 | return 0; 38 | //return (c1->r == c2->r && c1->i == c2->i); 39 | if(c1->r == c2->r && c1->i == c2->i) 40 | return 1; 41 | else 42 | return 0; 43 | } 44 | 45 | int oposto_cplx(cplx*c,cplx*res){ 46 | if(c == NULL || res == NULL) 47 | return 0; 48 | res->r = -(c->r); 49 | res->i = -(c->i); 50 | return 1; 51 | } 52 | 53 | int soma_cplx(cplx*c1,cplx*c2,cplx*res){ 54 | if(c1==NULL || c2==NULL || res==NULL) 55 | return 0; 56 | res->r = c1->r + c2->r; 57 | res->i = c1->i + c2->i; 58 | return 1; 59 | } 60 | 61 | int subtracao_cplx(cplx*c1,cplx*c2,cplx*res){ 62 | if(c1==NULL || c2==NULL || res==NULL) 63 | return 0; 64 | res->r = c1->r - c2->r; 65 | res->i = c1->i - c2->i; 66 | return 1; 67 | } 68 | 69 | int produto_cplx(cplx*c1,cplx*c2,cplx*res){ 70 | if(c1==NULL || c2==NULL || res==NULL) 71 | return 0; 72 | res->r = (c1->r * c2->r) - (c1->i * c2->i); 73 | res->i = (c1->r * c2->i) + (c1->i * c2->r); 74 | return 1; 75 | } 76 | 77 | int modulo_cplx(cplx*c,float *res){ 78 | if(c == NULL) 79 | return 0; 80 | *res = sqrt(pow(c->r,2) + pow(c->i,2)); 81 | return 1; 82 | } 83 | 84 | int inverso_cplx(cplx*c1,cplx*res){ 85 | if(c1==NULL || res==NULL) 86 | return 0; 87 | float m = pow(c1->r,2) + pow(c1->i,2); 88 | res->r = c1->r/m; 89 | res->i = c1->i/m; 90 | return 1; 91 | } 92 | 93 | int divisao_cplx(cplx*c1,cplx*c2,cplx*res){ 94 | if(c1==NULL || c2==NULL || res==NULL) 95 | return 0; 96 | float m = pow(c2->r,2) + pow(c2->i,2); 97 | float r = c2->r/m; 98 | float i = c2->i/m; 99 | res->r = (c1->r * r) - (c1->i * i); 100 | res->i = (c1->r * i) + (c1->i * r); 101 | return 1; 102 | } 103 | 104 | int conj_cplx(cplx*c1,cplx*res){ 105 | if(c1 == NULL || res == NULL) 106 | return 0; 107 | res->r = c1->r; 108 | res->i = -(c1->i); 109 | return 1; 110 | } 111 | -------------------------------------------------------------------------------- /Ordenacao Externa/MergeSortExterno.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define N 100 6 | //#define K 10 7 | 8 | struct arquivo{ 9 | FILE *f; 10 | int pos, MAX; 11 | int *buffer; 12 | }; 13 | 14 | int compara(const void *a, const void *b){ 15 | if(*(int*)a == *(int*)b) 16 | return 0;//iguais 17 | else 18 | if(*(int*)a < *(int*)b) 19 | return -1; //vem antes 20 | else 21 | return 1; //vem depois 22 | } 23 | 24 | void salvaArquivo(char *nome, int *V, int tam, int mudaLinhaFinal){ 25 | int i; 26 | FILE *f = fopen(nome,"a"); 27 | for(i=0; i < tam-1; i++) 28 | fprintf(f,"%d\n",V[i]); 29 | if(mudaLinhaFinal == 0) 30 | fprintf(f,"%d",V[tam-1]); 31 | else 32 | fprintf(f,"%d\n",V[tam-1]); 33 | fclose(f); 34 | } 35 | 36 | void criArquivoTeste(char *nome){ 37 | int i; 38 | FILE *f = fopen(nome,"w"); 39 | srand(time(NULL)); 40 | for(i=1; i < 1000; i++) 41 | fprintf(f,"%d\n",rand()); 42 | fprintf(f,"%d",rand()); 43 | fclose(f); 44 | } 45 | 46 | int criaArquivosOrdenados(char *nome){ 47 | int V[N]; 48 | char novo[20]; 49 | int cont = 0, total = 0; 50 | FILE *f = fopen(nome,"r"); 51 | while(!feof(f)){ 52 | fscanf(f,"%d",&V[total]); 53 | total++; 54 | if(total == N){ 55 | cont++; 56 | sprintf(novo,"Temp%d.txt",cont); 57 | qsort(V,total,sizeof(int),compara); 58 | salvaArquivo(novo, V, total,0); 59 | total = 0; 60 | } 61 | } 62 | 63 | if(total > 0){ 64 | cont++; 65 | sprintf(novo,"Temp%d.txt",cont); 66 | qsort(V,total,sizeof(int),compara); 67 | salvaArquivo(novo, V, total,0); 68 | } 69 | fclose(f); 70 | return cont; 71 | } 72 | 73 | void preencheBuffer(struct arquivo* arq, int T){ 74 | int i; 75 | if(arq->f == NULL) 76 | return; 77 | 78 | arq->pos = 0; 79 | arq->MAX = 0; 80 | for(i=0; if)){ 82 | fscanf(arq->f,"%d",&arq->buffer[arq->MAX]); 83 | arq->MAX++; 84 | }else{ 85 | fclose(arq->f); 86 | arq->f = NULL; 87 | break; 88 | } 89 | } 90 | } 91 | 92 | int procuraMenor(struct arquivo* arq,int K,int T,int* menor){ 93 | int i, idx = -1; 94 | for(i=0; i