├── .gitignore ├── CONTRIBUTING.md ├── LICENSE ├── README.md └── root ├── Listas - questions ├── Lista 01 - Ponteiros.pdf ├── Lista 02 - AlocDinamica - Vetores.pdf ├── Lista 03 - AlocDinamica.pdf ├── Lista 04 - Matrizes.pdf ├── Lista 05 - Strucs.pdf ├── Lista 06 - Structs.pdf └── Lista 07 - Union Enum.pdf ├── TAD ├── ContaBancaria │ ├── README.md │ ├── contabancaria.c │ ├── contabancaria.h │ └── main.c ├── README.md ├── circulo │ ├── circulo.c │ ├── circulo.h │ ├── circulo.o │ ├── main │ ├── main.c │ └── main.o ├── exemplo-01 │ ├── README.md │ ├── main.c │ ├── str.c │ └── str.h ├── exemplo-circulo │ ├── README.md │ ├── circulo.c │ ├── circulo.h │ ├── main.c │ ├── ponto.c │ └── ponto.h ├── exemplo-ponto │ ├── README.md │ ├── main.c │ ├── ponto.c │ └── ponto.h ├── funcionario │ ├── funcionario.c │ ├── funcionario.h │ ├── funcionarios.txt │ └── main.c └── ingresso │ ├── ingresso.c │ ├── ingresso.h │ ├── ingressos.txt │ └── main.c ├── Ufersa.png ├── algoritmos-de-busca ├── README.md ├── binary.c ├── complexity.md ├── interpolacao.c ├── jump.c ├── linear.c ├── struzik.c ├── time.md └── trabalho.md ├── arquivos ├── Lista-para-treino │ ├── Lista-para-treino-Arquivos.pdf │ ├── README.md │ ├── entrada_ex1.txt │ ├── entrada_ex2.txt │ ├── quest-1.c │ └── quest-2.c ├── README.md ├── aula-pratica-02-lab │ ├── quest-1.c │ ├── quest-2.c │ └── quest-3.c ├── entrada_lista1_ex2.txt ├── entrada_q3.txt ├── manipular_arquivos.c ├── pratica-01-questao-1.c ├── pratica-01-questao-2.c └── questões-prática-01-arquivos.pdf ├── estruturas ├── ContaBancaria.c ├── README.md ├── aninhamento.c ├── conta-bancaria.c ├── enum │ ├── README.md │ ├── enum.png │ └── exemplo-enum.c ├── exemplo-pessoa.c ├── exercio-lista.c ├── funcionário.c ├── retangulo-circulo.c ├── retangulo.c ├── struct.png ├── union │ ├── README.md │ ├── exemplo-aula.c │ ├── exemplo-union.c │ └── union.png ├── vetores-de-ponteiros-de-struct │ ├── README.md │ ├── turma-alunos.c │ └── vetor-ponteiro-struct.png └── vetores-estruturados │ ├── README.md │ ├── funcionarios.c │ ├── vetor-de-pontos.c │ └── vetor-de-struct.png ├── execution_time ├── aula.c ├── fibonacci.c └── tempo.c ├── filas ├── README.md ├── filas_com_listas │ ├── fila.c │ ├── fila.h │ └── main.c └── filas_com_vetores │ ├── fila.c │ ├── fila.h │ └── main.c ├── github-git-cheat-sheet.pdf ├── interecao por menus ├── README.md └── menu.c ├── listas ├── README.md ├── listas-circulares │ ├── Circulares.c │ └── README.md ├── listas-duplamente-encadeadas │ ├── Lista.c │ ├── Lista.h │ ├── README.md │ └── main.c ├── listasEncadeadas │ ├── Lista.c │ ├── Lista.h │ ├── README.md │ └── main.c └── pratica-01 │ ├── Listas_Encadeadas_-_Prtica_1.pdf │ ├── README.md │ ├── lista_de_frutas.c │ ├── main │ ├── quest01.c │ ├── quest02.c │ ├── quest03.c │ └── quest04.c ├── matrices ├── README.md ├── exemplo_aula.c ├── frutas_exemplo.c ├── matriz.jpg ├── nlogonia.c ├── question-1.c └── question-2.c ├── pilha ├── README.md ├── pilha_com_listas │ ├── main.c │ ├── pilha.c │ └── pilha.h └── pilha_com_vetores │ ├── main.c │ ├── pilha.c │ └── pilha.h ├── pointers ├── README.md ├── alocdinamic.md ├── exercise-five.c ├── exercise-four.c ├── exercise-three.c ├── exercise-two.c ├── exercises-one.c └── ponteiro_de_funcao.c ├── provaI.c ├── questoes_revisao.md ├── recursividade.md ├── sort-algorithms ├── README.md └── sort-algorithms │ ├── bubblesort.c │ ├── combsort.c │ ├── gnomesort.c │ ├── insertionsort.c │ ├── mergesort.c │ ├── quicksort.c │ └── shellsort.c ├── ufersa.jpg └── vectors ├── README.md ├── question-1.c ├── question-2.c ├── question-3.c ├── question-4.c ├── vetor-alocacao-dinamica.png └── vetores.png /.gitignore: -------------------------------------------------------------------------------- 1 | # Ignore all files with the specified extension. 2 | *.ini 3 | *.exe 4 | 5 | 6 | ### VisualStudioCode ### 7 | .vscode/* 8 | root/.vscode/* 9 | .vscode/settings.json 10 | .vscode/tasks.json 11 | .vscode/launch.json 12 | .vscode/extensions.json 13 | *.code-workspace 14 | 15 | ### VisualStudioCode Patch ### 16 | # Ignore all local history of files 17 | .history 18 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | Se você encontrar algum bug ou encontrar uma solução mais ideal, fork e abra uma solicitação pull resquest. 2 | 3 | 4 | If you find some bug or found more optimal solution, fork it and open a pull request. 5 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |
2 | 3 | 4 |
5 | 6 | # Algorithms and Data Structure 7 | ###### Professora: [Rosana Rego](https://github.com/roscibely) 8 | 9 | ### PEX1241 - Algoritmos e Estrutura de dados I 10 | #### Bacharelado Interdisciplinar em Tecnologia da Informação - UFERSA 11 | 12 | --- 13 | - Git e controle de versão: 🤜 [curso grátis](https://www.dataquest.io/course/git-and-vcs/) 14 | - [Git cheat sheet](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/root/github-git-cheat-sheet.pdf) :octocat: 15 | --- 16 | #### Parte I 17 | 1. [Ponteiros](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/pointers) 18 | 2. [Alocação dinâmica](https://github.com/roscibely/algorithms-and-data-structure/blob/main/root/pointers/alocdinamic.md) 19 | - 2.1 [Vetores](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/vectors) 20 | - 2.2 [Matrizes](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/matrices) 21 | 3. [Tipos Estruturados](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/estruturas) 22 | - 3.1 [Vetores de Estruturas](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/estruturas/vetores-estruturados) 23 | - 3.2 [Vetores de ponteiros para estruturas](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/estruturas/vetores-de-ponteiros-de-struct) 24 | - 3.3 [União](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/estruturas/union) 25 | - 3.4 [Enumerações](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/estruturas/enum) 26 | - [Exercícios](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/root/questoes_revisao.md) 27 | --- 28 | #### Parte II 29 | 30 | 1. [Arquivos](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/arquivos) 31 | 2. [Tipos abstrato de dados](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/TAD) 32 | 3. [Complexidade de Algoritmos](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/root/algoritmos-de-busca/time.md) 33 | - 3.1 [Calculando o tempo de execução](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/execution_time) 34 | 4. [Algoritmos de Busca](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/algoritmos-de-busca) 35 | 5. [Algoritmos de Ordenação](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/sort-algorithms) 36 | --- 37 | #### Parte III 38 | 39 | 1. [Estrutura de dados: Lista](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/listas) 40 | 2. [Estrutura de dados: Pilha](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/pilha) 41 | 3. [Estrutura de dados: Fila](https://github.com/roscibely/algorithms-and-data-structure/tree/main/root/filas) 42 | --- 43 | #### EXTRA 44 | 1. [Intereção por menu](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/interecao%20por%20menus) 45 | --- 46 | #### Quer aprender Python? 47 | Comece [clicando aqui](https://github.com/roscibely/data-structure-with-python) 48 | 49 | --- 50 | 51 | #### Especial 52 | 53 | --- 54 | 55 | #### i) Compilando e executando programas em C no terminal do Linux 56 | 57 | Com o terminal aberto, digite o comando abaixo para compilar o programa: 58 | ```bash 59 | gcc nome_do_programa.c -o nome_do_programa 60 | ``` 61 | Para executar o programa, digite o comando abaixo: 62 | ```bash 63 | ./nome_do_programa 64 | ``` 65 | Para compilar e executar o programa em um único comando, digite o comando abaixo: 66 | ```bash 67 | gcc nome_do_programa.c -o nome_do_programa && ./nome_do_programa 68 | ``` 69 | --- 70 | 71 | #### ii) Compilando e executando programas em C no terminal do Windows 72 | 73 | Com o terminal aberto, digite o comando abaixo para compilar o programa: 74 | ```bash 75 | gcc nome_do_programa.c -o nome_do_programa 76 | ``` 77 | Para executar o programa, digite o comando abaixo: 78 | ```bash 79 | nome_do_programa 80 | ``` 81 | Para compilar e executar o programa em um único comando, digite o comando abaixo: 82 | ```bash 83 | gcc nome_do_programa.c -o nome_do_programa && nome_do_programa 84 | ``` 85 | 86 | gcc é o compilador do C, ele compila o código fonte e gera um arquivo executável. O comando acima compila o arquivo ```nome_do_programa.c``` e gera um arquivo executável ```nome_do_programa```. O parâmetro ```-o nome_do_programa``` indica o nome do arquivo executável gerado. O parâmetro ```&&``` indica que o próximo comando só será executado se o comando anterior for executado com sucesso. O comando ```./nome_do_programa``` executa o arquivo executável ```nome_do_programa```. 87 | 88 | ### Debugger 89 | 90 | Para compilar o programa com o debugger, digite o comando abaixo: 91 | ```bash 92 | gcc -g nome_do_programa.c -o nome_do_programa 93 | ``` 94 | Para executar o programa com o debugger, digite o comando abaixo: 95 | ```bash 96 | gdb nome_do_programa 97 | ``` 98 | Para compilar e executar o programa com o debugger em um único comando, digite o comando abaixo: 99 | ```bash 100 | gcc -g nome_do_programa.c -o nome_do_programa && gdb nome_do_programa 101 | ``` 102 | Para executar o programa com o debugger, digite o comando abaixo: 103 | ```bash 104 | gdb nome_do_programa 105 | ``` 106 | 107 | 108 | 109 | --- 110 |
111 | 112 |
113 | UFERSA - Campus Pau dos Ferros 114 | -------------------------------------------------------------------------------- /root/Listas - questions/Lista 01 - Ponteiros.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 01 - Ponteiros.pdf -------------------------------------------------------------------------------- /root/Listas - questions/Lista 02 - AlocDinamica - Vetores.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 02 - AlocDinamica - Vetores.pdf -------------------------------------------------------------------------------- /root/Listas - questions/Lista 03 - AlocDinamica.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 03 - AlocDinamica.pdf -------------------------------------------------------------------------------- /root/Listas - questions/Lista 04 - Matrizes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 04 - Matrizes.pdf -------------------------------------------------------------------------------- /root/Listas - questions/Lista 05 - Strucs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 05 - Strucs.pdf -------------------------------------------------------------------------------- /root/Listas - questions/Lista 06 - Structs.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 06 - Structs.pdf -------------------------------------------------------------------------------- /root/Listas - questions/Lista 07 - Union Enum.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Listas - questions/Lista 07 - Union Enum.pdf -------------------------------------------------------------------------------- /root/TAD/ContaBancaria/README.md: -------------------------------------------------------------------------------- 1 | ## Exemplo de Tipo abstrato de dados 2 | 3 | ## Tipo ContaBancaria 4 | 5 | Para compilar o exemplo: 6 | 7 | 8 | ```console 9 | gcc -c contabancaria.c 10 | gcc -c main.c 11 | gcc -o main.exe contabancaria.o main.o 12 | main 13 | ``` 14 | -------------------------------------------------------------------------------- /root/TAD/ContaBancaria/contabancaria.c: -------------------------------------------------------------------------------- 1 | // Crie um TAD chamado ContaBancaria que possui os seguintes campos: titular, número e saldo. 2 | #include 3 | #include 4 | #include "contabancaria.h" 5 | 6 | struct contabancaria 7 | { 8 | char titular[50]; 9 | int numero; 10 | float saldo; 11 | }; 12 | 13 | 14 | ContaBancaria *criaconta(char * nome_arquivo){ 15 | 16 | ContaBancaria *conta; 17 | conta = (ContaBancaria *) malloc(sizeof(ContaBancaria)); 18 | if (conta == NULL){ 19 | printf("Erro ao alocar memoria"); 20 | exit(1); 21 | } 22 | 23 | printf("Digite o nome do titular: "); 24 | scanf("%s", conta->titular); 25 | printf("Digite o numero da conta: "); 26 | scanf("%d", &conta->numero); 27 | conta->saldo = 0; 28 | 29 | FILE *arq; 30 | arq = fopen(nome_arquivo, "a"); 31 | if(arq == NULL){ 32 | printf("Erro ao abrir o arquivo"); 33 | exit(1); 34 | } 35 | fprintf(arq, "Titular: %s Numero: %d Saldo: %.2f \n", conta->titular, conta->numero, conta->saldo); 36 | fclose(arq); 37 | 38 | return conta; 39 | } 40 | 41 | 42 | void deposita(ContaBancaria *conta, float valor){ 43 | conta->saldo += valor; 44 | } 45 | 46 | 47 | void saca(ContaBancaria *conta, float valor){ 48 | 49 | if(conta->saldo >= valor){ 50 | conta->saldo -= valor; 51 | }else{ 52 | printf("Saldo insuficiente para realizar o saque"); 53 | } 54 | 55 | } 56 | 57 | 58 | void transfere(ContaBancaria *conta1, ContaBancaria *conta2, float valor){ 59 | 60 | if(conta1->saldo >= valor){ 61 | conta1->saldo -= valor; 62 | conta2->saldo += valor; 63 | }else{ 64 | printf("Saldo insuficiente para realizar a transferencia"); 65 | } 66 | } 67 | 68 | 69 | void excluiConta(ContaBancaria *conta){ 70 | free(conta); 71 | } -------------------------------------------------------------------------------- /root/TAD/ContaBancaria/contabancaria.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /*Definição do tipo de dados abstrato ContaBancaria: 5 | estrutura que armazena o número da conta, o nome do correntista e o saldo da conta. */ 6 | typedef struct contabancaria ContaBancaria; 7 | 8 | /*Cria conta: aloca dinamicamente uma estrutura do tipo ContaBancaria 9 | e retorna seu endereço */ 10 | ContaBancaria *criaconta(char * nome_arquivo); 11 | 12 | /*Deposita: recebe, como parâmetros, o endereço de uma estrutura do tipo ContaBancaria 13 | e um valor, atualizando o saldo;*/ 14 | void deposita(ContaBancaria *conta, float valor); 15 | 16 | /*Saca: recebe, como parâmetros, o endereço de uma estrutura do tipo ContaBancaria 17 | e um valor, atualizando o saldo;*/ 18 | void saca(ContaBancaria *conta, float valor); 19 | 20 | /*Transfere: recebe, como parâmetros, o endereço de duas estruturas do tipo ContaBancaria 21 | e um valor, atualizando o saldo das duas contas;*/ 22 | void transfere(ContaBancaria *conta1, ContaBancaria *conta2, float valor); 23 | 24 | /*Exclui conta: libera o espaço alocado dinamicamente para a estrutura*/ 25 | void excluiConta(ContaBancaria *conta); -------------------------------------------------------------------------------- /root/TAD/ContaBancaria/main.c: -------------------------------------------------------------------------------- 1 | #include "contabancaria.h" 2 | 3 | 4 | int main(void) { 5 | ContaBancaria *conta = criaconta("conta.txt"); 6 | deposita(conta, 100); 7 | saca(conta, 50); 8 | ContaBancaria *conta2 = criaconta("conta.txt"); 9 | deposita(conta2, 200); 10 | transfere(conta, conta2, 50); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /root/TAD/README.md: -------------------------------------------------------------------------------- 1 | # Tipos Abstrato de Dados (TAD) na Linguagem C 2 | 3 | ## O que é um TAD? 4 | 5 | Um TAD é um tipo de dado abstrato, ou seja, um tipo de dado que não é definido na linguagem C, mas que pode ser utilizado para representar um tipo de dado abstrato. 6 | 7 | ## Para que serve? 8 | 9 | TADs são úteis para representar tipos de dados abstratos. 10 | 11 | ## Como funciona? 12 | 13 | TADs são definidos através de structs. 14 | 15 | ```c 16 | 17 | struct pessoa { 18 | char nome[50]; 19 | int idade; 20 | }; 21 | 22 | struct pessoa joao; 23 | 24 | ``` 25 | 26 | Para criar um TAD, precisamos criar uma struct que contenha os dados que queremos representar. Um arquivo que contenha uma struct é chamado de arquivo de cabeçalho (.h). E um arquivo que contenha a implementação de uma struct é chamado de arquivo de implementação (.c). Portanto, para criar um TAD, precisamos criar um arquivo de cabeçalho e um arquivo de implementação. 27 | 28 | ## Exemplo: TAD pessoa 29 | 30 | ### Arquivo de cabeçalho (pessoa.h) 31 | 32 | 33 | 34 | ```c 35 | 36 | typedef struct pessoa Pessoa; 37 | 38 | Pessoa* cria_pessoa(char nome[50], int idade); 39 | 40 | void imprime_pessoa(Pessoa *p); 41 | 42 | ``` 43 | 44 | ### Arquivo de implementação (pessoa.c) 45 | 46 | 47 | 48 | ```c 49 | 50 | #include 51 | #include 52 | #include "pessoa.h" 53 | 54 | struct pessoa { 55 | char nome[50]; 56 | int idade; 57 | }; 58 | 59 | Pessoa* cria_pessoa(char nome[50], int idade) { 60 | Pessoa *p = (Pessoa*) malloc(sizeof(Pessoa)); 61 | p->idade = idade; 62 | strcpy(p->nome, nome); 63 | return p; 64 | } 65 | 66 | void imprime_pessoa(Pessoa *p) { 67 | printf("Nome: %s\n", p->nome); 68 | printf("Idade: %d\n", p->idade); 69 | } 70 | 71 | ``` 72 | 73 | ## Arquivo principal (main.c) 74 | 75 | 76 | ```c 77 | 78 | #include 79 | #include "pessoa.h" 80 | 81 | int main() { 82 | Pessoa *p = cria_pessoa("João", 20); 83 | imprime_pessoa(p); 84 | return 0; 85 | } 86 | 87 | ``` 88 | 89 | 90 | 91 | -------------------------------------------------------------------------------- /root/TAD/circulo/circulo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "circulo.h" 4 | 5 | struct circulo 6 | { 7 | float x,y; // Coordenadas do centro 8 | float raio; // raio 9 | }; 10 | 11 | 12 | Circulo* cria_circulo() { 13 | Circulo* c = (Circulo*) malloc(sizeof(Circulo)); 14 | if(c==NULL){ 15 | exit(1); 16 | } 17 | else{ 18 | printf("Digite a coordenada x: "); 19 | scanf("%f", &c->x); 20 | printf("\nDigite a coordenada y: "); 21 | scanf("%f", &c->y); 22 | printf("\nDigite o raio: "); 23 | scanf("%f", &c->raio); 24 | } 25 | return c; 26 | } 27 | 28 | 29 | float area_circulo(Circulo* c) { 30 | return 3.14 * c->raio * c->raio; 31 | } 32 | 33 | 34 | void move_circulo(Circulo* c, float novo_x, float novo_y) { 35 | c->x = novo_x; 36 | c->y = novo_y; 37 | } -------------------------------------------------------------------------------- /root/TAD/circulo/circulo.h: -------------------------------------------------------------------------------- 1 | typedef struct circulo Circulo; 2 | 3 | /* Função que cria um circulo */ 4 | Circulo* cria_circulo(); 5 | 6 | /* Função que calcula a área de um circulo */ 7 | float area_circulo(Circulo* c); 8 | 9 | /* Função que modifica o centro de um circulo */ 10 | void move_circulo(Circulo* c, float novo_x, float novo_y); -------------------------------------------------------------------------------- /root/TAD/circulo/circulo.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/circulo/circulo.o -------------------------------------------------------------------------------- /root/TAD/circulo/main: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/circulo/main -------------------------------------------------------------------------------- /root/TAD/circulo/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "circulo.h" 4 | 5 | 6 | int main() { 7 | Circulo* c = cria_circulo(); 8 | printf("Area do circulo: %f\n", area_circulo(c)); 9 | move_circulo(c, 10, 10); 10 | free(c); // Libera a memória alocada 11 | return 0; 12 | } -------------------------------------------------------------------------------- /root/TAD/circulo/main.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/circulo/main.o -------------------------------------------------------------------------------- /root/TAD/exemplo-01/README.md: -------------------------------------------------------------------------------- 1 | ## Exemplo de módulo em C: Módulo que manipula strings 2 | 3 | Para compilar o exemplo: 4 | 5 | 6 | ```console 7 | gcc -c str.c 8 | gcc -c main.c 9 | gcc -o programa.exe str.o main.o 10 | programa 11 | ``` 12 | -------------------------------------------------------------------------------- /root/TAD/exemplo-01/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "str.h" 3 | 4 | int main (void){ 5 | char str[101], str1[51], str2[51]; 6 | printf("Entre com uma seqüência de caracteres: "); 7 | scanf(" %50[^\n]", str1); 8 | printf("Entre com outra seqüência de caracteres: "); 9 | scanf(" %50[^\n]", str2); 10 | copia(str, str1); 11 | concatena(str, str2); 12 | printf("Comprimento da concatenação: %d\n",comprimento(str)); 13 | return 0; 14 | } -------------------------------------------------------------------------------- /root/TAD/exemplo-01/str.c: -------------------------------------------------------------------------------- 1 | #include "str.h" 2 | 3 | int comprimento (char* s) 4 | { 5 | int i; 6 | int n = 0; /* contador */ 7 | for (i=0; s[i] != '\0'; i++) 8 | n++; 9 | return n; 10 | } 11 | 12 | void copia (char* dest, char* orig) 13 | { 14 | int i; 15 | for (i=0; orig[i] != '\0'; i++) 16 | dest[i] = orig[i]; 17 | /* fecha a cadeia copiada */ 18 | dest[i] = '\0'; 19 | } 20 | 21 | void concatena (char*dest, char* orig) 22 | { 23 | int i = 0; /* indice usado na cadeia destino, inicializado com zero */ 24 | int j; /* indice usado na cadeia origem */ 25 | /* acha o final da cadeia destino */ 26 | i = 0; 27 | while (dest[i] != '\0') 28 | i++; 29 | /* copia elementos da origem para o final do destino */ 30 | for (j=0; orig[j] != '\0'; j++) { 31 | dest[i] = orig[j]; 32 | i++; 33 | } 34 | /* fecha cadeia destino */ 35 | dest[i] = '\0'; 36 | } -------------------------------------------------------------------------------- /root/TAD/exemplo-01/str.h: -------------------------------------------------------------------------------- 1 | 2 | int comprimento (char* str); 3 | void copia (char* dest, char* orig); 4 | void concatena (char* dest, char* orig); 5 | -------------------------------------------------------------------------------- /root/TAD/exemplo-circulo/README.md: -------------------------------------------------------------------------------- 1 | ## Exemplo de Tipo abstrato de dados 2 | 3 | ## Tipo Circulo 4 | 5 | Para compilar o exemplo: 6 | 7 | 8 | ```console 9 | gcc -c ponto.c 10 | gcc -c circulo.c 11 | gcc -c main.c 12 | gcc -o programa.exe ponto.o circulo.o main.o 13 | programa 14 | ``` 15 | -------------------------------------------------------------------------------- /root/TAD/exemplo-circulo/circulo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "ponto.h" 5 | #include "circulo.h" 6 | #define PI 3.14 7 | 8 | struct circulo{ 9 | Ponto* c; 10 | float r; 11 | 12 | }; 13 | 14 | Circulo* circ_cria(float x, float y, float R){ 15 | Ponto * p = cria(x,y); 16 | Circulo*C = (Circulo *) malloc(sizeof(Circulo)); 17 | if(C == NULL){ 18 | exit(1); 19 | } 20 | C->c = p; 21 | C->r = R; 22 | return C; 23 | } 24 | 25 | void circ_libera(Circulo* C){ 26 | libera(C->c); 27 | free(C); 28 | } 29 | 30 | 31 | float circ_area(Circulo *C){ 32 | float a = (C->r)*(C->r)*PI; 33 | return a; 34 | } 35 | 36 | int circ_interior(Ponto *p, Circulo *C){ 37 | float dist = distancia(p,C->c); 38 | return distr?1:0; 39 | } 40 | -------------------------------------------------------------------------------- /root/TAD/exemplo-circulo/circulo.h: -------------------------------------------------------------------------------- 1 | #ifndef CIRCULO_H_INCLUDED 2 | #define CIRCULO_H_INCLUDED 3 | #include 4 | #include 5 | #include 6 | #include "ponto.h" 7 | typedef struct circulo Circulo; 8 | 9 | Circulo* circ_cria(float x, float y, float r); 10 | 11 | void circ_libera(Circulo* C); 12 | 13 | float circ_area(Circulo *C); 14 | 15 | int circ_interior(Ponto *p, Circulo *C); 16 | 17 | 18 | #endif // CIRCULO_H_INCLUDED 19 | -------------------------------------------------------------------------------- /root/TAD/exemplo-circulo/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "ponto.h" 5 | #include "circulo.h" 6 | 7 | int main(void){ 8 | 9 | /*float x, y; 10 | Ponto* p = cria(2.0,1.0); 11 | Ponto* q = cria(3.4,2.1); 12 | float d = distancia(p,q); 13 | printf("Distancia entre pontos: %.1f\n",d); 14 | libera(q); 15 | libera(p);*/ 16 | Ponto* p = cria(2.0,1.0); 17 | Circulo* C = circ_cria(4, 4, 2); 18 | float a = circ_area(C); 19 | printf("A area do circulo es: %.1f\n", a); 20 | circ_interior(p, C)?printf("Ponto no circulo \n"):printf("Ponto nao esta circulo \n"); 21 | 22 | circ_libera(C); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /root/TAD/exemplo-circulo/ponto.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/exemplo-circulo/ponto.c -------------------------------------------------------------------------------- /root/TAD/exemplo-circulo/ponto.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/exemplo-circulo/ponto.h -------------------------------------------------------------------------------- /root/TAD/exemplo-ponto/README.md: -------------------------------------------------------------------------------- 1 | ## Exemplo de Tipo abstrato de dados 2 | 3 | ## Tipo Ponto 4 | 5 | Para compilar o exemplo: 6 | 7 | 8 | ```console 9 | gcc -c ponto.c 10 | gcc -c main.c 11 | gcc -o programa.exe ponto.o main.o 12 | programa 13 | ``` 14 | -------------------------------------------------------------------------------- /root/TAD/exemplo-ponto/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "ponto.h" 5 | 6 | 7 | int main(void){ 8 | 9 | Ponto* p = cria(2.0,1.0); 10 | Ponto* q = cria(3.4,2.1); 11 | float d = distancia(p,q); 12 | printf("Distancia entre pontos: %.1f\n",d); 13 | libera(q); 14 | libera(p); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /root/TAD/exemplo-ponto/ponto.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/exemplo-ponto/ponto.c -------------------------------------------------------------------------------- /root/TAD/exemplo-ponto/ponto.h: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/TAD/exemplo-ponto/ponto.h -------------------------------------------------------------------------------- /root/TAD/funcionario/funcionario.c: -------------------------------------------------------------------------------- 1 | //TAD Funcionario que possui os seguintes campos: nome, salario e cargo 2 | 3 | #include 4 | #include 5 | #include 6 | #include "funcionario.h" 7 | 8 | 9 | 10 | struct funcionario{ 11 | char nome[50]; 12 | float salario; 13 | char cargo[50]; 14 | }; 15 | 16 | // Preencher campos do funcionario: Receber os dados do funcionario fornecidos pelo usuario via teclado e armazenar em um arquivo 17 | 18 | void preencherFuncionario(char *nomeArquivo){ 19 | 20 | Funcionario func; 21 | printf("Digite o nome do funcionario: "); 22 | scanf(" %[^\n]", func.nome); 23 | printf("Digite o salario do funcionario: "); 24 | scanf("%f", &func.salario); 25 | printf("Digite o cargo do funcionario: "); 26 | scanf(" %[^\n]", func.cargo); 27 | 28 | FILE *arquivo = fopen(nomeArquivo, "a"); 29 | if(arquivo == NULL){ 30 | printf("Erro ao abrir o arquivo"); 31 | exit(1); 32 | } 33 | 34 | fprintf(arquivo, "%s %f %s ", func.nome, func.salario, func.cargo); 35 | printf("Funcionario cadastrado com sucesso!"); 36 | 37 | fclose(arquivo); 38 | } 39 | 40 | // Imprime funcionarios: Imprime todos os funcionarios cadastrados em um arquivo 41 | 42 | void imprimirFuncionarios(char *nomeArquivo){ 43 | 44 | Funcionario func; 45 | 46 | FILE *arquivo = fopen(nomeArquivo, "r"); 47 | if(arquivo == NULL){ 48 | printf("Erro ao abrir o arquivo"); 49 | exit(1); 50 | } 51 | 52 | while(fscanf(arquivo, "%s %f %s ", func.nome, &func.salario, func.cargo) != EOF){ 53 | printf("Nome: %s Salario: %.2f Cargo: %s \n ", func.nome, func.salario, func.cargo); 54 | } 55 | 56 | fclose(arquivo); 57 | } 58 | 59 | // Altera salário: Altera o salário de um funcionário cadastrado em um arquivo 60 | 61 | void alterarSalario(char *nomeArquivo, char * nome){ 62 | 63 | Funcionario func; 64 | float novoSalario; 65 | 66 | printf("Digite o novo salario do funcionario %s: ", nome); 67 | scanf("%f", &novoSalario); 68 | 69 | FILE *arquivo = fopen(nomeArquivo, "r"); 70 | if(arquivo == NULL){ 71 | printf("Erro ao abrir o arquivo"); 72 | exit(1); 73 | } 74 | 75 | FILE *arquivoTemp = fopen("temp.txt", "w"); 76 | if(arquivoTemp == NULL){ 77 | printf("Erro ao abrir o arquivo"); 78 | exit(1); 79 | } 80 | 81 | while(fscanf(arquivo, "%s %f %s ", func.nome, &func.salario, func.cargo) != EOF){ 82 | if(strcmp(func.nome, nome) == 0){ 83 | func.salario = novoSalario; 84 | } 85 | fprintf(arquivoTemp, "%s %f %s ", func.nome, func.salario, func.cargo); 86 | } 87 | 88 | fclose(arquivo); 89 | fclose(arquivoTemp); 90 | 91 | remove(nomeArquivo); 92 | rename("temp.txt", nomeArquivo); 93 | } -------------------------------------------------------------------------------- /root/TAD/funcionario/funcionario.h: -------------------------------------------------------------------------------- 1 | 2 | // Redefinição do tipo Funcionario 3 | typedef struct funcionario Funcionario; 4 | 5 | // Função para preencher os dados de um funcionário e salvar em um arquivo 6 | void preencherFuncionario(char *nomeArquivo); 7 | 8 | // Função para ler os dados de um funcionário de um arquivo e imprimir na tela 9 | void imprimirFuncionarios(char *nomeArquivo); 10 | 11 | // Função para ler os dados de um funcionário de um arquivo e imprimir na tela 12 | void alterarSalario(char *nomeArquivo, char*nome); -------------------------------------------------------------------------------- /root/TAD/funcionario/funcionarios.txt: -------------------------------------------------------------------------------- 1 | Joao 2000.000000 Diretor Maria 3000.000000 Gerente Marcos 500.000000 Estagiario Julia 4000.000000 CEO -------------------------------------------------------------------------------- /root/TAD/funcionario/main.c: -------------------------------------------------------------------------------- 1 | #include "funcionario.c" 2 | 3 | int main(void){ 4 | 5 | preencherFuncionario("funcionarios.txt"); 6 | imprimirFuncionarios("funcionarios.txt"); 7 | alterarSalario("funcionarios.txt", "Maria"); 8 | imprimirFuncionarios("funcionarios.txt"); 9 | 10 | return 0; 11 | } -------------------------------------------------------------------------------- /root/TAD/ingresso/ingresso.c: -------------------------------------------------------------------------------- 1 | // TAD Ingresso que contenha os seguintes campos: atração, local e preço 2 | 3 | #include 4 | #include 5 | #include 6 | #include "ingresso.h" 7 | 8 | struct ingresso { 9 | char atracao[50]; 10 | char local[50]; 11 | float preco; 12 | }; 13 | 14 | 15 | 16 | void preencherIngresso(char *nomeArquivo) { 17 | 18 | Ingresso ingresso; 19 | 20 | FILE *arquivo = fopen(nomeArquivo, "a"); 21 | if (arquivo == NULL) { 22 | printf("Erro ao abrir o arquivo"); 23 | return; 24 | } 25 | 26 | printf("Digite o nome: "); 27 | scanf(" %[^\n]", ingresso.atracao); 28 | printf("Digite o local: "); 29 | scanf(" %[^\n]", ingresso.local); 30 | printf("Digite o preço: "); 31 | scanf("%f", &ingresso.preco); 32 | 33 | fprintf(arquivo, "%s %s %f ", ingresso.atracao, ingresso.local, ingresso.preco); 34 | printf("Ingresso cadastrado com sucesso!\n"); 35 | 36 | fclose(arquivo); 37 | } 38 | 39 | 40 | 41 | void imprimirIngressos(char *nomeArquivo) { 42 | 43 | Ingresso ingresso; 44 | 45 | FILE *arquivo = fopen(nomeArquivo, "r"); 46 | if (arquivo == NULL) { 47 | printf("Erro ao abrir o arquivo"); 48 | return; 49 | } 50 | 51 | while (fscanf(arquivo, "%s %s %f ", ingresso.atracao, ingresso.local, &ingresso.preco) != EOF) { 52 | printf("Atração: %s Local: %s Preço: %.2f \n ", ingresso.atracao, ingresso.local, ingresso.preco); 53 | } 54 | 55 | fclose(arquivo); 56 | } 57 | 58 | // Função para alterar o preço de um ingresso em um arquivo dado o nome da atração 59 | 60 | void alterarPreco(char *nomeArquivo, char *atracao) { 61 | 62 | Ingresso ingresso; 63 | 64 | FILE *arquivo = fopen(nomeArquivo, "r"); 65 | if (arquivo == NULL) { 66 | printf("Erro ao abrir o arquivo"); 67 | return; 68 | } 69 | 70 | FILE *arquivoTemp = fopen("temp.txt", "w"); 71 | if (arquivoTemp == NULL) { 72 | printf("Erro ao abrir o arquivo"); 73 | return; 74 | } 75 | 76 | while (fscanf(arquivo, "%s %s %f ", ingresso.atracao, ingresso.local, &ingresso.preco) != EOF) { 77 | if (strcmp(ingresso.atracao, atracao) == 0) { 78 | printf("Digite o novo preço da atração: "); 79 | scanf("%f", &ingresso.preco); 80 | } 81 | fprintf(arquivoTemp, "%s %s %f ", ingresso.atracao, ingresso.local, ingresso.preco); 82 | } 83 | 84 | fclose(arquivo); 85 | fclose(arquivoTemp); 86 | 87 | remove(nomeArquivo); 88 | rename("temp.txt", nomeArquivo); 89 | } 90 | -------------------------------------------------------------------------------- /root/TAD/ingresso/ingresso.h: -------------------------------------------------------------------------------- 1 | 2 | // Redefinição do tipo Ingresso 3 | typedef struct ingresso Ingresso; 4 | 5 | void preencherIngresso(char *nomeArquivo); 6 | 7 | void imprimirIngressos(char *nomeArquivo); 8 | 9 | void alterarPreco(char *nomeArquivo, char *atracao); -------------------------------------------------------------------------------- /root/TAD/ingresso/ingressos.txt: -------------------------------------------------------------------------------- 1 | ECOP UFERSA 0.000000 Circo Praca 15.000000 -------------------------------------------------------------------------------- /root/TAD/ingresso/main.c: -------------------------------------------------------------------------------- 1 | #include "ingresso.c" 2 | 3 | int main(void){ 4 | 5 | preencherIngresso("ingressos.txt"); 6 | imprimirIngressos("ingressos.txt"); 7 | alterarPreco("ingressos.txt", "Circo"); 8 | imprimirIngressos("ingressos.txt"); 9 | 10 | 11 | return 0; 12 | } -------------------------------------------------------------------------------- /root/Ufersa.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/Ufersa.png -------------------------------------------------------------------------------- /root/algoritmos-de-busca/README.md: -------------------------------------------------------------------------------- 1 | # Algoritmos de busca 2 | 3 | ## Para que serve os algoritmos de busca? 4 | 5 | Algoritmos de busca são úteis para encontrar um elemento em uma lista. No munda real, podemos usar algoritmos de busca para encontrar um livro em uma biblioteca, um filme em um catálogo de filmes, um produto em um catálogo de produtos, etc. 6 | 7 | Os algortimos de busca são aplicados a sistemas de informação, que são sistemas que armazenam e processam dados. Um sistema de informação pode ser um banco de dados, um catálogo de produtos, um catálogo de filmes, etc. 8 | 9 | ## Como funciona os algoritmos de busca? 10 | 11 | Os algoritmos de busca, normalmente recebem a lista e o elemento que queremos encontrar. O algoritmo de busca percorre a lista e verifica se o elemento que queremos encontrar está na lista. Se o elemento estiver na lista, o algoritmo de busca retorna a posição do elemento na lista. Se o elemento não estiver na lista, o algoritmo de busca retorna um valor que indica que o elemento não foi encontrado. 12 | 13 | ## Exemplo de algoritmos de busca: busca sequencial (linear), busca binária, busca por interpolação, jump search. 14 | 15 | -------------------------------------------------------------------------------- /root/algoritmos-de-busca/binary.c: -------------------------------------------------------------------------------- 1 | // Algoritmo de busca binária 2 | 3 | #include 4 | 5 | int buscaBinaria(int *vetor, int tamanho, int valor) { 6 | int inicio = 0; 7 | int fim = tamanho - 1; 8 | int meio; 9 | while (inicio <= fim) { 10 | meio = (inicio + fim) / 2; 11 | if (vetor[meio] == valor) { 12 | return meio; 13 | } else if (vetor[meio] < valor) { 14 | inicio = meio + 1; 15 | } else { 16 | fim = meio - 1; 17 | } 18 | } 19 | return -1; 20 | } 21 | 22 | int main() { 23 | int vetor[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 24 | int tamanho = sizeof(vetor) / sizeof(int); 25 | int valor = 5; 26 | int posicao = buscaBinaria(vetor, tamanho, valor); 27 | if (posicao == -1) { 28 | printf("Valor não encontrado"); 29 | } else { 30 | printf("Valor encontrado na posição %d", posicao); 31 | } 32 | return 0; 33 | } -------------------------------------------------------------------------------- /root/algoritmos-de-busca/complexity.md: -------------------------------------------------------------------------------- 1 | # Complexidade de Algoritmos 2 | 3 | ## O que é complexidade de algoritmos? 4 | 5 | Complexidade de algoritmos é uma medida de desempenho de um algoritmo. É uma medida de tempo e espaço de memória que um algoritmo consome para executar uma tarefa. 6 | 7 | ## Como medir a complexidade de algoritmos? 8 | 9 | Existem duas formas de medir a complexidade de algoritmos: 10 | 11 | - Tempo de execução 12 | - Espaço de memória 13 | 14 | ### Tempo de execução 15 | 16 | O tempo de execução de um algoritmo é a quantidade de tempo que o algoritmo leva para executar uma tarefa. Para medir o tempo de execução de um algoritmo, é necessário executar o algoritmo com diferentes entradas e calcular o tempo de execução para cada entrada. O tempo de execução de um algoritmo é a soma dos tempos de execução para cada entrada. 17 | 18 | ### Espaço de memória 19 | 20 | O espaço de memória de um algoritmo é a quantidade de memória que o algoritmo consome para executar uma tarefa. Para medir o espaço de memória de um algoritmo, é necessário executar o algoritmo com diferentes entradas e calcular o espaço de memória para cada entrada. O espaço de memória de um algoritmo é a soma dos espaços de memória para cada entrada. 21 | 22 | ## Como calcular a complexidade de algoritmos? 23 | 24 | Existem duas formas de calcular a complexidade de algoritmos: 25 | 26 | - Complexidade de tempo 27 | 28 | - Complexidade de espaço 29 | 30 | ### Complexidade de tempo 31 | 32 | A complexidade de tempo de um algoritmo é denotada por T(n), em que n é o tamanho da entrada. A complexidade de tempo de um algoritmo é a quantidade de tempo que o algoritmo leva para executar uma tarefa com uma entrada de tamanho n. 33 | 34 | Normalmente, utilizamos a notação big-O para denotar a complexidade de tempo de um algoritmo. A notação big-O denota o limite superior da complexidade de tempo de um algoritmo. 35 | 36 | Por exemplo, se T(n) = 2n + 1, então T(n) = O(n). 37 | 38 | ### Exemplo de complexidade de tempo linear: 39 | 40 | ```c 41 | int soma(int n) { 42 | int soma = 0; 43 | for (int i = 0; i < n; i++) { 44 | soma += i; 45 | } 46 | return soma; 47 | } 48 | ``` 49 | 50 | O algoritmo acima calcula a soma dos números de 0 até n-1. A complexidade de tempo de soma(n) é O(n). Pois, o algoritmo executa n operações de soma e n operações de comparação. Já que o algoritmo executa n operações de soma e n operações de comparação, o tempo de execução do algoritmo é proporcional a n. 51 | 52 | A complexidade de espaço de soma(n) é O(1). Pois, o algoritmo consome uma quantidade constante de memória. 53 | 54 | ### Exemplo de complexidade de tempo quadrática: 55 | 56 | ```c 57 | int soma(int n) { 58 | int soma = 0; // c1, 1 vez 59 | for (int i = 0; i < n; i++) { // c2, n vezes 60 | for (int j = 0; j < n; j++) { // c3, n*n vezes 61 | soma += i * j; // c4, n*n vezes 62 | } 63 | } 64 | return soma; // c5 1 vez 65 | } 66 | ``` 67 | 68 | Podemos multiplicar a execução de cada linha pelo tempo que leva para executar essa linha. Então, o tempo total de execução será a soma de todos os tempos de execução de cada linha. 69 | 70 | $$ 71 | T(n) = c1 + c2n + c3n^2 + c4n^2 + c5 72 | $$ 73 | 74 | ou ainda 75 | 76 | $$ 77 | T(n) = (c1 + c5) + c2n + (c3 + c4)n^2 78 | $$ 79 | 80 | Chamamos esse modelo de modelo quadrático porque N está elevado a 2. Algoritmos com complexidade quadrática quadruplicam o tempo de execução quando os dados são duplicados. 81 | 82 | Portanto, o algoritmo acima calcula a soma dos produtos de todos os pares de números de 0 até n-1. A complexidade de tempo de soma(n) é O(n^2). Pois, o algoritmo executa n^2 operações de soma e n^2 operações de comparação. Já que o algoritmo executa n^2 operações de soma e n^2 operações de comparação, o tempo de execução do algoritmo é proporcional a n^2. 83 | 84 | ## Simplificando ainda mais 85 | 86 | Até agora, analisamos algoritmos com apenas algumas linhas de código, para que os cálculos não ficassem extremamente complexos. No entanto, à medida que os algoritmos se tornam mais complicados, esse processo pode se tornar bastante complexo e complicado. 87 | 88 | Além disso, lembre-se de que estamos interessados apenas em ver quanto o tempo de execução cresce à medida que os dados crescem, não o tempo exato de execução. Com isso em mente, podemos simplificar ainda mais nossa análise descartando informações desnecessárias. 89 | 90 | 1. Remova termos constantes 91 | 92 | Seja T(n) = 2n + 1. Podemos remover o termo constante 1, pois ele não afeta o crescimento do tempo de execução. Portanto, T(n) = O(2n). 93 | 94 | 2. Remova constantes multiplicativas 95 | 96 | Seja T(n) = 2n + 1. Podemos remover a constante multiplicativa 2, pois ela não afeta o crescimento do tempo de execução. Portanto, T(n) = O(n). 97 | 98 | 3. Remova termos de menor ordem 99 | 100 | Seja T(n) = n^2 + n. Podemos remover o termo de menor ordem n, pois ele não afeta o crescimento do tempo de execução. Portanto, T(n) = O(n^2). 101 | 102 | 4. Mantenha apenas o termo de maior ordem 103 | 104 | Seja T(n) = n^3 + n^2 + n + 1. Podemos remover todos os termos de menor ordem, pois eles não afetam o crescimento do tempo de execução. Portanto, T(n) = O(n^3). 105 | 106 | 107 | ### Complexidade de espaço 108 | 109 | A complexidade de espaço de um algoritmo é denotada por S(n), em que n é o tamanho da entrada. A complexidade de espaço de um algoritmo é a quantidade de memória que o algoritmo consome para executar uma tarefa com uma entrada de tamanho n. 110 | 111 | Normalmente, utilizamos a notação big-O para denotar a complexidade de espaço de um algoritmo. A notação big-O denota o limite superior da complexidade de espaço de um algoritmo. 112 | 113 | 114 | -------------------------------------------------------------------------------- /root/algoritmos-de-busca/interpolacao.c: -------------------------------------------------------------------------------- 1 | // Algoritmo de Busca por interpolação 2 | 3 | #include 4 | 5 | int buscaInterpolacao(int *vetor, int tamanho, int valor) { 6 | int inicio = 0; 7 | int fim = tamanho - 1; 8 | int meio; 9 | while (inicio <= fim) { 10 | meio = inicio + ((valor - vetor[inicio]) * (fim - inicio)) / (vetor[fim] - vetor[inicio]); 11 | if (vetor[meio] == valor) { 12 | return meio; 13 | } else if (vetor[meio] < valor) { 14 | inicio = meio + 1; 15 | } else { 16 | fim = meio - 1; 17 | } 18 | } 19 | return -1; 20 | } 21 | 22 | int main() { 23 | int vetor[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 24 | int tamanho = sizeof(vetor) / sizeof(int); 25 | int valor = 5; 26 | int posicao = buscaInterpolacao(vetor, tamanho, valor); 27 | if (posicao == -1) { 28 | printf("Valor não encontrado"); 29 | } else { 30 | printf("Valor encontrado na posição %d", posicao); 31 | } 32 | return 0; 33 | } -------------------------------------------------------------------------------- /root/algoritmos-de-busca/jump.c: -------------------------------------------------------------------------------- 1 | // Algoritmo Jump search (busca pulo) 2 | 3 | #include 4 | 5 | int buscaPulo(int *vetor, int tamanho, int valor) { 6 | int i = 0; 7 | int pulo = 2; 8 | while (i < tamanho) { 9 | if (vetor[i] == valor) { 10 | return i; 11 | } else if (vetor[i] > valor) { 12 | int j; 13 | for (j = i - pulo; j < i; j++) { 14 | if (vetor[j] == valor) { 15 | return j; 16 | } 17 | } 18 | return -1; 19 | } 20 | i += pulo; 21 | } 22 | return -1; 23 | } 24 | 25 | int main() { 26 | int vetor[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 27 | int tamanho = sizeof(vetor) / sizeof(int); 28 | int valor = 5; 29 | int posicao = buscaPulo(vetor, tamanho, valor); 30 | if (posicao == -1) { 31 | printf("Valor não encontrado"); 32 | } else { 33 | printf("Valor encontrado na posição %d", posicao); 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /root/algoritmos-de-busca/linear.c: -------------------------------------------------------------------------------- 1 | // Algporitmo de busca linear 2 | 3 | #include 4 | 5 | 6 | int buscaLinear(int *vetor, int tamanho, int valor) { 7 | int i; 8 | for (i = 0; i < tamanho; i++) { 9 | if (vetor[i] == valor) { 10 | return i; 11 | } 12 | } 13 | return -1; 14 | } 15 | 16 | int main() { 17 | int vetor[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 18 | int tamanho = sizeof(vetor) / sizeof(int); 19 | int valor = 5; 20 | int posicao = buscaLinear(vetor, tamanho, valor); 21 | if (posicao == -1) { 22 | printf("Valor não encontrado"); 23 | } else { 24 | printf("Valor encontrado na posição %d", posicao); 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /root/algoritmos-de-busca/struzik.c: -------------------------------------------------------------------------------- 1 | // Algoritmo de Busca exponencial (ou busca struzik/busca a galope) 2 | 3 | #include 4 | 5 | int buscaExponencial(int *vetor, int tamanho, int valor) { // Busca exponencial porque o tamanho do intervalo é dobrado a cada iteração 6 | int i = 1; 7 | while (i < tamanho && vetor[i] <= valor) { // Encontra o intervalo onde o valor pode estar 8 | i *= 2; // Dobro do tamanho do intervalo 9 | } 10 | int j; 11 | for (j = i / 2; j < i; j++) { // Busca linear no intervalo 12 | if (vetor[j] == valor) { // Se o valor for encontrado, retorna a posição 13 | return j; 14 | } 15 | } 16 | return -1; // Se o valor não for encontrado, retorna -1 17 | } 18 | 19 | int main() { 20 | int vetor[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 21 | int tamanho = sizeof(vetor) / sizeof(int); 22 | int valor = 5; 23 | int posicao = buscaExponencial(vetor, tamanho, valor); 24 | if (posicao == -1) { 25 | printf("Valor não encontrado"); 26 | } else { 27 | printf("Valor encontrado na posição %d", posicao); 28 | } 29 | return 0; 30 | } -------------------------------------------------------------------------------- /root/algoritmos-de-busca/time.md: -------------------------------------------------------------------------------- 1 | # Medindo o tempo de execução de um algoritmo em C 2 | 3 | Intuitivamente, podemos dizer que o tempo de execução de um algoritmo é a quantidade de tempo que o algoritmo leva para executar uma tarefa. Para medir o tempo de execução de um algoritmo, é necessário executar o algoritmo com diferentes entradas e calcular o tempo de execução para cada entrada. O tempo de execução de um algoritmo é a soma dos tempos de execução para cada entrada. 4 | 5 | Para medir o tempo de execução de um algoritmo em C, podemos utilizar a função `clock()` do header `time.h`. A função `clock()` retorna o tempo de execução do programa em milissegundos. Para calcular o tempo de execução de um algoritmo, podemos utilizar a seguinte fórmula: 6 | 7 | ```c 8 | double tempo = (double)(clock() - inicio) / CLOCKS_PER_SEC; 9 | ``` 10 | 11 | Onde `inicio` é o tempo de execução do programa antes de executar o algoritmo e `tempo` é o tempo de execução do programa após executar o algoritmo. 12 | 13 | A seguir, temos um exemplo de como medir o tempo de execução de um algoritmo em C: 14 | 15 | ```c 16 | #include 17 | #include 18 | 19 | int main() { 20 | clock_t inicio = clock(); 21 | // Executar o algoritmo 22 | double tempo = (double)(clock() - inicio) / CLOCKS_PER_SEC; 23 | printf("Tempo de execução: %f\n", tempo); 24 | return 0; 25 | } 26 | ``` 27 | 28 | # Analisando o tempo de execução de um algoritmo 29 | 30 | Com o modelo de complexidade de tempo, podemos inserir um comprimento de lista e ter uma ideia do tempo de execução do algoritmo para esse comprimento de entrada sem precisar realmente executar o código. 31 | 32 | ## Modelo de complexidade de tempo 33 | 34 | O modelo de complexidade de tempo é uma representação matemática de um algoritmo. O modelo de complexidade de tempo de um algoritmo é denotado por T(n), em que n é o tamanho da entrada. O modelo de complexidade de tempo de um algoritmo é a quantidade de tempo que o algoritmo leva para executar uma tarefa com uma entrada de tamanho n. 35 | 36 | ## Análise de tempo de execução 37 | 38 | Na análise de tempo de execução, nós não queremos o tempo exato, e sim como o tempo de execução de um algoritmo cresce com o tamanho da entrada. Para analisar o tempo de execução de um algoritmo, podemos utilizar o modelo de complexidade de tempo. 39 | 40 | Exemplo: Soma de todos os números de 1 a n 41 | 42 | ```c 43 | 44 | int soma(int n) { 45 | int soma = 0; //c1 46 | for (int i = 1; i <= n; i++) { //c2 47 | soma += i; //c3 48 | } 49 | return soma; //c4 50 | } 51 | ``` 52 | 53 | Os comentários acima significam que a primeira linha leva algum tempo constante c1 para ser executada. O segundo leva c2 e assim por diante. Então podemos contar quantas vezes cada linha será executada. Isso dependerá do tamanho de n. Vamos denotar esse tamanho por N e escrever a contagem de execução de cada linha na frente dele: 54 | 55 | ```c 56 | int soma(int n) { 57 | int soma = 0; //c1, 1 vez 58 | for (int i = 1; i <= n; i++) { //c2, N vezes 59 | soma += i; //c3, N vezes 60 | } 61 | return soma; //c4, 1 vez 62 | } 63 | ``` 64 | 65 | Podemos multiplicar a execução de cada linha pelo tempo que leva para executar essa linha. Então, o tempo total de execução será a soma de todos os tempos de execução de cada linha. 66 | 67 | $$ 68 | T(n) = c1 + c2N + c3N + c4 69 | $$ 70 | 71 | ou ainda 72 | 73 | $$ 74 | T(n) = (c2 + c3)N + (c1 + c4) 75 | $$ 76 | 77 | Agora, podemos ver que o tempo de execução cresce linearmente com o tamanho da entrada. 78 | 79 | ## [Complexidade de Algoritmos](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/root/algoritmos-de-busca/complexity.md) 80 | -------------------------------------------------------------------------------- /root/algoritmos-de-busca/trabalho.md: -------------------------------------------------------------------------------- 1 | # Requisitos para o desenvolvimento do trabalho com algoritmos de busca e ordenação: 2 | 3 | 1. O trabalho deve ser desenvolvido grupo de 4. 4 | 5 | 2. O trabalho deve ser desenvolvido em qualquer linguagem (C, Python, Java, Javascript, etc). 6 | 7 | 3. O trabalho deve estar disponível em um repositório no GitHub. 8 | 9 | 4. O trabalho deve conter um arquivo README.md com a descrição do trabalho, explicando como o trabalho deve ser executado, e com a descrição dos algoritmos de busca e ordenação que foram implementados, complexidade. Além disso, uma explicação sobre os algoritmos de busca e ordenação que foram implementados deve ser apresentado no arquivo, e com a analise de complexidade. 10 | 11 | 5.1 Explicar a aplicabilidade dos algoritmos de busca e ordenação. 12 | 13 | 5.2 Descrição dos algoritmos de busca e ordenação que foram implementados. 14 | 15 | 5.3 Analise de complexidade dos algoritmos de busca e ordenação que foram implementados. 16 | 17 | # Algoritmos de busca: 18 | 19 | 1. Busca sequencial (linear); 20 | 2. Busca binária; 21 | 3. Busca por interpolação; 22 | 4. Jump search; 23 | 5. Busca Exponencial (Struck). 24 | 25 | # Algoritmos de ordenação: 26 | 27 | 1. Bubble Sort; 28 | 2. Insertion Sort; 29 | 3. Selection Sort; 30 | 4. Comb Sort; 31 | 5. Gnome Sort. 32 | 33 | -------------------------------------------------------------------------------- /root/arquivos/Lista-para-treino/Lista-para-treino-Arquivos.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/arquivos/Lista-para-treino/Lista-para-treino-Arquivos.pdf -------------------------------------------------------------------------------- /root/arquivos/Lista-para-treino/README.md: -------------------------------------------------------------------------------- 1 | # Manipulação de arquivos na linguagem C (Problemas para treino) 2 | 3 | ↩️ [Volte para pasta principal](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/arquivos) 4 | 5 | 1. Prática ✅[(clique aqui para ver as questões)](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/arquivos/Lista-para-treino/Lista-para-treino-Arquivos.pdf): 6 | 1️⃣ [Acesse a resposta da questão 1](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/arquivos/Lista-para-treino/quest-1.c) 7 | 8 | 2️⃣ [Acesse a resposta da questão 2](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/arquivos/Lista-para-treino/quest-2.c) 9 | -------------------------------------------------------------------------------- /root/arquivos/Lista-para-treino/entrada_ex1.txt: -------------------------------------------------------------------------------- 1 | Aline 2 | Pedro 3 | Sofia 4 | Alberto 5 | 6 | -------------------------------------------------------------------------------- /root/arquivos/Lista-para-treino/entrada_ex2.txt: -------------------------------------------------------------------------------- 1 | 4 2 | A1 Ana A 800 3 | A2 Beatriz A 800.50 4 | A3 Beatrize A 800.50 5 | A4 Joao B 800.50 6 | 7 | -------------------------------------------------------------------------------- /root/arquivos/Lista-para-treino/quest-1.c: -------------------------------------------------------------------------------- 1 | #include // Biblioteca que define as funções de entrada e saída fopen, fclose, fprintf, fscanf, etc. 2 | #include // exit() 3 | #include // Biblioteca que define funções para manipulação de strings 4 | 5 | 6 | /*Escreva um programa que preencha um vetor (strings) 7 | com informações vindas de um arquivo de entrada */ 8 | 9 | 10 | int main(void) { 11 | 12 | char* nomes[4]; // Vetor de strings para armazenar os nomes 13 | char nome[21]; // Variavel para armazenar o nome lido do arquivo 14 | char linha[100]; // Variavel para armazenar a linha lida do arquivo 15 | 16 | FILE * arquivo_de_entrada; // Variavel para armazenar o ponteiro do arquivo de entrada 17 | int i, n; // Variaveis para controle do laço de repetição 18 | i=0; // Inicializando a variavel i com 0 19 | 20 | arquivo_de_entrada = fopen("entrada_ex1.txt", "rt"); // Abrindo o arquivo de entrada para leitura 21 | if (arquivo_de_entrada == NULL) { // Verifica se o arquivo foi aberto corretamente 22 | printf("Não encontrado\n"); // Caso o arquivo não seja encontrado, imprime a mensagem "Não encontrado" 23 | exit(1); 24 | } 25 | 26 | /* preencha um vetor (strings) com informações vindas de um arquivo de entrada */ 27 | while(fgets(linha, 100, arquivo_de_entrada) !=NULL){ // Enquanto houver linhas no arquivo de entrada 28 | 29 | sscanf(linha, "%20[^\n]", nome); // Lê a linha do arquivo de entrada e armazena no vetor nome 30 | n = strlen(nome); // Armazena o tamanho da string nome na variavel n 31 | nomes[i] = (char*) malloc((n+1)*sizeof(char)); // Alocando memoria para o vetor nomes 32 | strcpy(nomes[i], nome); // Copia a string nome para o vetor nomes 33 | i++; // Incrementa o contador i 34 | 35 | } 36 | 37 | fclose(arquivo_de_entrada); // Fecha o arquivo de entrada 38 | 39 | /*imprima cada elemento do vetor na saída padrão*/ 40 | for(i=0; i<4; i++){ // Laço de repetição para imprimir os nomes do vetor nomes 41 | printf(" %s \t", nomes[i]); // Imprime o nome do vetor nomes 42 | } 43 | 44 | return 0; // Retorna 0 para o sistema operacional 45 | 46 | } -------------------------------------------------------------------------------- /root/arquivos/Lista-para-treino/quest-2.c: -------------------------------------------------------------------------------- 1 | /* 2 | escrever um programa em C que, dado o arquivo com a relação de funcionários, 3 | imprima o valor gasto com a folha de pagamento para um determinado departamento. 4 | Os dados dos funcionários da empresa devem ser fornecidos para um vetor, 5 | de modo que uma função que execute tal tarefa deve ser implementada, obedecendo ao protótipo: 6 | 7 | void copia_dados(FILE* fl, int n, Funcionario** pessoal); 8 | */ 9 | 10 | 11 | #include // printf, scanf, fopen, fclose 12 | #include // malloc, free 13 | #include // strcpy 14 | 15 | typedef struct funcionario{ 16 | char nome[21]; 17 | char departamento; 18 | float salario; 19 | char funcional[11]; 20 | }Funcionario; 21 | 22 | void copia_dados(FILE* fl, int n, Funcionario** pessoal); // protótipo da função que copia os dados do arquivo para o vetor de ponteiro pessoal 23 | void imprime_folha_pagamento(int n, Funcionario** pessoal, char depto); // protótipo da função que imprime a folha de pagamento de um determinado departamento 24 | 25 | // função principal 26 | int main(void) { 27 | 28 | char linha[100]; // Variavel para armazenar a linha lida do arquivo 29 | int n; // Variavel para armazenar o numero de funcionarios 30 | Funcionario** pessoal; // Ponteiro para a estrutura Funcionario 31 | FILE * arquivo_de_entrada; // Variavel para armazenar o ponteiro do arquivo de entrada 32 | int i; // Variavel para controle do laço de repetição 33 | i=0; // Inicializando a variavel i com 0 34 | 35 | arquivo_de_entrada = fopen("entrada_ex2.txt", "rt"); // Abrindo o arquivo de entrada para leitura 36 | if (arquivo_de_entrada == NULL) { // Verifica se o arquivo foi aberto corretamente 37 | printf("Não encontrado\n"); // Caso o arquivo não seja encontrado, imprime a mensagem "Não encontrado" 38 | exit(1); 39 | } 40 | 41 | fgets(linha, 100, arquivo_de_entrada); // Lê a primeira linha do arquivo de entrada que contém o numero de funcionarios ao todo na empresa 42 | sscanf(linha, "%d", &n); // Lê a linha do arquivo de entrada e armazena o valor em n 43 | printf("Numero de funcionarios: %d\n", n); // Imprime o numero de funcionarios 44 | 45 | pessoal = (Funcionario**) malloc(n*sizeof(Funcionario*)); // Alocando memoria para o vetor pessoal 46 | for(i=0; ifuncional, pessoal[i-1]->nome, &pessoal[i-1]->departamento, &pessoal[i-1]->salario); // Lê a linha do arquivo de entrada e armazena nos parametros da estrutura funcionario 76 | } 77 | i++; // Incrementa a variavel i 78 | } 79 | } 80 | 81 | 82 | /* 83 | implementar uma função que imprime o valor gasto para um determinado departamento. 84 | Esta função deve obedecer ao seguinte protótipo: 85 | void imprime_folha_pagamento(int n, Funcionario** pessoal, char depto); 86 | */ 87 | 88 | void imprime_folha_pagamento(int n, Funcionario** pessoal, char depto){ 89 | 90 | int i=0; // Variavel para controle do laço de repetição e Inicializando a variavel i com 0 91 | 92 | printf("\nFolha de pagamento do departamento %c\n", depto); //mensagem 93 | printf("Funcional\tNome\t\tDepartamento\tSalario\n"); //mensagem 94 | 95 | while(idepartamento), &(depto)) == 0){ // Verifica se o departamento é igual ao depto 97 | printf("%s\t\t%s\t\t%c\t\t%.2f\n", pessoal[i]->funcional, pessoal[i]->nome, pessoal[i]->departamento, pessoal[i]->salario); // Imprime os dados do funcionario 98 | } 99 | i++; // Incrementa a variavel i 100 | } 101 | } -------------------------------------------------------------------------------- /root/arquivos/aula-pratica-02-lab/quest-1.c: -------------------------------------------------------------------------------- 1 | /* 2 | 1) Faça um programa em C que solicita ao usuário informações de funcionários via teclado. 3 | As informações digitadas pelo o usuário são: id, nome e salário do funcionário. 4 | Armazene as informações digitadas pelo usuário em um arquivo texto. 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | typedef struct functionario{ 12 | int id; 13 | char nome[50]; 14 | float salario; 15 | } Funcionario; 16 | 17 | int main() { 18 | 19 | Funcionario funcionario; 20 | FILE *arquivo; 21 | char nomeArquivo[50]; 22 | 23 | printf("Digite o nome do arquivo: "); 24 | scanf("%s", nomeArquivo); 25 | 26 | arquivo = fopen(nomeArquivo, "w"); 27 | if (arquivo == NULL) { 28 | printf("Erro ao abrir o arquivo!"); 29 | exit(1); 30 | } 31 | 32 | printf("Digite o id do funcionario: "); 33 | scanf("%d", &funcionario.id); 34 | printf("Digite o nome do funcionario: "); 35 | scanf(" %[^\n]", funcionario.nome); 36 | printf("Digite o salario do funcionario: "); 37 | scanf("%f", &funcionario.salario); 38 | 39 | fprintf(arquivo, "%d %s %f", funcionario.id, funcionario.nome, funcionario.salario); 40 | 41 | fclose(arquivo); 42 | 43 | return 0; 44 | 45 | } 46 | -------------------------------------------------------------------------------- /root/arquivos/aula-pratica-02-lab/quest-2.c: -------------------------------------------------------------------------------- 1 | /* 2 | Implemente um programa em C para ler o nome e as notas de um número N de 3 | alunos e armazená-los em um arquivo 4 | */ 5 | #include 6 | #include 7 | 8 | typedef struct aluno{ 9 | char nome[50]; 10 | float nota1; 11 | float nota2; 12 | float nota3; 13 | } Aluno; 14 | 15 | int main() { 16 | 17 | FILE *arquivo; 18 | char nomeArquivo[50]; 19 | int n; 20 | //Solicita ao usuario para digitar o nome do arquivo 21 | printf("Digite o nome do arquivo: "); 22 | scanf(" %[^\n]", nomeArquivo); 23 | // Abrindo o arquivo 24 | arquivo = fopen(nomeArquivo, "w"); 25 | if (arquivo == NULL) { 26 | printf("Erro ao abrir o arquivo!"); 27 | exit(1); 28 | } 29 | 30 | printf("Digite o numero de alunos: "); 31 | scanf("%d", &n); 32 | Aluno *aluno = (Aluno*) malloc(n*sizeof(Aluno)); 33 | 34 | int i; 35 | for (i = 0; i < n; i++) { 36 | printf("Digite o nome do aluno: "); 37 | scanf("%s", aluno[i].nome); 38 | printf("Digite a nota 1 do aluno: "); 39 | scanf("%f", &aluno[i].nota1); 40 | printf("Digite a nota 2 do aluno: "); 41 | scanf("%f", &aluno[i].nota2); 42 | printf("Digite a nota 3 do aluno: "); 43 | scanf("%f", &aluno[i].nota3); 44 | 45 | fprintf(arquivo, "%s\t%f\t%f\t%f\n", aluno[i].nome, aluno[i].nota1, aluno[i].nota2, aluno[i].nota3); 46 | } 47 | 48 | fclose(arquivo); 49 | free(aluno); 50 | return 0; 51 | 52 | } -------------------------------------------------------------------------------- /root/arquivos/aula-pratica-02-lab/quest-3.c: -------------------------------------------------------------------------------- 1 | /* 2 | Implemente um programa em C para ler o nome e as notas de um número N de 3 | alunos e armazená-los em um arquivo 4 | */ 5 | #include 6 | #include 7 | 8 | typedef struct aluno{ 9 | char nome[50]; 10 | float nota1; 11 | float nota2; 12 | float nota3; 13 | } Aluno; 14 | 15 | int main() { 16 | 17 | FILE *arquivo; 18 | char nomeArquivo[50]; 19 | int n; 20 | //Solicita ao usuario para digitar o nome do arquivo 21 | printf("Digite o nome do arquivo: "); 22 | scanf(" %[^\n]", nomeArquivo); 23 | // Abrindo o arquivo no modo de anexar 24 | arquivo = fopen(nomeArquivo, "a"); 25 | if (arquivo == NULL) { 26 | printf("Erro ao abrir o arquivo!"); 27 | exit(1); 28 | } 29 | 30 | printf("Digite o numero de alunos: "); 31 | scanf("%d", &n); 32 | Aluno *aluno = (Aluno*) malloc(n*sizeof(Aluno)); 33 | 34 | int i; 35 | for (i = 0; i < n; i++) { 36 | printf("Digite o nome do aluno: "); 37 | scanf("%s", aluno[i].nome); 38 | printf("Digite a nota 1 do aluno: "); 39 | scanf("%f", &aluno[i].nota1); 40 | printf("Digite a nota 2 do aluno: "); 41 | scanf("%f", &aluno[i].nota2); 42 | printf("Digite a nota 3 do aluno: "); 43 | scanf("%f", &aluno[i].nota3); 44 | 45 | fprintf(arquivo, "%s\t%f\t%f\t%f\n", aluno[i].nome, aluno[i].nota1, aluno[i].nota2, aluno[i].nota3); 46 | } 47 | 48 | fclose(arquivo); 49 | free(aluno); 50 | return 0; 51 | 52 | } -------------------------------------------------------------------------------- /root/arquivos/entrada_lista1_ex2.txt: -------------------------------------------------------------------------------- 1 | 10 2 | 2 3 | 8 4 | 1 5 | 12 6 | 8 7 | 10 8 | 5 9 | 4 10 | 19 -------------------------------------------------------------------------------- /root/arquivos/entrada_q3.txt: -------------------------------------------------------------------------------- 1 | Amanda 7.0 6.5 9.0 2 | Alberto 5.0 7.0 3.5 3 | Jane 8.0 6.8 4.5 4 | Igor 9.0 9.0 8.5 5 | Samara 10.0 10.0 7.0 6 | Maria Luiza 10.0 10.0 10.0 7 | Cesar 10.0 9.0 8.0 8 | Pedro Felipe 7.0 7.0 7.0 -------------------------------------------------------------------------------- /root/arquivos/manipular_arquivos.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | /* 4 | - O que veremos? 5 | - Como manipular arquivos em C; 6 | - Funções para manipular arquivos (fechar, abrir, ler e escrever); 7 | 8 | - Funções para abrir arquivos 9 | FILE * fopen(char * nome_arquivo, char * modo_abertura); 10 | - nome_arquivo: nome do arquivo que será aberto; 11 | - modo_abertura: modo de abertura do arquivo; 12 | - r: leitura; 13 | - w: escrita; 14 | - a: anexar; 15 | - r+: leitura e escrita; 16 | - w+: escrita e leitura; 17 | - a+: anexar e leitura; 18 | - b: modo binário; 19 | - t: modo texto; 20 | - +: atualização; 21 | 22 | - Funções para fechar arquivos 23 | int fclose(FILE * arquivo); 24 | - arquivo: ponteiro para o arquivo que será fechado; 25 | 26 | - Funções para escrever em arquivos 27 | int fputc(int caractere, FILE * arquivo); 28 | - caractere: caractere que será escrito no arquivo; 29 | - arquivo: ponteiro para o arquivo que será escrito; 30 | int fputs(char * string, FILE * arquivo); 31 | - string: string que será escrita no arquivo; 32 | - arquivo: ponteiro para o arquivo que será escrito; 33 | int fprintf(FILE * arquivo, char * formato, ...); 34 | - arquivo: ponteiro para o arquivo que será escrito; 35 | - formato: formato da string que será escrita no arquivo; 36 | - ...: argumentos que serão escritos no arquivo; 37 | 38 | - Funções para ler dados: 39 | int fscanf (FILE* fp, char* formato, ...); 40 | - fp: ponteiro para o arquivo que será lido; 41 | - formato: formato da string que será lida do arquivo; 42 | - ...: variáveis que receberão os dados lidos do arquivo; 43 | 44 | int fgetc (FILE* fp); 45 | - fp: ponteiro para o arquivo que será lido; 46 | - retorna: caractere lido do arquivo; 47 | 48 | char* fgets (char* s, int n, FILE* fp); 49 | - s: string que receberá os dados lidos do arquivo; 50 | - n: tamanho máximo da string; 51 | - fp: ponteiro para o arquivo que será lido; 52 | - retorna: string lida do arquivo; 53 | */ 54 | 55 | int main() { 56 | 57 | // Abrindo um arquivo 58 | FILE *arquivo = fopen("arquivo.txt", "w"); 59 | if(arquivo==NULL) { 60 | printf("Erro ao abrir o arquivo!"); 61 | exit(1); 62 | } 63 | 64 | // Escrevendo no arquivo 65 | fputs("ABC", arquivo); 66 | //fputc('A', arquivo); 67 | 68 | // Fechando um arquivo 69 | fclose(arquivo); 70 | 71 | return 0; 72 | } -------------------------------------------------------------------------------- /root/arquivos/pratica-01-questao-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | int main(void){ 6 | 7 | FILE * arquivo_entrada, * arquivo_saida; 8 | float nota1, nota2, nota3, media=0; 9 | char nome[100], linha[100]; 10 | 11 | //Abrir o arquivo de entrada apenas para leitura (r) 12 | arquivo_entrada = fopen("entrada_q3.txt", "r"); 13 | if(arquivo_entrada == NULL){ 14 | printf("Erro ao abrir o arquivo"); 15 | exit(1); 16 | } 17 | 18 | //Abrir/criar o arquivo de saida para escrita (w) 19 | arquivo_saida = fopen("saida_q3.txt", "w"); 20 | if(arquivo_saida==NULL){ 21 | printf("Erro ao abrir o arquivo"); 22 | exit(1); 23 | } 24 | 25 | //Ler os dados do arquivo de entrada 26 | while(fgets(linha,100,arquivo_entrada) != NULL){ 27 | sscanf(linha, "%20[^\t]\t%f\t%f\t%f", nome, ¬a1, ¬a2, ¬a3); 28 | media = (nota1 + nota2 + nota3)/3; 29 | 30 | // Escreve no arquivo de saida os dados de nome, media e aprovado/reprovado 31 | fprintf(arquivo_saida, "%s\t%.1f\t %s\n", nome, media, (media>=7.0)?"aprovado":"reprovado"); 32 | 33 | } 34 | // Fecha os arquivos abertos 35 | fclose(arquivo_entrada); 36 | fclose(arquivo_saida); 37 | 38 | return 0; 39 | } -------------------------------------------------------------------------------- /root/arquivos/pratica-01-questao-2.c: -------------------------------------------------------------------------------- 1 | #include // Biblioteca padrão de entrada e saída 2 | #include // exit() 3 | 4 | int main(void){ 5 | 6 | char linha[100]; //Para armazenar a linha de entrada do arquivo 7 | int v[10]; // Vetor para armaenar os valores lidos do arquivo 8 | FILE * arq, *arq1; //Variaveis para armazenar o ponteiro do arquivo 9 | int n=0; // contador para acessar os dados do vetor v 10 | float media =0; // variavel para armazenar a media dos valores do vetor v 11 | 12 | //Abrindo o arquivo de entrada para leitura 13 | arq = fopen("entrada_lista1_ex2.txt", "rt"); 14 | if (arq == NULL) { 15 | printf("Não encontrado\n"); 16 | exit(1); 17 | } 18 | 19 | // Cria o arquivo de saida para escrita 20 | arq1 = fopen("saida_lista1_ex2.txt", "wt"); 21 | if (arq1 == NULL) { 22 | printf("ERRO\n"); 23 | exit(1); 24 | } 25 | 26 | // Ler os dados do arquivo de entrada 27 | while (fgets(linha,100,arq) != NULL){ 28 | // Passando os dados do vetor linha para o vetor v 29 | sscanf(linha, "%d ", &v[n]); 30 | // Somando os valores do vetor v e armazenando em media 31 | media+=v[n]; 32 | // Incrementando o contador n para acessar o proximo elemento do vetor v 33 | n++; 34 | } 35 | 36 | // Encontrar o maior e menor elemento do vetor v 37 | int menor = v[0]; //Variavel para guardar o menor 38 | int maior = v[0]; // Variavel para guardar o maior 39 | 40 | // Laço de repetição for para encontrar o maior e menor elemento do vetor v 41 | for(n=0; n<10; n++){ 42 | // Verifica se o elemento do vetor v é menor que o valor armazenado em menor 43 | if(v[n] < menor) 44 | menor = v[n]; 45 | // Verifica se o elemento do vetor v é maior que o valor armazenado em maior 46 | if(v[n] > maior) 47 | maior = v[n]; 48 | } 49 | // Escrever no arquivo de saida 50 | fprintf(arq1, " menor elemento: %d\n maior elemento: %d \n media dos elementos %f ", menor, maior, media/10); 51 | fclose(arq); 52 | return 0; 53 | } -------------------------------------------------------------------------------- /root/arquivos/questões-prática-01-arquivos.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/arquivos/questões-prática-01-arquivos.pdf -------------------------------------------------------------------------------- /root/estruturas/ContaBancaria.c: -------------------------------------------------------------------------------- 1 | #include 2 | /* 3 | Crie um tipo estruturado para armazenar dados de uma conta bancária. Uma estrutura deste tipo possui os 4 | seguintes campos: nome do cliente, saldo e número. 5 | */ 6 | typedef struct conta { 7 | char nome[50]; 8 | float saldo; 9 | int numero; 10 | } ContaBancaria; 11 | 12 | /* 13 | Escreva uma função que receba como parâmetro o endereço de uma estrutura do tipo ContaBancária e 14 | preencha seus campos com valores fornecidos pelo usuário via teclado. 15 | */ 16 | 17 | void preencheConta(ContaBancaria *conta) { 18 | printf("Digite o nome do cliente: "); 19 | scanf(" %[^\n]", &conta->nome); 20 | printf("Digite o saldo da conta: "); 21 | scanf("%f", &conta->saldo); 22 | printf("Digite o numero da conta: "); 23 | scanf("%d", &conta->numero); 24 | } 25 | 26 | /* 27 | Escreva uma função que receba como parâmetro o endereço 28 | de uma estrutura do tipo ContaBancária e imprima os valores dos seus campos. 29 | */ 30 | 31 | void imprime(ContaBancaria *conta) { 32 | printf("Nome do cliente: %s, saldo: %.2f, numero: %d ", conta->nome, conta->saldo, conta->numero); 33 | } 34 | 35 | /* 36 | Implemente uma função para realizar um depósito em 37 | uma estrutura do tipo ContaBancaria. 38 | */ 39 | 40 | void deposito(ContaBancaria *conta, float valor) { 41 | conta->saldo += valor; 42 | } 43 | 44 | /* 45 | Escreva uma função que receba como parâmetro um vetor de estruturas 46 | do tipo ContaBancária imprima o nome do cliente com menor saldo e o nome do cliente com maior saldo. 47 | */ 48 | 49 | void maiorMenor(ContaBancaria *contas, int tam) { 50 | int i, maior = 0, menor = 0; 51 | for (i = 0; i < tam; i++) { 52 | if (contas[i].saldo > contas[maior].saldo) { 53 | maior = i; 54 | } 55 | if (contas[i].saldo < contas[menor].saldo) { 56 | menor = i; 57 | } 58 | } 59 | printf("\nCliente com maior saldo: %s,\nCliente com menor saldo: %s", contas[maior].nome, contas[menor].nome); 60 | } 61 | 62 | /*Implemente a função main para testar todas as demais funções declaradas nos itens anteriores*/ 63 | 64 | int main(void){ 65 | 66 | int n; 67 | printf("Quantas contas deseja cadastrar? "); 68 | scanf("%d", &n); 69 | 70 | ContaBancaria contas[n]; 71 | int i; 72 | 73 | for (i = 0; i < n; i++) { 74 | preencheConta(&contas[i]); 75 | } 76 | for (i = 0; i < n; i++) { 77 | imprime(&contas[i]); 78 | } 79 | deposito(&contas[0], 100); 80 | maiorMenor(contas, n); 81 | return 0; 82 | } 83 | -------------------------------------------------------------------------------- /root/estruturas/README.md: -------------------------------------------------------------------------------- 1 | # Estruturas de dados na linguagem C 2 | 3 | ## O que é uma estrutura de dados? 4 | 5 | Uma estrutura de dados é uma forma de organizar dados em um programa. 6 | 7 | ## Para que serve? 8 | 9 | Estruturas de dados são úteis para organizar dados de forma que seja fácil acessá-los. 10 | 11 | ## Como funciona? 12 | 13 | Estruturas de dados são definidas através de structs. 14 | 15 | ```c 16 | 17 | struct pessoa { 18 | char nome[50]; 19 | int idade; 20 | }; 21 | 22 | ``` 23 | 24 | ## Acesso aos valores de uma estrutura 25 | 26 | Para acessar os valores de uma estrutura, basta usar o operador de acesso (.) e o nome da variável. 27 | 28 | ```c 29 | 30 | struct pessoa p; 31 | 32 | p.idade = 20; 33 | p.nome = "João"; 34 | 35 | ``` 36 | 37 | ## Acesso ao endereço de uma estrutura 38 | 39 | Para acessar o endereço de uma estrutura, basta colocar um & antes do nome da variável. 40 | 41 | ```c 42 | 43 | struct pessoa p; 44 | 45 | printf("%d", &p); 46 | 47 | ``` 48 | 49 | ## Ponteiros e Estruturas 50 | 51 | Uma estrutura é um ponteiro para a primeira variável da estrutura. 52 | 53 | ```c 54 | 55 | struct pessoa p; 56 | 57 | struct pessoa *p = &p; 58 | 59 | printf("%d", *p); 60 | 61 | ``` 62 | 63 | ## Alocação Dinâmica de Estruturas 64 | 65 | Para alocar dinamicamente uma estrutura, basta usar a função malloc. 66 | 67 | ```c 68 | 69 | struct pessoa *p = malloc(sizeof(struct pessoa)); 70 | 71 | p->idade = 20; 72 | p->nome = "João"; 73 | 74 | printf("%d", p->idade); 75 | 76 | ``` 77 | 78 | ## Desalocação de Estruturas 79 | 80 | Para desalocar uma estrutura, basta usar a função free. 81 | 82 | ```c 83 | 84 | struct pessoa *p = malloc(sizeof(struct pessoa)); 85 | 86 | free(p); 87 | 88 | ``` 89 | 90 | ## Exercícios 91 | 92 | 93 | ![](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/estruturas/struct.png) 94 | 95 | 96 | ## Questões 97 | 98 | 1) Crie um tipo estruturado para representar uma conta bancária, cujos campos são: o nome do 99 | cliente, o número da conta e um saldo. Crie uma variável do tipo estrutura e escreva instruções 100 | para inicializar seus campos. Em seguida, implemente uma função para realizar um depósito em 101 | uma estrutura do tipo struct contaBancaria. Sua função deve obedecer ao seguinte protótipo: 102 | void deposita(float valor, struct contaBancaria* conta); [Acessar resposta](https://github.com/roscibely/algorithms-and-data-structure/blob/main/estruturas/conta-bancaria.c) 103 | -------------------------------------------------------------------------------- /root/estruturas/aninhamento.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef union documento { 5 | int cpf; 6 | int rg; 7 | }Documento; 8 | 9 | typedef struct disciplina { 10 | char nome[50]; 11 | int codigo; 12 | int carga_horaria; 13 | } Disciplina; 14 | 15 | typedef struct aluno { 16 | char nome[50]; 17 | int matricula; 18 | Documento documento; 19 | Disciplina *disciplina; 20 | } Aluno; 21 | 22 | 23 | Disciplina * aloca_disciplina(int num_disciplinas) { 24 | Disciplina *disciplina = (Disciplina *) malloc(num_disciplinas*sizeof(Disciplina)); 25 | if (disciplina == NULL){ 26 | exit(1); 27 | } 28 | return disciplina; 29 | } 30 | 31 | Aluno * aloca_aluno() { 32 | Aluno *aluno = (Aluno *) malloc(sizeof(Aluno)); 33 | if (aluno == NULL) 34 | { 35 | exit(1); 36 | } 37 | aluno->disciplina = aloca_disciplina(1); 38 | return aluno; 39 | } 40 | 41 | void inicializar_aluno(Aluno *aluno) { 42 | printf("Digite o nome do aluno: "); 43 | scanf(" %[^\n]", aluno->nome); 44 | printf("Digite a matricula do aluno: "); 45 | scanf("%d", &aluno->matricula); 46 | printf("Digite o cpf do aluno: "); 47 | scanf("%d", &aluno->documento.cpf); 48 | printf("Digite o nome da disciplina: "); 49 | scanf("%s", aluno->disciplina->nome); 50 | printf("Digite o codigo da disciplina: "); 51 | scanf("%d", &aluno->disciplina->codigo); 52 | printf("Digite a carga horaria da disciplina: "); 53 | scanf("%d", &aluno->disciplina->carga_horaria); 54 | } 55 | 56 | void imprime_aluno(Aluno *aluno){ 57 | printf(" Nome do aluno: %s, Matricula: %d, CPF: %d ", aluno->nome, aluno->matricula, aluno->documento.cpf); 58 | printf(" Nome da disciplina: %s, Codigo: %d, Carga Horaria: %d ", aluno->disciplina->nome, aluno->disciplina->codigo, aluno->disciplina->carga_horaria); 59 | } 60 | 61 | int main(void){ 62 | Aluno *aluno = aloca_aluno(); 63 | inicializar_aluno(aluno); 64 | imprime_aluno(aluno); 65 | return 0; 66 | } 67 | -------------------------------------------------------------------------------- /root/estruturas/conta-bancaria.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | //Definição da struct Conta 6 | typedef struct Conta{ 7 | /*int num: numero da conta 8 | char cliente[]: nome do cliente 9 | float saldo: saldo da conta */ 10 | int num; 11 | char cliente[81]; 12 | float saldo; 13 | }ContaBancaria; 14 | 15 | 16 | void inicializa(ContaBancaria*CONTA){ 17 | /*Função para inicializar a CONTA */ 18 | CONTA = NULL; 19 | } 20 | 21 | void deposita(float valor, ContaBancaria*conta){ 22 | /*Função que incrementa o saldo da conta 23 | float valor: valor a ser incrementado na conta 24 | ContaBancaria * conta: ponteiro para a estrutura do tipo ContaBancaria */ 25 | conta->saldo=+valor; 26 | } 27 | 28 | int main(void){ 29 | /*Função principal */ 30 | 31 | // Alocação dinâmica de um ponteiro do tipo ContaBancaria 32 | ContaBancaria *Conta; 33 | Conta = (ContaBancaria *) malloc(sizeof(ContaBancaria)); 34 | 35 | //inicializa(Conta); 36 | Conta->saldo = 4000.00; 37 | Conta->num = 7863; 38 | deposita(1000, Conta); 39 | 40 | strcpy(Conta->cliente,"Fulano"); 41 | 42 | printf("Novo saldo: %.2f \n", Conta->saldo); 43 | 44 | free(Conta); // Libera o espaço de memoria alocado para o ponteiro Conta 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /root/estruturas/enum/README.md: -------------------------------------------------------------------------------- 1 | # Enum 2 | 3 | ## Definição 4 | 5 | A estrutura de dados enum é uma estrutura de dados que permite armazenar um conjunto de valores inteiros. A estrutura de dados enum é definida da seguinte forma: 6 | 7 | ```c 8 | enum nome_da_enum { 9 | valor1, 10 | valor2, 11 | ... 12 | valorn 13 | }; 14 | ``` 15 | 16 | ### Exemplo de declaração de enum: 17 | 18 | ```c 19 | enum dias_semana { 20 | SEGUNDA, 21 | TERCA, 22 | QUARTA, 23 | QUINTA, 24 | SEXTA, 25 | SABADO, 26 | DOMINGO 27 | }; 28 | ``` 29 | 30 | No exemplo acima, a variável dias_semana pode armazenar os valores inteiros 0, 1, 2, 3, 4, 5 e 6. O valor 0 é atribuído ao valor SEGUNDA, o valor 1 é atribuído ao valor TERCA, o valor 2 é atribuído ao valor QUARTA, o valor 3 é atribuído ao valor QUINTA, o valor 4 é atribuído ao valor SEXTA, o valor 5 é atribuído ao valor SABADO e o valor 6 é atribuído ao valor DOMINGO. 31 | 32 | 33 | ### Exemplo de declaração de enum: 34 | ![](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/estruturas/enum/enum.png) 35 | 36 | 37 | ### Exemplo 38 | 39 | ```c 40 | #include 41 | 42 | enum dias_semana { 43 | SEGUNDA, 44 | TERCA, 45 | QUARTA, 46 | QUINTA, 47 | SEXTA, 48 | SABADO, 49 | DOMINGO 50 | }; 51 | 52 | int main() { 53 | enum dias_semana dia; 54 | dia = SEGUNDA; 55 | printf("Dia da semana: %d\n", dia); 56 | return 0; 57 | } 58 | ``` 59 | 60 | Neste exemplo, a variável dia é declarada como um tipo enum dias_semana. A variável dia é inicializada com o valor SEGUNDA. O valor de dia é impresso na tela. O valor de dia é 0, pois o valor SEGUNDA é 0. -------------------------------------------------------------------------------- /root/estruturas/enum/enum.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/estruturas/enum/enum.png -------------------------------------------------------------------------------- /root/estruturas/enum/exemplo-enum.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef enum boolean { 4 | false, 5 | true 6 | }bool; 7 | 8 | typedef enum response { 9 | no, 10 | yes 11 | }response; 12 | 13 | 14 | int main(void){ 15 | 16 | bool var; 17 | printf("Digite true ou false: "); 18 | scanf("%d", &var); 19 | 20 | if(var==false){ 21 | printf("Is false"); 22 | } 23 | else{ 24 | printf("Is true"); 25 | } 26 | 27 | 28 | response r; 29 | r=yes; 30 | printf("%d", yes); 31 | 32 | return 0; 33 | } -------------------------------------------------------------------------------- /root/estruturas/exemplo-pessoa.c: -------------------------------------------------------------------------------- 1 | #include 2 | /* 3 | Crie um tipo estruturado para armazenar dados de uma pessoa. 4 | Uma estrutura deste tipo possui os seguintes campos: nome da pessoa, numero do documento e idade. 5 | */ 6 | 7 | typedef struct pessoa { 8 | char nome[50]; 9 | int idade; 10 | int documento; 11 | }Pessoa; 12 | 13 | /* 14 | Escreva uma função que receba como parâmetro o endereço de uma estrutura do tipo Pessoa e 15 | preencha seus campos com valores fornecidos pelo usuário via teclado. 16 | */ 17 | 18 | void preenchePessoa(Pessoa *pessoa) { 19 | printf("Digite o nome da pessoa: "); 20 | scanf(" %[^\n]", &pessoa->nome); 21 | printf("Digite a idade da pessoa: "); 22 | scanf("%d", &pessoa->idade); 23 | printf("Digite o numero do documento: "); 24 | scanf("%d", &pessoa->documento); 25 | } 26 | 27 | /* 28 | Escreva uma função que receba como parâmetro o endereço de uma estrutura do tipo Pessoa 29 | e imprima os valores dos seus campos. 30 | */ 31 | 32 | void imprime(Pessoa *pessoa) { 33 | printf("Nome da pessoa: %s, idade: %d, documento: %d ", pessoa->nome, pessoa->idade, pessoa->documento); 34 | } 35 | 36 | /* 37 | Implemente uma função para realizar uma atualização da idade de uma estrutura do tipo Pessoa. 38 | */ 39 | 40 | void atualizaIdade(Pessoa *pessoa, int novaidade) { 41 | pessoa->idade = novaidade; 42 | } 43 | 44 | /*Escreva uma função que receba como parâmetro um vetor de estruturas 45 | do tipo Pessoa e imprima o nome da Pessoa mais velha e mais nova. */ 46 | 47 | void maisVelhaMaisNova(Pessoa *pessoas, int tam) { 48 | int i, maisvelha = 0, maisnova = 0; 49 | for (i = 0; i < tam; i++) { 50 | if (pessoas[i].idade > pessoas[maisvelha].idade) { 51 | maisvelha = i; 52 | } 53 | if (pessoas[i].idade < pessoas[maisnova].idade) { 54 | maisnova = i; 55 | } 56 | } 57 | printf("\nPessoa mais velha: %s,\nPessoa mais nova: %s", pessoas[maisvelha].nome, pessoas[maisnova].nome); 58 | } 59 | 60 | /* 61 | Implemente a função main para testar todas as demais funções declaradas nos itens anteriores 62 | */ 63 | 64 | int main() { 65 | 66 | int n; 67 | printf("Quantas pessoas deseja cadastrar? "); 68 | scanf("%d", &n); 69 | 70 | Pessoa pessoas[n]; 71 | int i; 72 | for (i = 0; i < n; i++) { 73 | preenchePessoa(&pessoas[i]); 74 | } 75 | for (i = 0; i < n; i++) { 76 | imprime(&pessoas[i]); 77 | } 78 | atualizaIdade(&pessoas[0], 18); 79 | maisVelhaMaisNova(pessoas, n); 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /root/estruturas/exercio-lista.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define MAX_TURMAS 3 6 | #define MAX_VAGAS 3 7 | 8 | struct aluno { 9 | int mat; 10 | char nome[81]; 11 | float notas[3]; 12 | float media; 13 | }; 14 | 15 | typedef struct aluno Aluno; 16 | 17 | struct turma { 18 | char id; 19 | int vagas; 20 | Aluno* alunos[MAX_VAGAS]; 21 | }; 22 | 23 | typedef struct turma Turma; 24 | 25 | Turma* turmas[MAX_TURMAS]; 26 | 27 | 28 | Turma * cria_turma(char id){ 29 | /* 30 | char id: identificador da turma 31 | */ 32 | Turma *t = (Turma*) malloc(sizeof(Turma)); 33 | t->id = id; 34 | t->vagas = 0; 35 | int i; 36 | for(i = 0; i < MAX_VAGAS; i++){ 37 | t->alunos[i] = NULL; 38 | } 39 | return t; 40 | } 41 | 42 | void matricula_aluno(Turma* turma, int mat, char* nome){ 43 | /* 44 | Turma* turma: ponteiro para a turma 45 | int mat: matricula do aluno 46 | char* nome: nome do aluno 47 | */ 48 | if(turma->vagas < MAX_VAGAS){ 49 | Aluno *a = (Aluno*) malloc(sizeof(Aluno)); 50 | a->mat = mat; 51 | strcpy(a->nome, nome); 52 | int i; 53 | for(i = 0; i < 3; i++){ 54 | a->notas[i] = 0; 55 | } 56 | a->media = 0; 57 | turma->alunos[turma->vagas] = a; 58 | turma->vagas++; 59 | } 60 | } 61 | 62 | void lanca_notas(Turma* turma){ 63 | /* 64 | Turma* turma: ponteiro para a turma 65 | */ 66 | 67 | int i, j; 68 | for(i = 0; i < turma->vagas; i++){ 69 | for(j = 0; j < 3; j++){ 70 | printf("Digite a nota %d do aluno %s: ", j+1, turma->alunos[i]->nome); 71 | scanf("%f", &turma->alunos[i]->notas[j]); 72 | turma->alunos[i]->media += turma->alunos[i]->notas[j]; 73 | } 74 | turma->alunos[i]->media /= 3; 75 | } 76 | } 77 | 78 | 79 | 80 | void imprime_alunos(Turma* turma){ 81 | /* 82 | Turma* turma: ponteiro para a turma 83 | */ 84 | printf("Turma %c \r", turma->id); 85 | int i; 86 | for(i = 0; i < turma->vagas; i++){ 87 | printf("Matricula: %d Nome: %s Notas: %.2f %.2f %.2f Media: %.2f \r" , turma->alunos[i]->mat, turma->alunos[i]->nome, turma->alunos[i]->notas[0], turma->alunos[i]->notas[1], turma->alunos[i]->notas[2], turma->alunos[i]->media); 88 | 89 | } 90 | } 91 | 92 | // Função para liberar a memória alocada para a estrutura turma e variável aluno 93 | 94 | void libera_turma(Turma* turma){ 95 | int i; 96 | for(i = 0; i < turma->vagas; i++){ 97 | free(turma->alunos[i]); 98 | } 99 | free(turma); 100 | } 101 | 102 | int main(void){ 103 | 104 | turmas[0] = cria_turma('A'); 105 | turmas[1] = cria_turma('B'); 106 | matricula_aluno(turmas[0], 1, "Joao"); 107 | //matricula_aluno(turmas[0], 2, "Maria"); 108 | //matricula_aluno(turmas[1], 4, "Pedro"); 109 | //lanca_notas(turmas[0]); 110 | //lanca_notas(turmas[1]); 111 | imprime_alunos(turmas[0]); 112 | //imprime_alunos(turmas[1]); 113 | libera_turma(turmas[0]); 114 | libera_turma(turmas[1]); 115 | 116 | 117 | return 0; 118 | } 119 | 120 | 121 | 122 | -------------------------------------------------------------------------------- /root/estruturas/funcionário.c: -------------------------------------------------------------------------------- 1 | #include 2 | /* 3 | Crie um tipo estruturado para armazenar dados de um funcionário. 4 | Uma estrutura deste tipo possui os seguintes campos: nome, salário e cargo. 5 | */ 6 | 7 | typedef struct funcionario { 8 | char nome[50]; 9 | float salario; 10 | char cargo[50]; 11 | } Funcionario; 12 | 13 | /* 14 | Escreva uma função que receba como parâmetro o endereço de uma estrutura do tipo Funcionario e 15 | preencha seus campos com valores fornecidos pelo usuário via teclado. 16 | */ 17 | 18 | void preencheFuncionario(Funcionario *func) { 19 | printf("Digite o nome do funcionario: "); 20 | scanf(" %[^\n]", &func->nome); 21 | printf("Digite o salario do funcionario: "); 22 | scanf("%f", &func->salario); 23 | printf("Digite o cargo do funcionario: "); 24 | scanf(" %[^\n]", &func->cargo); 25 | } 26 | 27 | /* 28 | Escreva uma função que receba como parâmetro o endereço de uma estrutura do tipo Funcionario 29 | e imprima os valores dos seus campos. 30 | */ 31 | 32 | void imprimeFuncionario(Funcionario *func) { 33 | printf("Nome do funcionario: %s, salario: %.2f, cargo: %s ", func->nome, func->salario, func->cargo); 34 | } 35 | 36 | /* 37 | Implemente uma função para realizar uma alteração no salário de uma estrutura do tipo Funcionario. 38 | */ 39 | 40 | void alteraSalario(Funcionario *func, float valor) { 41 | func->salario += valor; 42 | } 43 | 44 | /* 45 | Escreva uma função que receba como parâmetro um vetor de estruturas do tipo Funcionario 46 | e imprima o cargo do Funcionario com maior salário e o cargo do funcionário com o menor salário. 47 | */ 48 | 49 | void maiorMenorSalario(Funcionario *func, int tam) { 50 | int i, maior = 0, menor = 0; 51 | for (i = 0; i < tam; i++) { 52 | if (func[i].salario > func[maior].salario) { 53 | maior = i; 54 | } 55 | if (func[i].salario < func[menor].salario) { 56 | menor = i; 57 | } 58 | } 59 | printf("\nFuncionario com maior salario: %s,\nFuncionario com menor salario: %s", func[maior].cargo, func[menor].cargo); 60 | } 61 | 62 | /* 63 | Implemente a função main para testar todas as demais funções declaradas nos itens anteriores 64 | */ 65 | 66 | int main() { 67 | 68 | int n; 69 | printf("Quantos funcionarios deseja cadastrar? "); 70 | scanf("%d", &n); 71 | 72 | Funcionario func[n]; 73 | int i; 74 | for (i = 0; i < n; i++) { 75 | preencheFuncionario(&func[i]); 76 | } 77 | for (i = 0; i < n; i++) { 78 | imprimeFuncionario(&func[i]); 79 | } 80 | alteraSalario(&func[0], 1000); 81 | 82 | maiorMenorSalario(func, n); 83 | return 0; 84 | } 85 | -------------------------------------------------------------------------------- /root/estruturas/retangulo-circulo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | /*Defina estruturas para representar retângulos (dadas a base e a altura) e círculos (dado o raio) */ 5 | 6 | typedef struct retangulo{ 7 | float base; 8 | float altura; 9 | } Ret; 10 | 11 | typedef struct circulo{ 12 | float raio; 13 | } Circ; 14 | 15 | /* Dado um círculo, crie e retorne o maior retângulo circunscrito de altura h. Considere que h é menor do 16 | que o diâmetro do círculo*/ 17 | 18 | Ret * ret_circunscrito(Circ *c, float h){ 19 | Ret *r= malloc(sizeof(Ret)); 20 | r->base = 2 * sqrt(pow(c->raio, 2) - pow(h, 2)); 21 | r->altura = h; 22 | return r; 23 | } 24 | 25 | /* Dado um retângulo, crie e retorne o maior círculo interno ao retângulo*/ 26 | 27 | Circ * circ_interno(Ret *r){ 28 | Circ *c = malloc(sizeof(Circ)); 29 | c->raio = sqrt(pow(r->base, 2) + pow(r->altura, 2)) / 2; 30 | return c; 31 | } 32 | 33 | 34 | int main(void){ 35 | Circ *c = malloc(sizeof(Circ)); 36 | c->raio = 5; 37 | Ret *r = ret_circunscrito(c, 3); 38 | printf("Base: %f ", r->base); 39 | printf("Altura: %f ", r->altura); 40 | free(c); 41 | free(r); 42 | return 0; 43 | } -------------------------------------------------------------------------------- /root/estruturas/retangulo.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef struct ponto{ 4 | float x, y; 5 | }Ponto; 6 | 7 | typedef struct retangulo{ 8 | Ponto p1, p2; 9 | }Retangulo; 10 | 11 | int main(void){ 12 | 13 | Retangulo tela; 14 | 15 | printf("Informe as cordenadas do ponto p1 da tela: "); 16 | scanf("%f %f", &tela.p1.x, &tela.p1.y); 17 | 18 | printf("Informe as cordenadas do ponto p2 da tela: "); 19 | scanf("%f %f", &tela.p2.x, &tela.p2.y); 20 | 21 | printf("A tela possui os dois pontos: p1=(%f, %f) p2=(%f, %f)", tela.p1.x, tela.p1.y, tela.p2.x, tela.p2.y); 22 | 23 | return 0; 24 | } -------------------------------------------------------------------------------- /root/estruturas/struct.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/estruturas/struct.png -------------------------------------------------------------------------------- /root/estruturas/union/README.md: -------------------------------------------------------------------------------- 1 | 2 | # Union 3 | 4 | ### Definição: 5 | 6 | A estrutura de dados union é uma estrutura de dados que permite armazenar diferentes tipos de dados em um mesmo espaço de memória. A estrutura de dados union é semelhante a estrutura de dados struct, mas a estrutura de dados union armazena apenas um tipo de dado por vez. A estrutura de dados union é definida da seguinte forma: 7 | 8 | ```c 9 | union nome_da_union { 10 | tipo_de_dado1 nome_do_campo1; 11 | tipo_de_dado2 nome_do_campo2; 12 | ... 13 | tipo_de_dadon nome_do_campon; 14 | }; 15 | ``` 16 | 17 | ### Exemplo de declaração de union: 18 | 19 | ```c 20 | union uniao{ 21 | int inteiro; 22 | float real; 23 | char caractere; 24 | }; 25 | 26 | union uniao u; // declara a variável u do tipo union uniao 27 | 28 | 29 | u.inteiro = 10; // armazena o valor 10 na variável inteiro 30 | u.real = 10.5; // armazena o valor 10.5 na variável real 31 | u.caractere = 'a'; // armazena o valor 'a' na variável caractere 32 | ``` 33 | No exemplo acima, a variável u pode armazenar um valor inteiro, um valor real ou um caractere. A variável u armazena apenas um tipo de dado por vez. Se a variável u armazenar um valor inteiro, então o valor real e o caractere são descartados. Se a variável u armazenar um valor real, então o valor inteiro e o caractere são descartados. Se a variável u armazenar um caractere, então o valor inteiro e o valor real são descartados. 34 | 35 | Dessa forma, como no exemplo acima a última atribuição feita na variável u foi a atribuição do caractere 'a', então a variável u armazena o caractere 'a', e os valores 10 e 10.5 são descartados. 36 | 37 | 38 | 39 | ### Exemplo de declaração de union: 40 | 41 | 42 | ![](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/estruturas/union/union.png) 43 | 44 | 45 | ### Exemplo 46 | 47 | ```c 48 | #include 49 | 50 | union tipo { 51 | int inteiro; 52 | float real; 53 | char caractere; 54 | }; 55 | 56 | typedef union tipo Tipo; 57 | 58 | int main() { 59 | Tipo t; 60 | t.inteiro = 10; 61 | printf("inteiro: %d \t real: %f \t caractere: %c \t \n", t.inteiro, t.real, t.caractere); 62 | t.real = 10.5; 63 | printf("inteiro: %d \t real: %f \t caractere: %c \t \n", t.inteiro, t.real, t.caractere); 64 | t.caractere = 'a'; 65 | printf("inteiro: %d \t real: %f \t caractere: %c \t \n", t.inteiro, t.real, t.caractere); 66 | return 0; 67 | } 68 | 69 | ``` 70 | 71 | ### Saída 72 | 73 | ```c 74 | inteiro: 10 real: 0.000000 caractere: NULL 75 | inteiro: 0 real: 10.500000 caractere: NULL 76 | inteiro: 0 real: 0.000000 caractere: a 77 | ``` 78 | 79 | Veja que a variável t armazena apenas um tipo de dado por vez. Se a variável t armazenar um valor inteiro, então o valor real e o caractere são descartados. Se a variável t armazenar um valor real, então o valor inteiro e o caractere são descartados. Se a variável t armazenar um caractere, então o valor inteiro e o valor real são descartados. 80 | 81 | 82 | 83 | # Exercício 84 | 85 | 1. Escreva um programa que implementa uma struct Aluno com os seguintes campos: nome, matrícula, curso e índice acadêmico. A variável índice acadêmico deve ser uma union que armazena um dos índices: índice geral (IG), índice de rendimento (IRA) acadêmico ou índice de rendimento técnico (IRT). O programa deve ler os dados de um aluno e imprimir os dados do aluno. 86 | 87 | 88 | -------------------------------------------------------------------------------- /root/estruturas/union/exemplo-aula.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | typedef union documento{ 6 | char rg[20]; 7 | char cpf[20]; 8 | } Documento; 9 | 10 | typedef struct pessoa{ 11 | char nome[50]; 12 | Documento doc; 13 | } Pessoa; 14 | 15 | int main(){ 16 | Pessoa p; 17 | int opcao; 18 | printf("Digite o nome: "); 19 | scanf(" %[^\n]s", p.nome); 20 | printf("Digite o documento: 1- RG, 2- CPF: "); 21 | scanf("%d", &opcao); 22 | if(opcao == 1){ 23 | printf("Digite o RG: "); 24 | scanf(" %[^\n]s", p.doc.rg); 25 | }else{ 26 | printf("Digite o CPF: "); 27 | scanf(" %[^\n]s", p.doc.cpf); 28 | } 29 | printf("Nome: %s ", p.nome); 30 | if(opcao == 1){ 31 | printf("RG: %s", p.doc.rg); 32 | }else{ 33 | printf("CPF: %s", p.doc.cpf); 34 | } 35 | return 0; 36 | } 37 | 38 | 39 | -------------------------------------------------------------------------------- /root/estruturas/union/exemplo-union.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | typedef union id{ 4 | int rg; 5 | int cpf; 6 | }id; 7 | 8 | typedef struct pessoa{ 9 | int idade; 10 | id documento; 11 | char nome[60]; 12 | }Pessoa; 13 | 14 | int main(void){ 15 | 16 | Pessoa p; 17 | int op; 18 | 19 | printf("Digite o nome da pessoa: "); 20 | scanf(" %[^\n]", p.nome); 21 | 22 | printf("Digite a idade: "); 23 | scanf("%d", &p.idade); 24 | 25 | printf("Selecione o documento a ser digitado 0-CPF ou 1-RG: "); 26 | scanf("%d", &op); 27 | 28 | switch (op) 29 | { 30 | case 0: 31 | printf("Digite o CPF: "); 32 | scanf("%d", &p.documento.cpf); 33 | break; 34 | case 1: 35 | printf("Digite o RG: "); 36 | scanf("%d", &p.documento.rg); 37 | break; 38 | default: 39 | printf("invalido \n"); 40 | break; 41 | } 42 | 43 | printf("Dados: \n Nome: %s\n Idade: %d \nDocumento: %d", p.nome, p.idade, op?p.documento.rg:p.documento.cpf); //Operador ternario: Condição ? verdadeiro : falso 44 | return 0; 45 | } -------------------------------------------------------------------------------- /root/estruturas/union/union.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/estruturas/union/union.png -------------------------------------------------------------------------------- /root/estruturas/vetores-de-ponteiros-de-struct/README.md: -------------------------------------------------------------------------------- 1 | # Vetores de ponteiros para struct 2 | 3 | ## Exemplo: Declaração de um vetor do tipo ponteiro struct ponto dinâmicamente 4 | ![](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/estruturas/vetores-de-ponteiros-de-struct/vetor-ponteiro-struct.png) 5 | 6 | 7 | No exemplo acima, declaramos um vetor que armazena 3 ponteiros para struct ponto. Dessa forma, em cada posição do vetor, podemos armazenar o endereço de uma struct ponto. 8 | 9 | ### Exemplo em C: Atribuição de valores para um vetor de ponteiros de struct 10 | 11 | ´´´c 12 | #include 13 | #include 14 | 15 | struct ponto { 16 | int x; 17 | int y; 18 | }; 19 | 20 | int main() { 21 | struct ponto **pontos = (struct ponto **) malloc(3 * sizeof(struct ponto *)); 22 | 23 | int i; 24 | 25 | for (i = 0; i < 3; i++) { 26 | pontos[i] = (struct ponto *) malloc(sizeof(struct ponto)); 27 | pontos[i]->x = i; 28 | pontos[i]->y = i; 29 | } 30 | 31 | for (i = 0; i < 3; i++) { 32 | printf("pontos[%d] = (%d, %d)\n", i, pontos[i]->x, pontos[i]->y); 33 | } 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /root/estruturas/vetores-de-ponteiros-de-struct/turma-alunos.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define MAX 5 6 | typedef struct aluno{ 7 | int matricula; 8 | char nome[81]; 9 | char turma; 10 | float nota[3]; 11 | float media; 12 | }Aluno; 13 | 14 | void inicializa(Aluno **alunos, int n){ 15 | int i; 16 | for(i=0; imatricula); 31 | scanf(" %c", &alunos[i]->turma); 32 | scanf(" %80[^\n]", alunos[i]->nome); 33 | alunos[i]->nota[0]=0; 34 | alunos[i]->nota[1]=0; 35 | alunos[i]->nota[2]=0; 36 | alunos[i]->media=0; 37 | i++; 38 | } 39 | } 40 | 41 | else 42 | { 43 | printf("Nao ha vagas"); 44 | } 45 | 46 | } 47 | 48 | void lanca_notas(int n, Aluno** alunos){ 49 | int i; 50 | for(i=0;inota[0], &alunos[i]->nota[1], &alunos[i]->nota[2]); 55 | alunos[i]->media=(alunos[i]->nota[0] + alunos[i]->nota[1] + alunos[i]->nota[2])/3; 56 | printf("Media: %.2f \n", alunos[i]->media); 57 | } 58 | } 59 | } 60 | 61 | void imprime_tudo(int n, Aluno** alunos){ 62 | int i; 63 | for(i=0; imatricula ); 66 | printf("Nome: %s \n", alunos[i]->nome); 67 | printf("Turma: %c \n", alunos[i]->turma); 68 | printf("Media: %f \n", alunos[i]->media); 69 | } 70 | 71 | } 72 | } 73 | 74 | void imprime_turma(int n, Aluno** alunos, char turma){ 75 | int i; 76 | for(i=0;iturma==turma){ 78 | printf("\n Matricula: %d \n", alunos[i]->matricula ); 79 | printf("Nome: %s \n", alunos[i]->nome); 80 | printf("Turma: %c \n", alunos[i]->turma); 81 | } 82 | } 83 | } 84 | 85 | void imprime_turma_aprovados(int n, Aluno**alunos, char turma){ 86 | int i; 87 | for(i=0;iturma==turma){ 89 | if(alunos[i]->media>=7){ 90 | printf("\n Matricula: %d \n", alunos[i]->matricula); 91 | printf("Nome: %s \n", alunos[i]->nome); 92 | printf("Media: %f \n, APROVADO \n", alunos[i]->media); 93 | } 94 | } 95 | } 96 | } 97 | int main(void){ 98 | Aluno ** aluno = (Aluno**) malloc(MAX*sizeof(Aluno*)); //Vector de ponteiros de struct 99 | if (aluno==NULL){ 100 | printf("Memoria cheia \n"); 101 | exit(1); 102 | } 103 | inicializa(aluno,MAX); 104 | matricula(MAX,aluno); 105 | lanca_notas(MAX, aluno); 106 | imprime_tudo(MAX,aluno); 107 | imprime_turma(MAX, aluno, 'a'); 108 | imprime_turma_aprovados(MAX,aluno, 'a'); 109 | 110 | return 0; 111 | } -------------------------------------------------------------------------------- /root/estruturas/vetores-de-ponteiros-de-struct/vetor-ponteiro-struct.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/estruturas/vetores-de-ponteiros-de-struct/vetor-ponteiro-struct.png -------------------------------------------------------------------------------- /root/estruturas/vetores-estruturados/README.md: -------------------------------------------------------------------------------- 1 | # Vetores de Estruturas na Linguagem C 2 | 3 | 4 | ## O que é um vetor de estruturas? 5 | 6 | Um vetor de estruturas é um vetor que contém estruturas. 7 | 8 | ## Para que serve? 9 | 10 | Vetores de estruturas são úteis para armazenar várias estruturas em um vetor. 11 | 12 | ## Como funciona? 13 | 14 | Vetores de estruturas são definidos através de structs. 15 | 16 | ```c 17 | 18 | struct pessoa { 19 | char nome[50]; 20 | int idade; 21 | }; 22 | 23 | struct pessoa pessoas[10]; 24 | 25 | ``` 26 | 27 | ## Acesso aos valores de um vetor de estruturas 28 | 29 | Para acessar os valores de um vetor de estruturas, basta usar o operador de acesso (.) e o nome da variável. 30 | 31 | ```c 32 | 33 | struct pessoa pessoas[10]; 34 | 35 | pessoas[0].idade = 20; 36 | pessoas[0].nome = "João"; 37 | 38 | ``` 39 | 40 | ## Acesso ao endereço de um vetor de estruturas 41 | 42 | Para acessar o endereço de um vetor de estruturas, basta colocar um & antes do nome da variável. 43 | 44 | ```c 45 | 46 | struct pessoa pessoas[10]; 47 | 48 | printf("%d", &pessoas); 49 | 50 | ``` 51 | 52 | ## Ponteiros e Vetores de Estruturas 53 | 54 | Um vetor de estruturas é um ponteiro para a primeira variável do vetor. 55 | 56 | ```c 57 | 58 | struct pessoa pessoas[10]; 59 | 60 | struct pessoa *p = &pessoas; 61 | 62 | printf("%d", *p); 63 | 64 | ``` 65 | 66 | 67 | 68 | ## Exemplo: Declaração de um vetor do tipo struct ponto dinâmicamente 69 | ![](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/estruturas/vetores-estruturados/vetor-de-struct.png) 70 | -------------------------------------------------------------------------------- /root/estruturas/vetores-estruturados/funcionarios.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define NUMERO_DE_FUNCIONARIOS 2 //Declaração de constante 5 | 6 | typedef struct funcionario{ 7 | char nome[100]; 8 | int idade; 9 | float salario; 10 | }Funcionario; 11 | 12 | int main(void){ 13 | 14 | Funcionario vetor_de_functionarios[NUMERO_DE_FUNCIONARIOS]; 15 | int contador; 16 | 17 | printf("\n----Digite os dados referentes aos funcionarios--- \n\n"); 18 | //Leitura dos dados dos funcionarios 19 | for(contador=0; contador 2 | #include 3 | 4 | typedef struct ponto{ 5 | float x, y; 6 | }Ponto; 7 | 8 | int main(void){ 9 | 10 | int contador; 11 | int tamanho_vetor; 12 | 13 | printf("Informe a quantidade de elementos do vetor: "); 14 | scanf("%d", &tamanho_vetor); 15 | 16 | Ponto * vetor = (Ponto*) malloc(tamanho_vetor*sizeof(Ponto)); 17 | 18 | //Leitura dos elementos para o vetor 19 | for(contador=0; contador 2 | 3 | // Algortimo: SUM: i 0 i< N 4 | 5 | int sum(int n){ 6 | int soma = 0; // 1 vez: c1 7 | int i; //1 vez: c2 8 | for(i=0; i=0 && arr[j]>key){ 64 | arr[j+1]=arr[j]; 65 | j=j-1; 66 | } 67 | arr[j+1]=key; //n-1 vez, c8 68 | } 69 | } 70 | 71 | /* T(n) = c1 + (c2+c3+c4+c8)(n-1) + n(n-1)(c5+c6+c7) 72 | T(n) = c + b(n-1) + n(n-1)*a 73 | 74 | T(n) = c + bn-b + an² - an 75 | 76 | T(n) = bn + an² - an 77 | 78 | T(n) = n + n² - n 79 | 80 | T(n) = n² 81 | 82 | Pior Insertion e Medio 83 | T(n) = O(n²) 84 | 85 | Melhor 86 | T(n) = O(n) 87 | 88 | */ 89 | 90 | -------------------------------------------------------------------------------- /root/execution_time/fibonacci.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int fibonacci(int n) { 5 | if (n == 0) { 6 | return 0; 7 | } else if (n == 1) { 8 | return 1; 9 | } else { 10 | return fibonacci(n - 1) + fibonacci(n - 2); 11 | } 12 | } 13 | 14 | int fibonacci_iterativo(int n) { 15 | int f0 = 0; 16 | int f1 = 1; 17 | int fn = 0; 18 | int i; 19 | if (n == 0) { 20 | return f0; 21 | } else if (n == 1) { 22 | return f1; 23 | } else { 24 | for (i = 2; i <= n; i++) { 25 | fn = f0 + f1; 26 | f0 = f1; 27 | f1 = fn; 28 | } 29 | return fn; 30 | } 31 | } 32 | 33 | int main() { 34 | clock_t inicio = clock(); 35 | int n = 40; 36 | printf("Fibonacci(%d) = %d\n", n, fibonacci(n)); 37 | double tempo = (double)(clock() - inicio) / CLOCKS_PER_SEC; 38 | tempo = tempo * 1000; //milisegundos 39 | printf("Tempo de execucao: %.5f ms\n", tempo); 40 | 41 | inicio = clock(); 42 | printf("Fibonacci(%d) = %d\n", n, fibonacci_iterativo(n)); 43 | tempo = (double)(clock() - inicio) / CLOCKS_PER_SEC; 44 | tempo = tempo * 1000; //milisegundos 45 | printf("Tempo de execucao: %.5f ms\n", tempo); 46 | return 0; 47 | } -------------------------------------------------------------------------------- /root/execution_time/tempo.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | clock_t inicio = clock(); 6 | // Executar o algoritmo 7 | double tempo = (double)(clock() - inicio) / CLOCKS_PER_SEC; 8 | tempo = tempo * 1000; //milisegundos 9 | printf("Tempo de execucao: %.50f\n", tempo); 10 | return 0; 11 | } -------------------------------------------------------------------------------- /root/filas/README.md: -------------------------------------------------------------------------------- 1 | # Estrutura de dados para filas 2 | 3 | ## O que é uma fila? 4 | 5 | Uma fila é uma estrutura de dados que segue o princípio FIFO (First In First Out), ou seja, o primeiro elemento a entrar é o primeiro a sair. 6 | 7 | ## Como funciona? 8 | 9 | A fila é uma estrutura de dados que funciona como uma fila de banco, onde o primeiro a chegar é o primeiro a ser atendido. 10 | 11 | ### Ilustração de como funciona uma fila 12 | 13 | ![Fila](https://www.arquivodecodigos.com.br/imagens_dicas/202205301343.jpg) 14 | 15 | ## Exemplo 16 | 17 | ```c 18 | 19 | #include 20 | #include 21 | 22 | typedef struct fila Fila; 23 | 24 | struct fila { 25 | int info; 26 | Fila *prox; 27 | }; 28 | 29 | Fila *cria_fila() { 30 | return NULL; 31 | } 32 | 33 | int fila_vazia(Fila *f) { 34 | return (f == NULL); 35 | } 36 | 37 | Fila *insere(Fila *f, int i) { 38 | Fila *novo = (Fila *) malloc(sizeof(Fila)); 39 | novo->info = i; 40 | novo->prox = NULL; 41 | if (fila_vazia(f)) { 42 | return novo; 43 | } 44 | Fila *aux = f; 45 | while (aux->prox != NULL) { 46 | aux = aux->prox; 47 | } 48 | aux->prox = novo; 49 | return f; 50 | } 51 | 52 | Fila *retira(Fila *f) { 53 | if (fila_vazia(f)) { 54 | printf("Fila vazia.\n"); 55 | return NULL; 56 | } 57 | Fila *aux = f; 58 | f = f->prox; 59 | free(aux); 60 | return f; 61 | } 62 | 63 | void imprime(Fila *f) { 64 | Fila *aux = f; 65 | while (aux != NULL) { 66 | printf("%d\n", aux->info); 67 | aux = aux->prox; 68 | } 69 | } 70 | 71 | int main() { 72 | Fila *f = cria_fila(); 73 | f = insere(f, 1); 74 | f = insere(f, 2); 75 | f = insere(f, 3); 76 | f = insere(f, 4); 77 | f = insere(f, 5); 78 | f = insere(f, 6); 79 | f = insere(f, 7); 80 | f = insere(f, 8); 81 | f = insere(f, 9); 82 | f = insere(f, 10); 83 | imprime(f); 84 | f = retira(f); 85 | f = retira(f); 86 | f = retira(f); 87 | f = retira(f); 88 | f = retira(f); 89 | f = retira(f); 90 | f = retira(f); 91 | f = retira(f); 92 | f = retira(f); 93 | f = retira(f); 94 | f = retira(f); 95 | imprime(f); 96 | return 0; 97 | } 98 | 99 | ``` 100 | -------------------------------------------------------------------------------- /root/filas/filas_com_listas/fila.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "fila.h" 4 | 5 | 6 | typedef struct lista{ 7 | float info; 8 | struct lista *prox; 9 | }Lista; 10 | 11 | struct fila{ 12 | Lista *ini; 13 | Lista *fim; 14 | }; 15 | 16 | Fila* fila_cria(void){ 17 | Fila * f = (Fila*) malloc(sizeof(Fila)); 18 | f->ini = NULL; 19 | f->fim = NULL; 20 | return f; 21 | } 22 | 23 | void fila_insere(Fila * f, float v){ 24 | Lista *novo = (Lista*) malloc(sizeof(Lista)); 25 | novo->info = v; 26 | novo->prox = NULL; 27 | if(f->fim!=NULL) 28 | f->fim->prox = novo; 29 | else{ 30 | f->ini= novo; 31 | } 32 | f->fim = novo; 33 | 34 | } 35 | 36 | float fila_retira(Fila *f){ 37 | if (f->ini==NULL){ 38 | printf("Fila vazia.\n"); 39 | exit(1); 40 | } 41 | float v = f->ini->info; 42 | f->ini= f->ini->prox; 43 | if (f->ini == NULL) 44 | f->fim = NULL; 45 | return v; 46 | } 47 | /* 48 | ou 49 | Lista *t 50 | float v; 51 | t= f->ini; 52 | v=t->info; 53 | f->ini = t->prox; 54 | if(f->ini==NULL) 55 | f->fim=NULL; 56 | free(t); 57 | return v; 58 | */ 59 | 60 | int fila_vaiza(Fila *f){ 61 | return (f->ini==NULL); 62 | } 63 | 64 | void fila_imprime(Fila *f){ 65 | Lista *p; 66 | for(p=f->ini; p!=NULL; p=p->prox){ 67 | printf(" Info = %.2f \n", p->info); 68 | } 69 | } 70 | 71 | void fila_libera(Fila *f){ 72 | Lista *p = f->ini; 73 | while(p!=NULL){ 74 | Lista* t = p->prox; 75 | free(p); 76 | p = t; 77 | } 78 | free(f); 79 | } 80 | 81 | void fila_fura(Fila *f, float v){ 82 | Lista *novo = (Lista*) malloc(sizeof(Lista)); 83 | novo->info = v; 84 | novo->prox = f->ini; 85 | f->ini = novo; 86 | } 87 | 88 | void inv(Fila* x){ 89 | Lista* t, *y, *r; 90 | r = NULL; 91 | y = x->ini; 92 | while (y!=NULL) { 93 | t = y->prox; 94 | y->prox = r; 95 | r = y; 96 | y = t; 97 | } 98 | x->ini = r; 99 | } 100 | -------------------------------------------------------------------------------- /root/filas/filas_com_listas/fila.h: -------------------------------------------------------------------------------- 1 | #ifndef FILA_LISTA_H_INCLUDED 2 | #define FILA_LISTA_H_INCLUDED 3 | 4 | typedef struct fila Fila; 5 | 6 | Fila* fila_cria(void); 7 | 8 | void fila_insere(Fila * f, float v); 9 | 10 | float fila_retira(Fila *f); 11 | 12 | int fila_vaiza(Fila *f); 13 | 14 | void fila_libera(Fila *f); 15 | 16 | void fila_imprime(Fila *f); 17 | 18 | void inv(Fila* x); 19 | 20 | 21 | #endif // FILA_LISTA_H_INCLUDED 22 | -------------------------------------------------------------------------------- /root/filas/filas_com_listas/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "fila.c" 4 | 5 | int main(){ 6 | Fila *f = fila_cria(); 7 | fila_insere(f,4.0); 8 | fila_insere(f,5.0); 9 | fila_insere(f,6.0); 10 | fila_insere(f,8.0); 11 | fila_insere(f,2.0); 12 | float v = fila_retira(f); 13 | float g = fila_retira(f); 14 | float h = fila_retira(f); 15 | fila_fura(f, 7.0); 16 | fila_insere(f,6.0); 17 | fila_insere(f,4.0); 18 | fila_insere(f,5.0); 19 | inv(f); 20 | fila_imprime(f); 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /root/filas/filas_com_vetores/fila.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "fila.h" 4 | 5 | #define MAX 10 6 | 7 | struct fila 8 | { 9 | int inicio; 10 | int fim; 11 | int numero_elementos; 12 | int dados[MAX]; 13 | }; 14 | 15 | Fila *fila_cria(void) 16 | { 17 | Fila *f = (Fila *)malloc(sizeof(Fila)); 18 | f->inicio = 0; 19 | f->fim = 0; 20 | f->numero_elementos = 0; 21 | return f; 22 | } 23 | 24 | void fila_insere(Fila *f, int v) 25 | { 26 | if (fila_cheia(f)) 27 | { 28 | printf("Capacidade da fila estourou!"); 29 | exit(1); // aborta programa 30 | } 31 | f->dados[f->fim] = v; 32 | f->fim = incrementa(f->fim); 33 | f->numero_elementos++; 34 | } 35 | 36 | int fila_remove(Fila *f) 37 | { 38 | if (fila_vazia(f)) 39 | { 40 | printf("Fila vazia!"); 41 | exit(1); // aborta programa 42 | } 43 | 44 | int elemento = f->dados[f->inicio]; 45 | f->inicio = incrementa(f->inicio); 46 | f->numero_elementos--; 47 | return elemento; 48 | } 49 | 50 | int fila_vazia(Fila *f) 51 | { 52 | return (f->numero_elementos == 0); 53 | } 54 | 55 | int fila_cheia(Fila *f) 56 | { 57 | return (f->numero_elementos == MAX); 58 | } 59 | 60 | void fila_libera(Fila *f) 61 | { 62 | free(f); 63 | } 64 | 65 | void fila_imprime(Fila *f) 66 | { 67 | int i; 68 | printf("Fila: \" "); 69 | for (i = 0; i < f->numero_elementos; i++) 70 | printf("%d ", f->dados[(f->inicio + i) % MAX]); 71 | printf("\"\n"); 72 | } 73 | 74 | int incrementa(int i) 75 | { 76 | return (i + 1) % MAX; 77 | } 78 | -------------------------------------------------------------------------------- /root/filas/filas_com_vetores/fila.h: -------------------------------------------------------------------------------- 1 | #ifndef FILA_H 2 | #define FILA_H 3 | 4 | typedef struct fila Fila; 5 | 6 | Fila* fila_cria(void); 7 | 8 | void fila_insere(Fila* f, int v); 9 | 10 | int fila_remove(Fila* f); 11 | 12 | int fila_vazia(Fila* f); 13 | 14 | int fila_cheia(Fila* f); 15 | 16 | void fila_libera(Fila* f); 17 | 18 | void fila_imprime(Fila* f); 19 | 20 | int incrementa(int i); 21 | 22 | #endif -------------------------------------------------------------------------------- /root/filas/filas_com_vetores/main.c: -------------------------------------------------------------------------------- 1 | #include "fila.c" 2 | 3 | int main(void) 4 | { 5 | Fila *f = fila_cria(); 6 | 7 | printf("Inserindo 3 elementos (10, 20, 30) na fila:\n"); 8 | fila_insere(f, 10); 9 | fila_insere(f, 20); 10 | fila_insere(f, 30); 11 | fila_imprime(f); 12 | 13 | printf("Removendo um elemento da fila (esperado: 10):\n"); 14 | fila_remove(f); 15 | fila_imprime(f); 16 | 17 | printf("Inserindo 40 na fila:\n"); 18 | fila_insere(f, 40); 19 | fila_imprime(f); 20 | 21 | printf("Removendo todos os elementos:\n"); 22 | fila_remove(f); 23 | fila_remove(f); 24 | fila_remove(f); 25 | fila_imprime(f); 26 | 27 | printf("Tentando remover de uma fila vazia:\n"); 28 | if (fila_vazia(f)) 29 | printf("Fila está vazia.\n"); 30 | else 31 | fila_remove(f); 32 | 33 | printf("Preenchendo a fila até a capacidade máxima (%d elementos):\n", MAX); 34 | for (int i = 1; i <= MAX; i++) 35 | { 36 | fila_insere(f, i * 10); 37 | } 38 | fila_imprime(f); 39 | 40 | printf("Tentando inserir em uma fila cheia:\n"); 41 | if (fila_cheia(f)) 42 | printf("Fila está cheia.\n"); 43 | else 44 | fila_insere(f, 100); 45 | 46 | fila_libera(f); 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /root/github-git-cheat-sheet.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/github-git-cheat-sheet.pdf -------------------------------------------------------------------------------- /root/interecao por menus/README.md: -------------------------------------------------------------------------------- 1 | # Funções com listas de argumentos variáveis 2 | 3 | 4 | 5 | ### Interação dirigida por menus 6 | 7 | ### Exemplo: Diálogo de opções dirigido por menus: 8 | 1. Soma de dois números interios 9 | 2. Multiplicação de dois números interios 10 | 3. Divisão de dois números interios 11 | 4. Sair do programa 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /root/interecao por menus/menu.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define TITULO_OPCAO1 "Soma de dois numeros inteiros" 6 | #define TITULO_OPCAO2 "Multiplicacao de dois numeros inteiros" 7 | #define TITULO_OPCAO3 "Divisao de dois numeros inteiros" 8 | #define TITULO_OPCAO4 "Saida do programa" 9 | 10 | #define N_OPCOES 4 11 | #define OPCAO1 '1' 12 | #define OPCAO2 '2' 13 | #define OPCAO3 '3' 14 | #define OPCAO4 '4' 15 | 16 | /**** 17 | * Função: LimpaBuffer() 18 | * Descrição: Lê e descarta caracteres encontrados na entrada 19 | * Parâmetros: Nenhum 20 | * Retorno: Nada 21 | ****/ 22 | void LimpaBuffer(void) { 23 | int valorLido; /* valorLido deve ser int! */ 24 | do { 25 | valorLido = getchar(); 26 | } while ((valorLido != '\n') && (valorLido != EOF)); 27 | } 28 | /**** 29 | * Função: LeOpcao() 30 | * Descrição: Lê e valida a opção digitada pelo usuário 31 | * Parâmetros: 32 | * menorValor (entrada): o menor valor válido 33 | * maiorValor (entrada): o maior valor válido 34 | * Retorno: A opção lida é validada 35 | ****/ 36 | int LeOpcao(int menorValor, int maiorValor) { 37 | int op; 38 | while (1) { 39 | printf("\nDigite sua opcao: "); 40 | op = getchar(); 41 | if (op >= menorValor && op <= maiorValor) { 42 | LimpaBuffer(); 43 | break; 44 | } 45 | else { 46 | printf("\nOpcao invalida. Tente novamente."); 47 | printf("\nA opcao deve estar entre %c e %c. \n", 48 | menorValor, maiorValor); 49 | LimpaBuffer(); 50 | } 51 | } 52 | return op; 53 | } 54 | /**** 55 | * Função: LeInteiro() 56 | * Descrição: Lê um número inteiro introduzido pelo usuário 57 | * Parâmetros: Nenhum 58 | * Retorno: O inteiro lido 59 | ****/ 60 | int LeInteiro(void) { 61 | int umInt, nValoresLidos; 62 | printf("Digite um valor inteiro: "); 63 | nValoresLidos = scanf("%d", &umInt); 64 | while (nValoresLidos == 0) { /*Nenhum inteiro foi lido*/ 65 | LimpaBuffer(); 66 | printf("Entrada incorreta. Digite um valor inteiro: "); 67 | nValoresLidos = scanf("%d", &umInt); 68 | } 69 | LimpaBuffer(); 70 | return umInt; 71 | } 72 | /**** 73 | * Função: ApresentaMenu 74 | * Descrição: Apresenta menu com número indeterminado de opções 75 | * Parâmetros: 76 | * nItens (entrada): número de itens no menu 77 | * menorOpcao (entrada): caractere associado ao item I 78 | * Retorno: Nada 79 | ****/ 80 | void ApresentaMenu(int nItens, int menorOpcao, ...) { 81 | int i; 82 | va_list argumentos; 83 | /* Inicia lista de argumentos variáveis */ 84 | va_start(argumentos, menorOpcao); 85 | /* Lê cada argumento e imprime na tela. Note que o */ 86 | /* tipo de cada argumento é char *, que é o tipo que */ 87 | /* representa strings em C */ 88 | for(i = 0; i < nItens; ++i) { 89 | printf("%c-%s\n", menorOpcao++, va_arg(argumentos, char *)); 90 | } 91 | va_end(argumentos);/* Encerra processamento de argumentos */ 92 | } 93 | 94 | int main(void) { 95 | unsigned char op; 96 | int inteiro1, inteiro2; 97 | unsigned int saida = 0; 98 | 99 | do { 100 | ApresentaMenu(N_OPCOES, OPCAO1, 101 | TITULO_OPCAO1, TITULO_OPCAO2, 102 | TITULO_OPCAO3, TITULO_OPCAO4); 103 | op = LeOpcao(OPCAO1, OPCAO1 + N_OPCOES - 1); 104 | switch(op) { 105 | case OPCAO1: 106 | Beep(1000,500); /* Emite um beep */ 107 | inteiro1 = LeInteiro(); 108 | inteiro2 = LeInteiro(); 109 | printf("%d + %d = %d\n", inteiro1, inteiro2, 110 | inteiro1 + inteiro2); 111 | break; 112 | 113 | case OPCAO2: 114 | Beep(1000,500); 115 | inteiro1 = LeInteiro(); 116 | inteiro2 = LeInteiro(); 117 | printf("%d * %d = %d\n", inteiro1, inteiro2, 118 | inteiro1 * inteiro2); 119 | break; 120 | 121 | case OPCAO3: 122 | Beep(1000,500); 123 | inteiro1 = LeInteiro(); 124 | inteiro2 = LeInteiro(); 125 | printf("%d / %d = %d\n", inteiro1, inteiro2, 126 | inteiro1 / inteiro2); 127 | break; 128 | 129 | case OPCAO4: 130 | Beep(1000,500); 131 | saida = 1; 132 | printf("Obrigado por usar este programa."); 133 | break; 134 | 135 | default: 136 | printf("Este programa possui um bug."); 137 | return 1; 138 | } 139 | } while(!saida); 140 | return 0; 141 | } 142 | -------------------------------------------------------------------------------- /root/listas/README.md: -------------------------------------------------------------------------------- 1 | # Estrutura de dados Lista 2 | 3 | ### Definição 4 | 5 | Uma lista é uma estrutura de dados que nos permite armazenar e organizar um conjunto de elementos de forma sequencial. Pense nela como uma coleção ordenada de itens, onde cada item pode ser identificado por uma posição ou índice. 6 | 7 | Imagine que você tem uma lista de compras que contém cinco itens: maçã, banana, laranja, abacaxi e morango. Essa lista pode ser representada da seguinte forma: 8 | 9 | ```bash 10 | 0. maçã 11 | 1. banana 12 | 2. laranja 13 | 3. abacaxi 14 | 4. morango 15 | 16 | ``` 17 | 18 | Cada item da lista é associado a um número, chamado índice, que indica sua posição na lista. Na lista acima, "maçã" está no índice 0, "banana" está no índice 1, e assim por diante. A principal característica de uma lista é que ela pode ser modificada, permitindo adicionar, remover ou modificar elementos. 19 | 20 | Assim, a lista é um conjunto de dados dispostos e/ou acessáveis em uma seqüência determinada. Este conjunto de dados pode possuir uma ordem intrínseca (lista ordenada) ou não. 21 | 22 | 23 | As listas são aplicadas em diversas situações, como por exemplo, em uma agenda de contatos, em uma lista de tarefas, em uma lista de compras, etc. 24 | 25 | As listas são estruturas de dados dinâmicas, ou seja, podem crescer e diminuir de tamanho conforme a necessidade. 26 | 27 | As listas podem ser implementadas de diversas formas, como por exemplo, através de um vetor, uma lista encadeada, uma lista duplamente encadeada, uma lista circular, etc. As listas podem ser implementadas em diferentes linguagens de programação, como arrays ou linked lists. Cada implementação tem suas particularidades, mas a ideia fundamental é a mesma: armazenar elementos em uma sequência ordenada e permitir a manipulação desses elementos. 28 | 29 | 1. [Listas simples (encadeada)](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/listas/listasEncadeadas) 30 | 2. [Listas duplamente encadeadas](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/listas/listas-duplamente-encadeadas) 31 | 3. [Listas circulares]() 32 | 4. [Listas duplamente circulares](https://github.com/roscibely/algorithms-and-data-structure/tree/develop/root/listas/listas-circulares) 33 | 34 | 35 | Referências recomendadas: 36 | 37 | [1] CELES, Waldemar. Introdução a estruturas de dados: com técnicas de programação em C. 38 | -------------------------------------------------------------------------------- /root/listas/listas-circulares/Circulares.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct lista{ 5 | int info; 6 | struct lista *ant; 7 | struct lista *prox; 8 | }Lista; 9 | 10 | Lista * insere(Lista *l, int v){ 11 | Lista *novo = (Lista*) malloc(sizeof(Lista)); 12 | novo->info = v; 13 | novo->prox = l; 14 | novo->ant = l->ant; 15 | l->ant->prox = novo; 16 | return novo; 17 | } 18 | 19 | void imprime(Lista*l){ 20 | Lista *p=l; 21 | if(p!=NULL) do{ 22 | printf("%d \n", p->info); 23 | p=p->prox; 24 | }while(p!=l); 25 | } 26 | Lista* busca(Lista *l, int v){ 27 | 28 | Lista *p; 29 | for(p=l; p!=NULL; p=p->prox){ 30 | if(p->info ==v) 31 | return p; 32 | } 33 | return NULL; 34 | 35 | } 36 | Lista* retira(Lista *l, int v){ 37 | Lista* p = busca(l,v); 38 | if(p==NULL) return l; 39 | if(p==l){ /*Inicio*/ 40 | l=p->prox; 41 | l->ant->prox=l; 42 | } 43 | else{ 44 | p->ant->prox = p->prox; 45 | p->prox->ant=p->ant;} 46 | printf("%d \n", p->info); 47 | free(p); 48 | return l; 49 | } 50 | 51 | 52 | int main (void){ 53 | Lista *l = (Lista*) malloc(sizeof(Lista)); 54 | l = insere(l,5); 55 | l = insere(l,4); 56 | l = insere(l,8); 57 | l = insere(l,0); 58 | l = retira(l, 0); 59 | 60 | /* Lista *p =l; 61 | do{ 62 | printf("%d \n", p->info); 63 | p=p->prox; 64 | }while(p!=l);*/ 65 | 66 | 67 | 68 | 69 | return 0; 70 | } 71 | -------------------------------------------------------------------------------- /root/listas/listas-circulares/README.md: -------------------------------------------------------------------------------- 1 | # Listas circulares 2 | 3 | ### Uma lista circular é uma lista que possui um ponteiro para o próximo elemento e último nó aponta para o primeiro nó. Dessa forma, é possível a patir do último nó navegar para o primeiro nó. 4 | 5 | ### Aplicação de listas circulares: 6 | 7 | - Implementação de filas circulares 8 | 9 | - Implementação de pilhas circulares 10 | 11 | ### Implementação de uma lista circular para inteiros: 12 | 13 | ```c 14 | typedef struct no { 15 | int valor; 16 | struct no *prox; 17 | } No; 18 | 19 | typedef struct lista { 20 | No *inicio; 21 | No *fim; 22 | } Lista; 23 | ``` 24 | 25 | ### Função para criar uma lista circular: 26 | 27 | ```c 28 | Lista *cria_lista() { 29 | Lista *l = (Lista *) malloc(sizeof(Lista)); 30 | if (l != NULL) { 31 | l->inicio = NULL; 32 | l->fim = NULL; 33 | } 34 | return l; 35 | } 36 | ``` 37 | 38 | ### Função para inserir um elemento no início da lista circular: 39 | 40 | ```c 41 | 42 | void insere_inicio(Lista *l, int valor) { 43 | No *novo = (No *) malloc(sizeof(No)); 44 | if (novo != NULL) { 45 | novo->valor = valor; 46 | if (l->inicio == NULL) { 47 | l->inicio = novo; 48 | l->fim = novo; 49 | novo->prox = novo; 50 | } else { 51 | novo->prox = l->inicio; 52 | l->inicio = novo; 53 | l->fim->prox = novo; 54 | } 55 | } 56 | } 57 | ``` 58 | 59 | ### Função para inserir um elemento no final da lista circular: 60 | 61 | ```c 62 | void insere_fim(Lista *l, int valor) { 63 | No *novo = (No *) malloc(sizeof(No)); 64 | if (novo != NULL) { 65 | novo->valor = valor; 66 | if (l->inicio == NULL) { 67 | l->inicio = novo; 68 | l->fim = novo; 69 | novo->prox = novo; 70 | } else { 71 | novo->prox = l->inicio; 72 | l->fim->prox = novo; 73 | l->fim = novo; 74 | } 75 | } 76 | } 77 | ``` 78 | 79 | ### Função para imprimir os elementos da lista circular: 80 | 81 | ```c 82 | 83 | void imprime_lista(Lista *l) { 84 | if (l->inicio != NULL) { 85 | No *aux = l->inicio; 86 | do { 87 | printf("%d ", aux->valor); 88 | aux = aux->prox; 89 | } while (aux != l->inicio); 90 | } 91 | } 92 | ``` 93 | 94 | ### Função para remover um elemento do início da lista circular: 95 | 96 | ```c 97 | 98 | int remove_inicio(Lista *l) { 99 | if (l->inicio == NULL) { 100 | return -1; 101 | } else { 102 | No *aux = l->inicio; 103 | int valor = aux->valor; 104 | if (l->inicio == l->fim) { 105 | l->inicio = NULL; 106 | l->fim = NULL; 107 | } else { 108 | l->inicio = aux->prox; 109 | l->fim->prox = l->inicio; 110 | } 111 | free(aux); 112 | return valor; 113 | } 114 | } 115 | ``` 116 | 117 | ### Função para remover um elemento do final da lista circular: 118 | 119 | ```c 120 | 121 | int remove_fim(Lista *l) { 122 | if (l->inicio == NULL) { 123 | return -1; 124 | } else { 125 | No *aux = l->inicio; 126 | int valor = l->fim->valor; 127 | if (l->inicio == l->fim) { 128 | l->inicio = NULL; 129 | l->fim = NULL; 130 | } else { 131 | while (aux->prox != l->fim) { 132 | aux = aux->prox; 133 | } 134 | aux->prox = l->inicio; 135 | l->fim = aux; 136 | } 137 | free(aux); 138 | return valor; 139 | } 140 | } 141 | ``` 142 | 143 | ### Função para liberar a memória alocada para a lista circular: 144 | 145 | ```c 146 | 147 | void libera_lista(Lista *l) { 148 | if (l->inicio != NULL) { 149 | No *aux = l->inicio; 150 | while (aux->prox != l->inicio) { 151 | No *aux2 = aux; 152 | aux = aux->prox; 153 | free(aux2); 154 | } 155 | free(aux); 156 | } 157 | free(l); 158 | } 159 | ``` 160 | 161 | ### Função para verificar se a lista circular está vazia: 162 | 163 | ```c 164 | 165 | int lista_vazia(Lista *l) { 166 | if (l->inicio == NULL) { 167 | return 1; 168 | } else { 169 | return 0; 170 | } 171 | } 172 | ``` 173 | 174 | ### Função para verificar se um elemento está na lista circular: 175 | 176 | ```c 177 | 178 | int elemento_existe(Lista *l, int valor) { 179 | if (l->inicio != NULL) { 180 | No *aux = l->inicio; 181 | do { 182 | if (aux->valor == valor) { 183 | return 1; 184 | } 185 | aux = aux->prox; 186 | } while (aux != l->inicio); 187 | } 188 | return 0; 189 | } 190 | ``` 191 | 192 | ### Função para retornar o tamanho da lista circular: 193 | 194 | ```c 195 | 196 | int tamanho_lista(Lista *l) { 197 | if (l->inicio != NULL) { 198 | No *aux = l->inicio; 199 | int tamanho = 0; 200 | do { 201 | tamanho++; 202 | aux = aux->prox; 203 | } while (aux != l->inicio); 204 | return tamanho; 205 | } 206 | return 0; 207 | } 208 | ``` 209 | 210 | ### Função para retornar o elemento do início da lista circular: 211 | 212 | ```c 213 | 214 | int elemento_inicio(Lista *l) { 215 | if (l->inicio != NULL) { 216 | return l->inicio->valor; 217 | } 218 | return -1; 219 | } 220 | ``` 221 | 222 | -------------------------------------------------------------------------------- /root/listas/listas-duplamente-encadeadas/Lista.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Lista.h" 4 | 5 | 6 | struct lista2{ 7 | int info; 8 | struct lista2* ant; 9 | struct lista2* prox; 10 | }; 11 | 12 | Lista2* lst_insere(Lista2 *l, int v){ 13 | 14 | Lista2* novo = (Lista2*) malloc(sizeof(Lista2)); 15 | if (novo == NULL) 16 | { 17 | printf("[ERRO] memoria insuficiente!"); 18 | exit(1); 19 | } 20 | novo->info = v; 21 | novo->prox = l; 22 | novo->ant = NULL; 23 | if(l!=NULL) 24 | l->ant = novo; 25 | return novo; 26 | } 27 | 28 | 29 | 30 | Lista2 * lst_insere_ordenado(Lista2 *l, int v){ 31 | //inserção de elementos ordenados na lista duplamente encadeada 32 | Lista2 * novo = (Lista2*) malloc(sizeof(Lista2)); 33 | novo->info = v; 34 | Lista2 * ant = NULL; 35 | Lista2 * p = l; 36 | while(p!=NULL && p->info < v){ 37 | ant = p; 38 | p = p->prox; 39 | } 40 | if(ant==NULL){ 41 | novo->prox = l; 42 | novo->ant = NULL; 43 | l->ant = novo; 44 | return novo; 45 | } 46 | else{ 47 | novo->prox = ant->prox; 48 | novo->ant = ant; 49 | ant->prox = novo; 50 | if(p!=NULL) 51 | p->ant = novo; 52 | return l; 53 | } 54 | 55 | } 56 | 57 | 58 | void lst_imprime(Lista2*l){ 59 | Lista2*p; 60 | for(p=l; p!=NULL; p=p->prox){ 61 | printf(" Info = %d \n", p->info); 62 | } 63 | 64 | } 65 | 66 | Lista2* lst_busca(Lista2 *l, int v){ 67 | 68 | Lista2 *p; 69 | for(p=l; p!=NULL; p=p->prox){ 70 | if(p->info ==v) 71 | return p; 72 | } 73 | return NULL; 74 | 75 | } 76 | 77 | Lista2* lst_retira(Lista2 *l, int v){ 78 | Lista2* p = lst_busca(l,v); 79 | 80 | if(p->prox!=NULL) 81 | p->prox->ant=p->ant; 82 | if(l==NULL) 83 | return l; 84 | if(p==l) 85 | l=p->prox; 86 | else 87 | p->ant->prox = p->prox; 88 | return l; 89 | 90 | } 91 | 92 | 93 | -------------------------------------------------------------------------------- /root/listas/listas-duplamente-encadeadas/Lista.h: -------------------------------------------------------------------------------- 1 | #ifndef LISTA_H_INCLUDED 2 | #define LISTA_H_INCLUDED 3 | 4 | 5 | typedef struct lista2 Lista2; 6 | 7 | // Função para inserir um elemento na lista duplamente encadeada 8 | Lista2* lst_insere(Lista2 *l, int v); 9 | 10 | // Função para inserir um elemento na lista duplamente encadeada de forma ordenada 11 | Lista2 * lst_insere_ordenado(Lista2 *l, int v); 12 | 13 | // Função para imprimir os elementos da lista duplamente encadeada 14 | void lst_imprime(Lista2*l); 15 | 16 | // Função para buscar um elemento na lista duplamente encadeada 17 | Lista2* lst_busca(Lista2 *l, int v); 18 | 19 | // Função para retirar um elemento da lista duplamente encadeada 20 | Lista2* lst_retira(Lista2 *l, int v); 21 | 22 | #endif // LISTA_H_INCLUDED 23 | -------------------------------------------------------------------------------- /root/listas/listas-duplamente-encadeadas/README.md: -------------------------------------------------------------------------------- 1 | # Listas duplamente encadeadas 2 | 3 | * Uma lista duplamente encadeada é uma lista que possui um ponteiro para o próximo elemento e um ponteiro para o elemento anterior. 4 | 5 | 6 | * Diferente da lista encadeada, a lista duplamente encadeada permite a navegação na lista em qualquer direção. Dessa forma, é possível navegar na lista tanto para frente quanto para trás. Por esse motivo, a lista duplamente encadeada é mais flexível que a lista encadeada e permite a implementação de algoritmos mais complexos. 7 | 8 | * Dessa forma, é necessário criar uma estrutura de dados que armazene o dado e dois ponteiros no nó, um para o próximo elemento e outro para o elemento anterior. 9 | 10 | 11 | 12 | * Implementação de uma lista duplamente encadeada para inteiros: 13 | 14 | Podemos definir uma estrutura para denotar a lista com um ponteiro para o início e um ponteiro para o fim da lista, ou simplesmente trabalharmos com a estrutura do nó. 15 | 16 | ```c 17 | typedef struct no { 18 | int valor; 19 | struct no *prox; 20 | struct no *ant; 21 | } No; 22 | 23 | typedef struct lista { 24 | No *inicio; 25 | No *fim; 26 | } Lista; 27 | ``` 28 | 29 | Veja que a estrutura do nó possui um ponteiro para o próximo elemento e um ponteiro para o elemento anterior. Diferente da lista encadeada, a lista duplamente encadeada possui um ponteiro para o início e um ponteiro para o fim da lista. 30 | 31 | * Inicialização da lista: 32 | 33 | ```c 34 | void inicializaLista(Lista *lista) { 35 | lista->inicio = NULL; 36 | lista->fim = NULL; 37 | } 38 | ``` 39 | 40 | Veja que a inicialização da lista é simples, basta atribuir NULL para o início e fim da lista. 41 | 42 | * Inserção de elemento no início da lista: 43 | 44 | ```c 45 | void insereInicio(Lista *lista, int valor) { 46 | No *novo = (No*) malloc(sizeof(No)); 47 | novo->valor = valor; 48 | novo->prox = lista->inicio; 49 | novo->ant = NULL; 50 | if (lista->inicio != NULL) { 51 | lista->inicio->ant = novo; 52 | } 53 | lista->inicio = novo; 54 | if (lista->fim == NULL) { 55 | lista->fim = novo; 56 | } 57 | } 58 | ``` 59 | 60 | Veja que a inserção de um elemento no início da lista é simples, basta criar um novo nó, atribuir o valor e fazer o ponteiro para o próximo elemento apontar para o início da lista. 61 | 62 | 63 | * Inserção de elemento no fim da lista: 64 | 65 | ```c 66 | void insereFim(Lista *lista, int valor) { 67 | No *novo = (No*) malloc(sizeof(No)); 68 | novo->valor = valor; 69 | novo->prox = NULL; 70 | novo->ant = lista->fim; 71 | if (lista->fim != NULL) { 72 | lista->fim->prox = novo; 73 | } 74 | lista->fim = novo; 75 | if (lista->inicio == NULL) { 76 | lista->inicio = novo; 77 | } 78 | } 79 | ``` 80 | 81 | Veja que a inserção de um elemento no fim da lista é simples, basta criar um novo nó, atribuir o valor e fazer o ponteiro para o elemento anterior apontar para o fim da lista. 82 | 83 | * Inserção de elemento na lista de forma ordenada: 84 | 85 | ```c 86 | 87 | void insereOrdenado(Lista *lista, int valor) { 88 | No *novo = (No*) malloc(sizeof(No)); 89 | novo->valor = valor; 90 | if (lista->inicio == NULL) { 91 | novo->prox = NULL; 92 | novo->ant = NULL; 93 | lista->inicio = novo; 94 | lista->fim = novo; 95 | } else { 96 | No *aux = lista->inicio; 97 | while (aux != NULL && aux->valor < valor) { 98 | aux = aux->prox; 99 | } 100 | if (aux == NULL) { 101 | novo->prox = NULL; 102 | novo->ant = lista->fim; 103 | lista->fim->prox = novo; 104 | lista->fim = novo; 105 | } else if (aux->ant == NULL) { 106 | novo->prox = aux; 107 | novo->ant = NULL; 108 | aux->ant = novo; 109 | lista->inicio = novo; 110 | } else { 111 | novo->prox = aux; 112 | novo->ant = aux->ant; 113 | aux->ant->prox = novo; 114 | aux->ant = novo; 115 | } 116 | } 117 | } 118 | ``` 119 | 120 | -------------------------------------------------------------------------------- /root/listas/listas-duplamente-encadeadas/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Lista.h" 4 | 5 | int main(void){ 6 | 7 | Lista2 *l = NULL; 8 | l = lst_insere(l, 2); 9 | l = lst_busca(l, 2); 10 | l = lst_insere(l, 3); 11 | l = lst_insere(l, 6); 12 | l = lst_retira(l, 3); 13 | lst_imprime(l); 14 | } 15 | -------------------------------------------------------------------------------- /root/listas/listasEncadeadas/Lista.c: -------------------------------------------------------------------------------- 1 | /* 2 | Listas encadeadas são estruturas de dados que permitem armazenar uma coleção 3 | de elementos de um mesmo tipo. 4 | 5 | Neste arquivo, temos a implementação de uma lista encadeada simples de inteiros. 6 | */ 7 | 8 | #include 9 | #include 10 | #include "lista.h" 11 | 12 | struct lista{ 13 | int info; 14 | struct lista*prox; 15 | }; 16 | 17 | 18 | Lista* lst_cria(void){ 19 | return NULL; 20 | } 21 | 22 | Lista* lst_insere(Lista* l, int v){ 23 | Lista* novo = (Lista*) malloc(sizeof(Lista)); 24 | if (novo == NULL) 25 | { 26 | printf("[ERRO] memoria insuficiente!"); 27 | exit(1); 28 | } 29 | novo->info = v; 30 | novo->prox = l; 31 | return novo; 32 | 33 | /* Ou para alterar diretamente 34 | 35 | void lst_insere(Lista** t, int v){ 36 | Lista* novo = (Lista*) malloc(sizeof(Lista)); 37 | novo->info = v; 38 | novo->prox = *t; 39 | *t = novo; */ 40 | 41 | } 42 | 43 | int lst_vazia(Lista *l){ 44 | return (l==NULL); 45 | } 46 | 47 | void lst_imprime(Lista*l){ 48 | 49 | Lista*p; 50 | for(p=l; p!=NULL; p=p->prox){ 51 | printf(" Info = %d \n", p->info); 52 | } 53 | 54 | } 55 | 56 | Lista * lst_busca(int elemento, Lista* l){ 57 | Lista * p; 58 | for(p=l; p!=NULL; p=p->prox){ 59 | if(p->info ==elemento) 60 | return p; 61 | } 62 | 63 | return NULL; 64 | 65 | } 66 | 67 | Lista * lst_retira(Lista*l, int v){ 68 | Lista* ant = NULL; /* ponteiro para elemento anterior */ 69 | Lista* p = l; /* ponteiro para percorrer a lista*/ 70 | /* procura elemento na lista, guardando anterior */ 71 | while(p->info!=v){ 72 | if (p==NULL) 73 | return l; /* n�o achou: retorna lista original */ 74 | ant = p; 75 | p = p->prox; 76 | /* verifica se achou elemento */ 77 | 78 | } 79 | /* retira elemento */ 80 | if (ant==NULL) 81 | /* retira elemento do inicio */ 82 | l = p->prox; 83 | else 84 | /* retira elemento do meio da lista */ 85 | ant->prox = p->prox; 86 | free(p); 87 | return l; 88 | } 89 | 90 | void lst_libera(Lista* l){ 91 | Lista* p = l; 92 | Lista* t; 93 | while (p != NULL) { 94 | t = p->prox; 95 | free(p); 96 | p = t; 97 | 98 | } 99 | } 100 | 101 | 102 | 103 | Lista* lst_insere_ordenada(Lista * l, int v){ 104 | Lista * novo; 105 | Lista * ant = NULL; 106 | Lista * p =l; 107 | while(p!=NULL && p->infoprox; 110 | 111 | } 112 | novo = (Lista*) malloc(sizeof(Lista)); 113 | novo->info = v; 114 | if(ant ==NULL){ 115 | novo->prox = l; 116 | l = novo; 117 | } 118 | else { 119 | novo->prox = ant-> prox; 120 | ant->prox = novo; 121 | } 122 | return l; 123 | } 124 | 125 | 126 | Lista* lst_ler_arquivo(char* nome_arquivo){ 127 | FILE *arquivo; 128 | int valor; 129 | Lista* l = lst_cria(); 130 | arquivo = fopen(nome_arquivo, "r"); 131 | if(arquivo == NULL){ 132 | printf("Erro ao abrir o arquivo!\n"); 133 | exit(1); 134 | } 135 | while(fscanf(arquivo, "%d", &valor) != EOF){ 136 | l = lst_insere(l, valor); 137 | } 138 | fclose(arquivo); 139 | return l; 140 | } 141 | 142 | -------------------------------------------------------------------------------- /root/listas/listasEncadeadas/Lista.h: -------------------------------------------------------------------------------- 1 | typedef struct lista Lista; 2 | 3 | 4 | // função que cria uma lista vazia (NULL) 5 | Lista* lst_cria(void); 6 | 7 | // função que insere um elemento no início da lista 8 | Lista* lst_insere(Lista* l, int v); 9 | 10 | //função que verifica se a lista está vazia 11 | int lst_vazia(Lista *l); 12 | 13 | //função que imprime os elementos da lista 14 | void lst_imprime(Lista*l); 15 | 16 | //função que busca um elemento na lista 17 | Lista * lst_busca(int elemento, Lista* l); 18 | 19 | //função que retira um elemento da lista 20 | Lista * lst_retira(Lista*l, int v); 21 | 22 | //função que libera a memória alocada para a lista 23 | void lst_libera(Lista* l); 24 | 25 | // função que insere de forma ordenada um elemento na lista 26 | Lista* lst_insere_ordenada(Lista * l, int v); 27 | 28 | // Função que ler de uma arquivo e armazena na lista encadeada de inteiros 29 | Lista* lst_ler_arquivo(char* nome_arquivo); 30 | 31 | -------------------------------------------------------------------------------- /root/listas/listasEncadeadas/README.md: -------------------------------------------------------------------------------- 1 | # Listas encadeadas 2 | 3 | ### Lista encadadedas são estruturas de dados que armazenam dados de forma sequencial, mas cada elemento da lista é um objeto que contém um campo com o dado e um campo com o endereço do próximo elemento da lista. 4 | 5 | ### As listas encadeadas são estruturas de dados dinâmicas, ou seja, podem crescer e diminuir de tamanho conforme a necessidade. A princial vantagem das listas encadeadas é a facilidade de inserção e remoção de elementos, pois não é necessário deslocar os elementos da lista para inserir ou remover um elemento. 6 | 7 | ### Além disso, não é necessário saber o tamanho da lista antes de inserir os elementos, pois a lista pode crescer conforme a necessidade. Chamamos cada elemento da lista de nó, e um conjunto de nós é chamado de lista encadeada. 8 | 9 | ## Exemplo: Considere a lista de frutas: 10 | ``` 11 | 0. maçã 12 | 1. banana 13 | 2. laranja 14 | ``` 15 | Queremos criar uma lista usando a linguagem de programação C. Podemos fazer isso da seguinte maneira: 16 | ```c 17 | // criaremos uma estrutura em que essa estrutura terá o nome da fruta e o endereço da estrutura da próxima fruta 18 | struct Fruta { 19 | char nome[20]; // nome da fruta 20 | struct Fruta* proxima; // endereço da próxima fruta 21 | }; 22 | 23 | int main() { 24 | // Vamos criar 3 structs Fruta para nossa lista de frutas 25 | // Criar os elementos da lista 26 | struct Fruta* fruta1 = (struct Fruta*)malloc(sizeof(struct Fruta)); 27 | struct Fruta* fruta2 = (struct Fruta*)malloc(sizeof(struct Fruta)); 28 | struct Fruta* fruta3 = (struct Fruta*)malloc(sizeof(struct Fruta)); 29 | 30 | // Atribuir os valores das frutas 31 | strcpy(fruta1->nome, "maçã"); 32 | strcpy(fruta2->nome, "banana"); 33 | strcpy(fruta3->nome, "laranja"); 34 | // Precisamos agora conectar os elementos da nossa lista de frutas 35 | // Para isso vamos encadear/conectar os elementos da lista encadeada 36 | fruta1->proxima = fruta2; // o endereço da próxima fruta que a fruta 1 vai armazenar é o endereço da fruta2 37 | fruta2->proxima = fruta3; // o endereço da próxima fruta que a fruta 2 vai armazenar é o endereço da fruta3 38 | fruta3->proxima = NULL; // o endereço da próxima fruta que a fruta 3 vai armazenar é NULL, pois não existe próxima fruta 39 | 40 | // Liberar a memória alocada 41 | free(fruta1); 42 | free(fruta2); 43 | free(fruta3); 44 | 45 | return 0; 46 | } 47 | ``` 48 | 49 | Podemos simplificar nosso exemplo acima criando uma função para alocar e encadear os elementos da nossa lista. 50 | 51 | ```c 52 | struct Fruta { 53 | char nome[20]; // nome da fruta 54 | struct Fruta* proxima; // endereço da próxima fruta 55 | }; 56 | 57 | // Função para criar e encadear os elementos da lista 58 | struct Fruta* insere(struct Fruta* fruta, char nome[20]) { 59 | /*A função recebe como parâmetros: 60 | struct Fruta* fruta: o endereço da lista de fruta (nossa lista existente) 61 | char nome[20]: o nome da fruta que será inserida na lista 62 | */ 63 | struct Fruta* novaFruta = (struct Fruta*)malloc(sizeof(struct Fruta)); 64 | strcpy(novaFruta->nome, nome); 65 | novaFruta->proxima = fruta; 66 | return novaFruta; 67 | } 68 | 69 | // Nossa main pode ser simplificada para: 70 | int main() { 71 | // Criar os elementos da lista 72 | struct Fruta* fruta = NULL; // lista vazia 73 | fruta = insere(fruta, "maçã"); // insere a fruta maçã na lista 74 | fruta = insere(fruta, "banana"); // insere a fruta banana na lista 75 | fruta = insere(fruta, "laranja"); // insere a fruta laranja na lista 76 | 77 | // Liberar a memória alocada 78 | free(fruta); 79 | 80 | return 0; 81 | } 82 | ``` 83 | 84 | 85 | Podemos ter listas encadeadas de qualquer tipo de dado, inclusive listas encadeadas de listas encadeadas. 86 | 87 | ## Exemplo de lista encadeada para inteiros: 88 | 89 | ```c 90 | struct lista_inteiro { 91 | int dado; // veja que o dado armaenado é do tipo inteiro 92 | struct lista_inteiro *prox; 93 | }; 94 | ``` 95 | 96 | Veja que para representar uma lista encadeada de inteiros, precisamos criar uma estrutura que armazena um inteiro e o endereço do próximo elemento da lista. 97 | 98 | ### Para criar uma lista encadeada, é necessário criar um ponteiro para o primeiro elemento da lista, que será o primeiro elemento da lista. Para isso, é necessário criar uma função que aloca memória para o primeiro elemento da lista e retorna o endereço do primeiro elemento da lista. 99 | 100 | ```c 101 | struct lista_inteiro* cria_lista() { 102 | struct lista_inteiro* lista = (struct lista_inteiro*)malloc(sizeof(struct lista_inteiro)); 103 | lista->prox = NULL; 104 | return lista; 105 | } 106 | ``` 107 | 108 | ### Para inserir um elemento na lista, é necessário criar uma função que aloca memória para o novo elemento da lista e retorna o endereço do novo elemento da lista. 109 | 110 | ```c 111 | struct lista_inteiro* insere(struct lista_inteiro* lista, int dado) { 112 | struct lista_inteiro* novo = (struct lista_inteiro*)malloc(sizeof(struct lista_inteiro)); 113 | novo->dado = dado; 114 | novo->prox = lista; 115 | return novo; 116 | } 117 | ``` 118 | -------------------------------------------------------------------------------- /root/listas/listasEncadeadas/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "lista.c" 4 | 5 | int main(void){ 6 | 7 | Lista* l = lst_cria(); /*Cria uma lista*/ 8 | l = lst_insere(l, 2); /*Insere o elemento na lista*/ 9 | l = lst_insere(l, 5); 10 | l = lst_insere(l, 4); 11 | l= lst_retira(l, 2); 12 | l= lst_busca(4, l); 13 | lst_imprime(l); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /root/listas/pratica-01/Listas_Encadeadas_-_Prtica_1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/listas/pratica-01/Listas_Encadeadas_-_Prtica_1.pdf -------------------------------------------------------------------------------- /root/listas/pratica-01/README.md: -------------------------------------------------------------------------------- 1 | # Prática 01 - Estrutura de dado: Listas encadeadas 2 | 3 | ## Objetivo 4 | 5 | O objetivo desta prática é implementar operações com listas encadeadas. 6 | 7 | [Questões](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/listas/pratica-01/Listas_Encadeadas_-_Prtica_1.pdf) 8 | 9 | -------------------------------------------------------------------------------- /root/listas/pratica-01/lista_de_frutas.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | typedef struct no{ 7 | char nome_fruta[20]; 8 | struct no * proxima; 9 | }No; 10 | 11 | No * adiciona_fruta(No * lista, char * nome_fruta){ 12 | No * nova_fruta = (No*) malloc(sizeof(No)); 13 | if (nova_fruta==NULL){ 14 | printf("No memory!\n"); 15 | exit(1); 16 | } 17 | strcpy(nova_fruta->nome_fruta,nome_fruta); 18 | nova_fruta->proxima=lista; 19 | return nova_fruta; 20 | } 21 | 22 | void imprime_Lista_frutas(No * lista){ 23 | No * contador; 24 | for(contador=lista; contador!=NULL; contador=contador->proxima){ 25 | printf(" %s -> ", contador->nome_fruta); 26 | } 27 | } 28 | 29 | int main(void){ 30 | No * lista_de_frutas; 31 | lista_de_frutas = NULL; 32 | lista_de_frutas = adiciona_fruta(lista_de_frutas, "Morango"); 33 | lista_de_frutas = adiciona_fruta(lista_de_frutas, "Abacate"); 34 | lista_de_frutas = adiciona_fruta(lista_de_frutas, "Goiaba"); 35 | imprime_Lista_frutas(lista_de_frutas); 36 | printf("Null"); 37 | return 0; 38 | } -------------------------------------------------------------------------------- /root/listas/pratica-01/main: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/listas/pratica-01/main -------------------------------------------------------------------------------- /root/listas/pratica-01/quest01.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | typedef struct lista{ 5 | int info; 6 | struct lista *prox; 7 | }Lista; 8 | 9 | int maiores(Lista* l, int n){ 10 | Lista * p; 11 | int k =0; 12 | for(p=l; p!=NULL; p=p->prox){ 13 | if(p->info>n) 14 | k++; 15 | } 16 | return k; 17 | } 18 | 19 | Lista * insere(Lista *l, int v){ 20 | Lista * novo = (Lista*) malloc(sizeof(Lista)); 21 | if (novo == NULL) 22 | { 23 | printf("[ERRO] memoria insuficiente!"); 24 | exit(1); 25 | } 26 | novo->info = v; 27 | novo->prox = l; 28 | return novo; 29 | } 30 | 31 | int main(void){ 32 | Lista * l = NULL; 33 | l =insere(l, 4); 34 | l = insere(l, 4); 35 | l = insere(l, 3); 36 | l = insere(l, 0); 37 | int b = 0; 38 | int a = maiores(l, b); 39 | printf("Existem %d elementos maiores que %d \n", a, b); 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /root/listas/pratica-01/quest02.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | typedef struct lista{ 6 | int info; 7 | struct lista *prox; 8 | }Lista; 9 | 10 | 11 | Lista * ultimo(Lista *l){ 12 | Lista * ultimo = NULL; 13 | Lista * p = l; 14 | while(p!=NULL){ 15 | ultimo = p; 16 | p=p->prox; 17 | } 18 | return ultimo; 19 | } 20 | 21 | Lista * insere(Lista *l, int v){ 22 | Lista * novo = (Lista*) malloc(sizeof(Lista)); 23 | if (novo == NULL) 24 | { 25 | printf("[ERRO] memoria insuficiente!"); 26 | exit(1); 27 | } 28 | novo->info = v; 29 | novo->prox = l; 30 | return novo; 31 | } 32 | 33 | int main(void){ 34 | Lista * l = NULL; 35 | l =insere(l, 6); 36 | l = insere(l, 4); 37 | l = insere(l, 3); 38 | l = insere(l, 0); 39 | l =ultimo(l); 40 | printf(" Valor do ultimo elemento da lista: %d \n", l->info); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /root/listas/pratica-01/quest03.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "..\listasEncadeadas\lista.c" // Inclui o arquivo lista.c onde consta a TAD listas 4 | 5 | 6 | Lista* contatena(Lista* l1, Lista* l2){ 7 | Lista * ant = NULL; 8 | Lista *p = l1; 9 | while(p!=NULL){ 10 | ant = p; 11 | p=p->prox; 12 | } 13 | ant->prox = l2; 14 | return ant; 15 | } 16 | 17 | Lista * insere(Lista *l, int v){ 18 | Lista * novo = (Lista*) malloc(sizeof(Lista)); 19 | if (novo == NULL) 20 | { 21 | printf("[ERRO] memoria insuficiente!"); 22 | exit(1); 23 | } 24 | novo->info = v; 25 | novo->prox = l; 26 | return novo; 27 | } 28 | 29 | int main(void){ 30 | Lista * l = NULL; 31 | l =insere(l, 6); 32 | Lista *L = insere(L, 0); 33 | L = contatena(l, L); 34 | lst_imprime(L); 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /root/listas/pratica-01/quest04.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "..\listasEncadeadas\lista.c" // Inclui o arquivo lista.c onde consta a TAD listas 4 | 5 | 6 | 7 | Lista* retira(Lista* l, int v) { 8 | Lista* ant = NULL; 9 | Lista* p = l; 10 | do{ 11 | while (p != NULL && p->info != v) { 12 | ant = p; 13 | p = p->prox; 14 | } 15 | if (p == NULL) 16 | return l; 17 | 18 | if (ant == NULL) 19 | l = p->prox; 20 | 21 | else 22 | ant->prox = p->prox; 23 | free(p); 24 | p = l; 25 | }while(p!=NULL); 26 | return l; 27 | } 28 | 29 | 30 | int main(void){ 31 | Lista * l = NULL; 32 | l =lst_insere(l, 6); 33 | l =lst_insere(l, 6); 34 | l =lst_insere(l, 5); 35 | l =lst_insere(l, 3); 36 | l =lst_insere(l, 6); 37 | l = retira(l, 6); 38 | lst_imprime(l); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /root/matrices/README.md: -------------------------------------------------------------------------------- 1 | # Matrizes com alocação dinâmica 2 | 3 | ## Introdução 4 | 5 | Matrizes são estruturas de dados que armazenam dados em linhas e colunas. A matriz é uma estrutura de dados bidimensional, ou seja, ela possui duas dimensões. A primeira dimensão é a linha e a segunda dimensão é a coluna. A matriz é uma estrutura de dados muito utilizada em algoritmos e estruturas de dados. 6 | 7 | ## Aplicação 8 | 9 | Uma das principais aplicações de matrizes é na representação de imagens. Uma imagem é composta por pixels, que são pontos de cor. Cada pixel é representado por uma matriz de 3 posições, onde cada posição representa uma cor. Por exemplo, uma imagem em tons de cinza é representada por uma matriz de 2 dimensões, onde cada posição representa um pixel. Uma imagem colorida é representada por uma matriz de 3 dimensões, onde cada posição representa um pixel. 10 | 11 | ## Exemplo 12 | 13 | Podemos representar uma matriz de 3 linhas e 3 colunas da seguinte forma: 14 | 15 | ```c 16 | int matriz[3][3] = { 17 | {1, 2, 3}, 18 | {4, 5, 6}, 19 | {7, 8, 9} 20 | }; 21 | ``` 22 | 23 | em que, acessamos o elemento da linha 1 e coluna 2 da seguinte forma: 24 | 25 | ```c 26 | matriz[1][2]; 27 | ``` 28 | 29 | ## Alocação dinâmica 30 | 31 | A alocação dinâmica é uma técnica utilizada para alocar memória em tempo de execução. A alocação dinâmica é muito utilizada em algoritmos e estruturas de dados, pois permite que o tamanho da estrutura seja definido em tempo de execução. 32 | 33 | ## Exemplo 34 | 35 | Para alocar dinamicamente uma matriz de 3 linhas e 3 colunas, podemos fazer da seguinte forma: 36 | 37 | ```c 38 | int colunas = 3; 39 | int linhas = 3; 40 | 41 | int **matriz = (int **) malloc(linhas * sizeof(int *)); // aloca as linhas 42 | for (int i = 0; i < 3; i++) { // aloca as colunas 43 | matriz[i] = (int *) malloc(colunas * sizeof(int)); 44 | } 45 | ``` 46 | 47 | ![](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/matrices/matriz.jpg) 48 | 49 | ## Função para alocar dinamicamente uma matriz 50 | 51 | Você pode criar uma função para alocar dinamicamente uma matriz. 52 | ```c 53 | int **alocaMatriz(int linhas, int colunas) { 54 | int **matriz = (int **) malloc(linhas * sizeof(int *)); 55 | for (int i = 0; i < linhas; i++) { 56 | matriz[i] = (int *) malloc(colunas * sizeof(int)); 57 | } 58 | return matriz; 59 | } 60 | ``` 61 | A função acima recebe o número de linhas e o número de colunas da matriz e retorna a matriz alocada dinamicamente. 62 | 63 | ### Liberação da memória 64 | 65 | Para liberar a memória alocada dinamicamente para uma matriz, podemos fazer da seguinte forma: 66 | 67 | ```c 68 | for (int i = 0; i < 3; i++) { // libera as colunas 69 | free(matriz[i]); 70 | } 71 | free(matriz); // libera as linhas 72 | ``` 73 | 74 | ## Passando matrizes para funções 75 | 76 | Para passar uma matriz para uma função, devemos passar o número de linhas e o número de colunas da matriz. Por exemplo, para passar uma matriz de 3 linhas e 3 colunas para uma função, podemos fazer da seguinte forma: 77 | 78 | ```c 79 | void imprimeMatriz(int **matriz, int linhas, int colunas) { 80 | for (int i = 0; i < linhas; i++) { 81 | for (int j = 0; j < colunas; j++) { 82 | printf("%d ", matriz[i][j]); 83 | } 84 | printf("\n"); 85 | } 86 | } 87 | ``` 88 | 89 | A função acima recebe uma matriz de inteiros, o número de linhas e o número de colunas da matriz. Em seguida, ela imprime a matriz na tela. 90 | 91 | ## Exemplo: Soma de matrizes 92 | 93 | Para somar duas matrizes, devemos percorrer as duas matrizes e somar os elementos de mesma posição. Por exemplo, para somar as matrizes abaixo: 94 | 95 | ```c 96 | int matriz1[3][3] = { 97 | {1, 2, 3}, 98 | {4, 5, 6}, 99 | {7, 8, 9} 100 | }; 101 | 102 | int matriz2[3][3] = { 103 | {1, 2, 3}, 104 | {4, 5, 6}, 105 | {7, 8, 9} 106 | }; 107 | ``` 108 | 109 | Podemos fazer da seguinte forma: 110 | 111 | ```c 112 | 113 | int matriz3[3][3]; 114 | 115 | for (int i = 0; i < 3; i++) { 116 | for (int j = 0; j < 3; j++) { 117 | matriz3[i][j] = matriz1[i][j] + matriz2[i][j]; 118 | } 119 | } 120 | ``` 121 | 122 | Com alocação dinâmica: 123 | 124 | ```c 125 | int colunas = 3; 126 | int linhas = 3; 127 | 128 | int **matriz1 = (int **) malloc(linhas * sizeof(int *)); // aloca as linhas 129 | for (int i = 0; i < 3; i++) { // aloca as colunas 130 | matriz1[i] = (int *) malloc(colunas * sizeof(int)); 131 | } 132 | 133 | int **matriz2 = (int **) malloc(linhas * sizeof(int *)); // aloca as linhas 134 | for (int i = 0; i < 3; i++) { // aloca as colunas 135 | matriz2[i] = (int *) malloc(colunas * sizeof(int)); 136 | } 137 | 138 | int **matriz3 = (int **) malloc(linhas * sizeof(int *)); // aloca as linhas 139 | for (int i = 0; i < 3; i++) { // aloca as colunas 140 | matriz3[i] = (int *) malloc(colunas * sizeof(int)); 141 | } 142 | 143 | for (int i = 0; i < 3; i++) { 144 | for (int j = 0; j < 3; j++) { 145 | matriz3[i][j] = matriz1[i][j] + matriz2[i][j]; 146 | } 147 | } 148 | ``` 149 | 150 | ## Exemplos realizados em sala de aula 151 | 152 | [Exemplo 1](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/matrices/exemplo_aula.c): Nomes completos 153 | 154 | [Exemplo 2](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/matrices/frutas_exemplo.c): Frutas e Preços 155 | 156 | 157 | ## Exercícios 158 | 159 | 160 | 161 | Questão 1) Escreva um programa que calcula a soma de duas matrizes MxN, considerando matrizes quadradas. As dimensões deve ser fornecidas pelo o usuário. Use alocação dinâmica e escreva uma função que somará as matrizes; [Acesse a resposta](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/matrices/question-1.c) 162 | 163 | 164 | Questão 2) Escreva um programa que aloque dinamicamente uma matriz de inteiros definida pelo o usuário. Em seguida, implemente uma função que receba um valor, retorne 1, caso esteja na matriz ou retorne 0 caso não esteja. Dica: implemente uma função que faz essa verificaçã. [Acesse a resposta](https://github.com/roscibely/algorithms-and-data-structure/blob/develop/matrices/question-2.c) 165 | -------------------------------------------------------------------------------- /root/matrices/exemplo_aula.c: -------------------------------------------------------------------------------- 1 | /* Exemplo feito em aula: Alocação Dinâmica de Matrizes na Linguagem C 2 | 3 | O programa consiste em solicitar ao usuário nomes e 4 | armazená-los em uma matriz de caracteres. 5 | 6 | O programa solicita ao usuário a quantidade de nomes que ele deseja armazenar. 7 | 8 | Em seguida, o programa aloca dinamicamente uma matriz de caracteres 9 | com a quantidade de linhas igual a quantidade de nomes digitados pelo usuário. 10 | 11 | O programa vai armazenar os nomes digitados pelo usuário na matriz de caracteres. 12 | Exemplo: 13 | 14 | nomes = { 15 | {"Joao Gomes Henrique"}, 16 | {"Maria da Silva"}, 17 | {"Jose da Silva"} 18 | } 19 | 20 | */ 21 | #include 22 | #include 23 | #include 24 | 25 | int main(void){ 26 | 27 | int qnt_nomes, linha; 28 | printf("Digite a quantidade de nomes: \n"); 29 | scanf("%d", &qnt_nomes); 30 | 31 | // Alocação dinâmica de uma matriz de caracteres 32 | char ** nomes = (char**) malloc(qnt_nomes*sizeof(char*)); 33 | if(nomes==NULL){ // Verifica se a alocação foi bem sucedida 34 | printf("Erro"); 35 | exit(1); 36 | } 37 | // Alocação dinâmica de cada linha da matriz de caracteres 38 | for(linha=0; linha 2 | #include 3 | #include 4 | /*Problema: 5 | Programa que recebe nomes de frutas e seu preço. A quantidade frutas deve ser informada 6 | pelo o usuário. Utilize alocação dinâmica, especialmente a função realloc para nãoo desperdiçar 7 | memória. 8 | 9 | */ 10 | 11 | int main() { 12 | 13 | char **nomes; 14 | float *precos; 15 | int qtd_frutas, i, j; 16 | 17 | printf("Quantidade de frutas: "); 18 | scanf("%d", &qtd_frutas); 19 | 20 | nomes = (char **)malloc(qtd_frutas * sizeof(char *)); 21 | precos = (float *)malloc(qtd_frutas * sizeof(float)); 22 | 23 | for (i = 0; i < qtd_frutas; i++) { 24 | nomes[i] = (char *)malloc(20 * sizeof(char)); 25 | printf("Digite o nome da fruta %d: ", i + 1); 26 | scanf(" %[^\n]s", nomes[i]); 27 | 28 | // Para não "desperdiçar" a memória, realocamos a memória para o tamanho exato 29 | nomes[i] = (char *)realloc(nomes[i], (strlen(nomes[i]) + 1) * sizeof(char)); 30 | 31 | printf("Digite o preco da fruta %d: ", i + 1); 32 | scanf("%f", &precos[i]); 33 | } 34 | 35 | 36 | printf("Frutas e Preços: \n"); 37 | for (i = 0; i < qtd_frutas; i++) { 38 | printf("Fruta %d: %s, Preço: %.2f\n", i + 1, nomes[i], precos[i]); 39 | } 40 | 41 | // Liberando memória 42 | for (i = 0; i < qtd_frutas; i++) { 43 | free(nomes[i]); 44 | } 45 | free(nomes); 46 | free(precos); 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /root/matrices/matriz.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/matrices/matriz.jpg -------------------------------------------------------------------------------- /root/matrices/nlogonia.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /* 5 | Problema Nlogonia 6 | 7 | Considere a matriz de entra: 8 | 3x3 9 | #.. 10 | ### 11 | .#. 12 | 13 | A saída deve ser 5, pois existem 5 costas. 14 | 15 | Considere a matriz de entra: 11 x 10 16 | .......... 17 | .....###.. 18 | ....#####. 19 | .#...##... 20 | .......... 21 | .......##. 22 | .##....... 23 | ..##...... 24 | ..###..... 25 | ..#####... 26 | .......... 27 | 28 | A saída deve ser 22, pois existem 22 costas. 29 | 30 | */ 31 | 32 | 33 | int main(void){ 34 | int m, n, i, j, k, l, cont = 0; 35 | char **matriz; 36 | 37 | // restrição de tamanho da matriz 38 | do{ 39 | printf("Digite o numero de linhas e colunas.\nDeve ser maior que 1 e menor que 1000: "); 40 | scanf("%d %d", &m, &n); 41 | }while(m < 1 || m > 1000 || n < 1 || n > 1000); 42 | 43 | 44 | matriz = (char**) malloc(m * sizeof(char*)); 45 | for(i = 0; i < m; i++) 46 | matriz[i] = (char*) malloc(n * sizeof(char)); 47 | 48 | printf("Digite o mapa em linhas: . para mar e # para terra:\n "); 49 | for(i = 0; i < m; i++){ 50 | scanf(" %[^\n]s", matriz[i]); 51 | } 52 | 53 | // imprime a matriz 54 | printf("\n Mapa informado: \n"); 55 | for(i = 0; i < m; i++){ 56 | for(j = 0; j < n; j++) 57 | printf("%c ", matriz[i][j]); 58 | printf("\n"); 59 | } 60 | 61 | 62 | // conta as costas 63 | for ( i = 0; i < m; i++) { 64 | for (j = 0; j < n; j++) { 65 | if (matriz[i][j] == '#') { 66 | // se for o canto superior esquerdo 67 | if ((i == 0 && j == 0 && (i + 1 < m && matriz[i + 1][j] == '.') || (j + 1 < n && matriz[i][j + 1] == '.'))) { 68 | cont++; 69 | } 70 | // se for o canto superior direito 71 | else if ((i == 0 && j == n - 1 && (i + 1 < m && matriz[i + 1][j] == '.') || (j > 0 && matriz[i][j - 1] == '.'))) { 72 | cont++; 73 | } 74 | // se for o canto inferior esquerdo 75 | else if ((i == m - 1 && j == 0 && (i > 0 && matriz[i - 1][j] == '.') || (j + 1 < n && matriz[i][j + 1] == '.'))) { 76 | cont++; 77 | } 78 | // se for o canto inferior direito 79 | else if ((i == m - 1 && j == n - 1 && (i > 0 && matriz[i - 1][j] == '.') || (j > 0 && matriz[i][j - 1] == '.'))) { 80 | cont++; 81 | 82 | } 83 | // se for a primeira linha 84 | else if ((i == m - 1 && j > 0 && j < n - 1 && (matriz[i][j - 1] == '.' || matriz[i][j + 1] == '.'))) { 85 | cont++; 86 | } 87 | // se for a ultima linha 88 | else if ((j == n - 1 && i > 0 && i < m - 1 && (matriz[i - 1][j] == '.' || matriz[i + 1][j] == '.'))) { 89 | cont++; 90 | } 91 | // se for a primeira coluna 92 | else if ((i == 0 && j > 0 && j < n - 1 && (matriz[i][j - 1] == '.' || matriz[i][j + 1] == '.'))) { 93 | cont++; 94 | } 95 | // se for a ultima coluna 96 | else if ((j == 0 && i > 0 && i < m - 1 && (matriz[i - 1][j] == '.' || matriz[i + 1][j] == '.'))) { 97 | cont++; 98 | } 99 | // se for o meio 100 | else if ((i != 0 && j != 0 && j != n - 1 && i != m - 1) && (matriz[i - 1][j] == '.' || matriz[i + 1][j] == '.' || matriz[i][j - 1] == '.' || matriz[i][j + 1] == '.')) { 101 | cont++; 102 | } 103 | } 104 | } 105 | } 106 | // imprime o numero de costas 107 | printf("\n O mapa contem :%d costas\n", cont); 108 | 109 | // libera a matriz 110 | for(i = 0; i < m; i++) 111 | free(matriz[i]); 112 | free(matriz); 113 | 114 | return 0; 115 | 116 | } 117 | 118 | -------------------------------------------------------------------------------- /root/matrices/question-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int *soma_vetor_simples(int*A, int*B, int n); 5 | int **soma_vetor_ponteiros(int**A, int**B, int n); 6 | 7 | /*____________________________________________*/ 8 | int *soma_vetor_simples(int *A, int*B, int n){ 9 | /* 10 | Função que retorna a soma de duas matrizes, isto é, A+B 11 | Função implementada considerando a declaração dinâmica de matrizes como vetor simples 12 | 13 | int *A: matriz 14 | int *B: matriz 15 | int n: dimensão das matrizes A e B considerando n x n (mesma quantidade de linhas e colunas) 16 | Return: 17 | C: matriz que armazena a soma A+B 18 | 19 | */ 20 | int i,j; 21 | int *C; 22 | C = (int*) malloc(n*n*sizeof(int)); 23 | for(i=0; i 2 | #include 3 | 4 | int verifica(int **A, int n, int valor); //prótotipo da função verifica 5 | 6 | int main(void){ 7 | /* Função principal do programa em C*/ 8 | 9 | int i,j, n; 10 | 11 | printf("Insira a dimensão da matriz: \t"); 12 | scanf("%d", &n); //Leitura da dimensão da matriz 13 | 14 | // Declaração da matriz dinâmica A 15 | int**A; 16 | A = (int**) malloc(n*sizeof(int*)); 17 | for(i=0; i 8 | #include 9 | #include "pilha.h" 10 | 11 | int main() { 12 | Pilha *pilha = cria_pilha(); 13 | int i; 14 | for (i = 0; i < 10; i++) { 15 | pilha_push(pilha, i); 16 | } 17 | while (!pilha_vazia(pilha)) { 18 | printf("%d ", pilha_pop(pilha)); 19 | } 20 | printf("\n"); 21 | libera_pilha(pilha); 22 | return 0; 23 | } 24 | ``` 25 | 26 | ### Saída: 27 | ```c 28 | 9 8 7 6 5 4 3 2 1 0 29 | ``` -------------------------------------------------------------------------------- /root/pilha/pilha_com_listas/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "Pilha.h" 4 | 5 | 6 | 7 | int main(void){ 8 | 9 | Pilha * p = pilha_cria(); 10 | pilha_push(p, 5.0); 11 | pilha_push(p, 2.0); 12 | 13 | /*imprime(p); 14 | float v =topo(p); 15 | printf("%.2f ", v);*/ 16 | 17 | Pilha * q = pilha_cria(); 18 | pilha_push(q, 3.0); 19 | pilha_push(q, 7.0); 20 | 21 | concatena(p,q); 22 | imprime(p); 23 | Pilha * c = copia_pilha(p); 24 | imprime(c); 25 | system("PAUSE"); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /root/pilha/pilha_com_listas/pilha.c: -------------------------------------------------------------------------------- 1 | #define N 10 2 | #include 3 | #include 4 | #include "Pilha.h" 5 | 6 | typedef struct lista{ 7 | float info; 8 | struct lista * prox; 9 | }Lista; 10 | 11 | struct pilha{ 12 | Lista * prim; 13 | }; 14 | 15 | Pilha * pilha_cria(void){ 16 | Pilha* p = (Pilha*) malloc(sizeof(Pilha)); 17 | p->prim = NULL; 18 | return p; 19 | } 20 | 21 | void pilha_push(Pilha* p, float v){ 22 | Lista * t = (Lista*) malloc(sizeof(Lista)); 23 | t->info = v; 24 | t->prox= p->prim; 25 | p->prim =t; 26 | } 27 | 28 | float pilha_pop(Pilha* p){ 29 | if(pilha_vazia(p)){ 30 | printf("Pilha vazia\n"); 31 | exit(1); 32 | } 33 | Lista * t; 34 | float v; 35 | t = p->prim; 36 | v = t->info; 37 | p->prim = t->prox; 38 | free(t); 39 | return v; 40 | } 41 | 42 | int pilha_vazia(Pilha *p){ 43 | return (p->prim ==NULL); 44 | } 45 | 46 | void pilha_libera(Pilha*p){ 47 | Lista* q= p->prim; 48 | Lista* t; 49 | while (q != NULL) { 50 | t = q->prox; 51 | free(q); 52 | q = t; 53 | 54 | } 55 | free(p); 56 | } 57 | 58 | float topo(Pilha* p){ 59 | Lista*t =(Lista*) malloc(sizeof(Lista)); 60 | t =p->prim; 61 | float v = t->info; 62 | return v; 63 | 64 | } 65 | 66 | void imprime(Pilha*l){ 67 | Lista*p; 68 | for(p=l->prim; p!=NULL; p=p->prox){ 69 | printf(" Info = %.2f \n", p->info); 70 | } 71 | 72 | } 73 | 74 | void concatena(Pilha * p1, Pilha *p2){ 75 | Lista*aux = NULL; 76 | while(p2->prim!=NULL){ 77 | Lista* novo = (Lista*) malloc(sizeof(Lista)); 78 | novo->info = pilha_pop(p2); 79 | novo->prox = aux; 80 | aux= novo; 81 | } 82 | while(aux!=NULL){ 83 | pilha_push(p1, aux->info); 84 | aux = aux->prox; 85 | } 86 | } 87 | 88 | Pilha* copia_pilha(Pilha* p){ 89 | Pilha * copia = pilha_cria(); 90 | copia =p; 91 | return copia; 92 | } 93 | 94 | -------------------------------------------------------------------------------- /root/pilha/pilha_com_listas/pilha.h: -------------------------------------------------------------------------------- 1 | 2 | typedef struct pilha Pilha; 3 | 4 | Pilha * pilha_cria(void); 5 | 6 | void pilha_push(Pilha* p, float v); 7 | 8 | float pilha_pop(Pilha* p); 9 | 10 | int pilha_vazia(Pilha*p); 11 | 12 | void pilha_libera(Pilha*p); 13 | 14 | void pilha_imprime(Pilha *p); 15 | 16 | float topo(Pilha* p); 17 | 18 | void concatena(Pilha * p1, Pilha *p2); 19 | 20 | Pilha* copia_pilha(Pilha* p); 21 | -------------------------------------------------------------------------------- /root/pilha/pilha_com_vetores/main.c: -------------------------------------------------------------------------------- 1 | #include "pilha.c" 2 | 3 | 4 | 5 | int main(void){ 6 | Pilha* p = pilha_cria(); 7 | pilha_push(p, 10); 8 | pilha_push(p, 20); 9 | pilha_push(p, 30); 10 | pilha_imprime(p); 11 | pilha_pop(p); 12 | pilha_imprime(p); 13 | pilha_libera(p); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /root/pilha/pilha_com_vetores/pilha.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "pilha.h" 4 | 5 | #define MAX 10 6 | 7 | struct pilha { 8 | int topo; 9 | int dados[MAX]; 10 | }; 11 | 12 | Pilha* pilha_cria(void) { 13 | Pilha* p = (Pilha*) malloc(sizeof(Pilha)); 14 | p->topo = 0; 15 | return p; 16 | } 17 | 18 | void pilha_push(Pilha* p, int v) { 19 | if (p->topo == MAX) { 20 | printf("Capacidade da pilha estourou!"); 21 | exit(1); // aborta programa 22 | } 23 | p->dados[p->topo] = v; 24 | p->topo++; 25 | } 26 | 27 | int pilha_pop(Pilha* p) { 28 | if (pilha_vazia(p)) { 29 | printf("Pilha vazia!"); 30 | exit(1); // aborta programa 31 | } 32 | return p->dados[--p->topo]; 33 | } 34 | 35 | int pilha_vazia(Pilha* p) { 36 | return (p->topo == 0); 37 | } 38 | 39 | void pilha_libera(Pilha* p) { 40 | free(p); 41 | } 42 | 43 | void pilha_imprime(Pilha* p) { 44 | int i; 45 | printf("Pilha: \" "); 46 | for (i = 0; i < p->topo; i++) 47 | printf("%d ", p->dados[i]); 48 | printf("\"\n"); 49 | } 50 | 51 | 52 | 53 | -------------------------------------------------------------------------------- /root/pilha/pilha_com_vetores/pilha.h: -------------------------------------------------------------------------------- 1 | #ifndef PILHA_H 2 | 3 | #define PILHA_H 4 | 5 | typedef struct pilha Pilha; 6 | 7 | Pilha* pilha_cria(void); 8 | 9 | void pilha_push(Pilha* p, int v); 10 | 11 | int pilha_pop(Pilha* p); 12 | 13 | int pilha_vazia(Pilha* p); 14 | 15 | void pilha_libera(Pilha* p); 16 | 17 | void pilha_imprime(Pilha* p); 18 | 19 | #endif -------------------------------------------------------------------------------- /root/pointers/README.md: -------------------------------------------------------------------------------- 1 | # Introdução a Ponteiros na Linguagem C 2 | 3 | ## Ponteiros 4 | 5 | Um ponteiro é uma variável que armazena o endereço de outra variável. 6 | 7 | ## Declaração de Ponteiros 8 | 9 | Para declarar um ponteiro, basta colocar um asterisco antes do nome da variável. 10 | 11 | ```c 12 | int *p; 13 | ``` 14 | 15 | ## Atribuição de Ponteiros 16 | 17 | Para atribuir um ponteiro, basta colocar o endereço da variável que ele apontará. 18 | 19 | ```c 20 | 21 | int x = 10; 22 | int *p = &x; 23 | ``` 24 | 25 | ## Acesso ao Valor de um Ponteiro 26 | 27 | Para acessar o valor de um ponteiro, basta colocar um asterisco antes do nome da variável. 28 | 29 | ```c 30 | 31 | int x = 10; 32 | int *p = &x; 33 | 34 | printf("%d", *p); 35 | ``` 36 | 37 | ## Acesso ao Endereço de um Ponteiro 38 | 39 | Para acessar o endereço de um ponteiro, basta colocar um & antes do nome da variável. 40 | 41 | ```c 42 | 43 | int x = 10; 44 | int *p = &x; 45 | 46 | printf("%p", &p); 47 | ``` 48 | 49 | ## Ponteiros e Vetores 50 | 51 | Um vetor é um ponteiro para o primeiro elemento do vetor. 52 | 53 | ```c 54 | 55 | int x[5] = {1, 2, 3, 4, 5}; 56 | int *p = x; 57 | 58 | printf("%d", *p); 59 | ``` 60 | 61 | ## Ponteiros para Ponteiros 62 | 63 | Um ponteiro para ponteiro é um ponteiro que aponta para outro ponteiro. Isto é, um ponteiro que aponta para um endereço de memória que contém outro endereço de memória. Isso é útil quando precisamos manipular uma estrutura de dados complexa. 64 | 65 | ```c 66 | 67 | int x = 10; 68 | int *p = &x; 69 | int **pp = &p; 70 | 71 | printf("%d", **pp); //Acessamos o valor de x com **pp (conteúdo do conteúdo de pp) 72 | ``` 73 | 74 | ## Ponteiros e Funções 75 | 76 | Podemos também declarar ponteiros de funções. Isso é útil quando precisamos passar uma função como parâmetro para outra função. 77 | 78 | ```c 79 | 80 | int soma(int a, int b) { 81 | return a + b; 82 | } 83 | 84 | int (*p)(int, int) = soma; /* Declaração de um ponteiro para função que recebe dois inteiros e retorna um inteiro */ 85 | 86 | printf("%d", p(1, 2)); 87 | ``` 88 | 89 | Um ponteiro para função pode ser usado para criar uma função que recebe outra função como parâmetro. 90 | 91 | ```c 92 | 93 | float (*ponteiro_para_funcao)(int, int); // Ponteiro para função que recebe dois inteiros e retorna um float 94 | ``` 95 | 96 | # Exemplo: Função que recebe outra função como parâmetro 97 | 98 | 99 | ```c 100 | float media(int a, int b) { 101 | return (a + b) / 2.0; 102 | } 103 | 104 | void calcula(int a, int b, float (*ponteiro_para_funcao)(int, int)) { 105 | printf("%f", ponteiro_para_funcao(a, b)); 106 | } 107 | 108 | int main(void){ 109 | calcula(1, 2, media); 110 | return 0; 111 | } 112 | 113 | ``` 114 | 115 | 116 | 117 | 118 | 119 | 120 | Links recomendados para estudo: 121 | 122 | [1] [clique aqui](https://www.treinaweb.com.br/blog/ponteiros-em-c-uma-abordagem-basica-e-inicial) 123 | 124 | [2] CELES, Waldemar; CERQUEIRA, Renato; RANGEL, José. Introdução a estruturas de dados: com técnicas de programação em C. 125 | -------------------------------------------------------------------------------- /root/pointers/alocdinamic.md: -------------------------------------------------------------------------------- 1 | # Alocação dinâmica 2 | 3 | ## O que é alocação dinâmica? 4 | 5 | A alocação dinâmica é um processo de alocar memória em tempo de execução. 6 | 7 | ## Para que serve? 8 | 9 | A alocação dinâmica é útil quando não sabemos o tamanho de um vetor ou quando queremos alocar memória para um vetor de tamanho variável. 10 | 11 | Na linguagem C, a alocação dinâmica é feita através da função malloc, calloc e/ou realloc. 12 | 13 | ## Como funciona? 14 | 15 | A alocação dinâmica é feita através da função malloc ou calloc. 16 | 17 | ```c 18 | 19 | int *x = malloc(5 * sizeof(int)); 20 | 21 | ``` 22 | 23 | ou, com a função calloc 24 | 25 | ```c 26 | 27 | int *x = calloc(5, sizeof(int)); 28 | 29 | ``` 30 | 31 | A diferenciação entre as duas funções é que a função calloc inicializa cada posição do vetor com zeros. 32 | 33 | ## Desalocação de memória 34 | 35 | Para desalocar memória, basta usar a função free. 36 | 37 | ```c 38 | 39 | int *x = malloc(1 * sizeof(int)); 40 | 41 | x[0] = 1; 42 | 43 | free(x); 44 | 45 | ``` 46 | 47 | ## Realocação de memória 48 | 49 | A função realloc é usada para realocar memória. Ela recebe como parâmetro um ponteiro para um bloco de memória já alocado e um inteiro que representa o novo tamanho do bloco de memória. Usa-se a função realloc quando queremos aumentar ou diminuir o tamanho de um bloco de memória já alocado. 50 | 51 | ```c 52 | 53 | int *x = malloc(1 * sizeof(int)); // x tem tamanho 1 54 | 55 | 56 | 57 | x = realloc(x, 2 * sizeof(int)); // Agora x tem tamanho 2 58 | 59 | 60 | 61 | ``` -------------------------------------------------------------------------------- /root/pointers/exercise-five.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | char situacao(float p1, float p2, float p3, int faltas, int aulas, float*media){ 5 | /* Função que determine a média e a situação de um aluno em uma disciplina 6 | 7 | float p1: nota referente a prova 1 8 | float p2: nota referente a prova 2 9 | float p3: nota referente a prova 3 10 | int faltas: faltas do aluno 11 | int aulas: total de aulas 12 | float *media: ponteiro que armazena o endereço da variável que representa a média da nota 13 | 14 | Return: 15 | A: para aprovado 16 | R: para reprovado 17 | F: para reprovado por faltas 18 | */ 19 | 20 | int nFaltas; // Variável para armazenar porcentagem de faltas 21 | 22 | *media = (p1+p2+p3)/3.0; // o conteudo do ponteiro media é modificado para a media das notas 23 | nFaltas = (100*faltas)/aulas; // porcentagem de faltas é calculada 24 | 25 | if ((nFaltas <=25) && (*media>=6.0)){ //Verifica se o aluno foi aprovado 26 | return 'A'; 27 | } 28 | else if ((nFaltas <=25) && (*media<6.0)){ // Verifica se o aluno foi reprovado por nota 29 | return 'R'; 30 | } 31 | else // Instrução executada apenas as duas condições anteriores não forem satisfeitas. 32 | return 'F'; 33 | } 34 | 35 | 36 | 37 | int main (void){ 38 | 39 | /* Função principal do programa */ 40 | 41 | float n1, n2, n3, m; //declaração de variáveis: n1, n2, n3 para as três notas a serem digitadas e m para guardar a média das notas 42 | char s; // s armazenará a letra referente a situação do aluno, isto é, A, R ou F. 43 | int f, a; // f variável para armazenar o total de faltas. a variável para armazenare total de aulas 44 | 45 | scanf("%f %f %f %d %d", &n1 , &n2, &n3, &f, &a); 46 | s = situacao(n1, n2, n3, f, a, &m); // Faz a chamada da função situacao 47 | 48 | switch(s){ 49 | case 'A': 50 | printf("Media = %.1f \t 'APROVADO' ", m); 51 | break; 52 | case 'R': 53 | printf("Media = %.1f \t 'REPROVADO' ", m); 54 | break; 55 | default: 56 | printf("Media = %.1f \t 'REPROVADO POR FALTAS' ", m); 57 | } 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /root/pointers/exercise-four.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void calcula_hexagono(float l, float *area, float *perimetro){ 5 | /* Função que calcula a area e perimetro de uma hexagono 6 | 7 | float l: lado do hexágono 8 | float *area: ponteiro que armazena o endereço da memoria onde está localizado o valor para area 9 | float *perimetro: ponteiro que armazena o endereço da memoria onde está localizado o valor para perimetro 10 | 11 | */ 12 | *perimetro = 6*l; // Realiza o calculo do perimetro do hexagono e atualiza o conteudo do endereço que o ponteiro perimetro aponta 13 | *area = (3*pow(l,2)*sqrt(3))/2; // Realiza o calculo da area do hexagono e atualiza o conteudo do endereço que o ponteiro area aponta 14 | } 15 | 16 | int main(void){ 17 | /* Função principal do programa */ 18 | 19 | float l, a, p; // Declaração das variaveis 20 | scanf("%f", &l); // Realiza a leitura do lado de um hexágono e amarzena o valor em "l" 21 | calcula_hexagono(l,&a,&p); //Faz a chamada da função calcula_hexagono passando como parametro o lado l, o endereço de a, o endereço de p 22 | printf("Area = %.2f \n Perimetro = %.2f \n", a,p); // Exibe a area e o perimetro calculados pela função calcula_hexagono 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /root/pointers/exercise-three.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | /* Função principal do programa */ 5 | 6 | int a, b, c; // Declaração de variáveis 7 | int *p1; // Declaração de um ponteiro p para int 8 | int *p2 = &a; // Declaração do ponteiro p2. O ponteiro p2 recebe o valor de endereço da variável "a" 9 | int *p3 = &c; // Declaração do ponteiro p3. O ponteiro p3 recebe o valor de endereço da variável "c" 10 | 11 | p1 = p2; // p1 agora guarda o mesmo endereço que p2 guarda 12 | *p2 = 10; // o conteúdo de p2, isto é, o valor da variável "a" é alterado para 10 13 | b = 20; //variável b armazena o valor 20 14 | int **pp; //declaração de ponteiro para ponteiro 15 | pp = &p1; //pp recebe o endereço do ponteiro p1 16 | *p3 = **pp; //o conteúdo de p3, isto é, o valor de c é alterado e agora é igual ao valor de a 17 | *p2 = b + (*p1)++; //o conteúdo de p2, isto é, o valor de a é alterado 18 | 19 | printf("%d\t%d\t%d\n", a, b, c); 20 | 21 | return 0; 22 | 23 | } 24 | -------------------------------------------------------------------------------- /root/pointers/exercise-two.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(void) { 4 | 5 | /* Função principal do programa */ 6 | 7 | int x, *p; // Declara um inteiro x e um ponteiro p para int 8 | x = 100; // Atribui o valor 100 a x 9 | p = &x; // p recebe o endereço de x 10 | 11 | printf("Valor de p = %p\tValor de *p = %d", p, *p); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /root/pointers/exercises-one.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main (void){ 4 | 5 | /* Função principal do programa */ 6 | 7 | int x, y, *p; // Declaração das variáveis x e y do tipo int e um ponteiro para int p. 8 | y = 0; // Innicializa o valor de y como 0 9 | p = &y; // p armazena o endereço de y 10 | x = *p; // x recebe o conteudo da variável que p aponta, isto é, x recebe o mesmo valor de y 11 | x = 4; // valor de x é atualizado para 4 12 | (*p)++; // conteudo da variável que p aponta é incrementado, isto é, o valor de y é incrementado 13 | --x; // valor de x é decrementado 14 | (*p) += x; // // conteudo da variável que p aponta é atualizado [(*p) = (*p)+x], isto é, o valor de y é atualizado 15 | printf("%d %d %p", x,y, p); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /root/pointers/ponteiro_de_funcao.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int mult(int valor1, int valor2) { 4 | return valor1 * valor2; 5 | } 6 | 7 | int main() { 8 | int (*p)(int, int); 9 | p = mult; 10 | printf("%d", p(2, 3)); 11 | return 0; 12 | } 13 | 14 | 15 | -------------------------------------------------------------------------------- /root/provaI.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | typedef struct professor { 6 | char nome[50]; 7 | char disciplinas[50]; 8 | int regime; 9 | } Professor; 10 | 11 | void preencheProfessor(Professor *professor) { 12 | printf("Digite o nome do professor: "); 13 | scanf(" %[^\n]", professor->nome); 14 | printf("Digite as disciplinas do professor: "); 15 | scanf(" %[^\n]", professor->disciplinas); 16 | printf("Digite o regime de trabalho do professor: "); 17 | scanf("%d", &professor->regime); 18 | } 19 | 20 | 21 | void imprimeProfessor(Professor *professor) { 22 | printf("Nome: %s\n", professor->nome); 23 | printf("Disciplinas: %s\n", professor->disciplinas); 24 | printf("Regime: %d\n", professor->regime); 25 | } 26 | 27 | 28 | void alteraRegime(Professor *professor, int novoRegime) { 29 | professor->regime = novoRegime; 30 | } 31 | 32 | int main(void){ 33 | Professor professor; 34 | preencheProfessor(&professor); 35 | imprimeProfessor(&professor); 36 | alteraRegime(&professor, 40); 37 | imprimeProfessor(&professor); 38 | return 0; 39 | 40 | } -------------------------------------------------------------------------------- /root/questoes_revisao.md: -------------------------------------------------------------------------------- 1 | # Questões para revisão 2 | 3 | ## 1. Ponteiros 4 | 5 | 01. Suponha que v é um vetor. Descreva a diferença conceitual entre as expressões v[2] e v+2. 6 | 7 | 02. Suponha que os elementos do vetor v são do tipo int e cada int ocupa 4 bytes no seu computador. Se o endereço de v[0] é 55000, qual o valor da expressão v+3. 8 | 9 | ## 2. Alocação dinâmica 10 | 11 | 01. Escreva uma função que receba dois vetores como entrada e retorne um novo vetor que contenha a soma dos elementos correspondentes dos vetores de entrada. 12 | 13 | 02. Escreva uma função que receba duas strings como entrada e retorne uma nova string que seja a concatenação das duas. 14 | 15 | Lembre-se de usar `malloc()` para alocar memória dinamicamente e `free()` para liberar a memória alocada quando ela não for mais necessária. 16 | 17 | ## 3. Structs 18 | 19 | Você precisa criar um programa para armazenar informações sobre diferentes tipos de frutas. Crie uma struct chamada "Fruta" com os seguintes campos: nome (string), cor (string), sabor (string) e quantidade (int). 20 | 21 | Em seguida, escreva um programa que permita ao usuário cadastrar várias frutas, armazenando-as em um vetor de structs. O programa deve ter as seguintes funcionalidades: 22 | 23 | * Cadastrar uma nova fruta: Solicitar ao usuário que insira o nome, cor, sabor e quantidade da fruta. Em seguida, adicionar a fruta ao array de structs. 24 | 25 | * Listar todas as frutas cadastradas: Imprimir na tela todas as informações das frutas cadastradas até o momento. 26 | 27 | * Buscar fruta por nome: Solicitar ao usuário que insira o nome de uma fruta. O programa deve buscar no array de structs por todas as frutas com esse nome e imprimir suas informações. 28 | 29 | -------------------------------------------------------------------------------- /root/recursividade.md: -------------------------------------------------------------------------------- 1 | # Recursão 2 | 3 | ## O que é? 4 | 5 | A recursão é um conceito matemático que consiste em uma função que se chama a si mesma. Em programação, a recursão é uma técnica que permite que uma função chame a si mesma, e que é muito utilizada para percorrer estruturas de dados como árvores e listas. 6 | 7 | ## Como funciona? 8 | 9 | Um exemplo de função recursiva simples em C é a função fatorial, que calcula o fatorial de um número inteiro positivo n. A definição matemática do fatorial é 10 | 11 | $$ n! = n * (n-1) * (n-2) * ... * 2 * 1. $$ 12 | 13 | A função fatorial pode ser implementada recursivamente em C da seguinte forma: 14 | 15 | ´´´c 16 | int fatorial(int n) { 17 | if (n == 0) { 18 | return 1; 19 | } 20 | return n * fatorial(n - 1); 21 | } 22 | ´´´ 23 | 24 | A função fatorial recebe um inteiro n como argumento e verifica se n é igual a 1. Se n for igual a 1, a função retorna 1, pois o fatorial de 1 é 1. Caso contrário, a função chama a si mesma com o argumento n-1 e multiplica o resultado pelo valor de n, retornando o resultado da multiplicação. Essa chamada recursiva continua até que a condição de parada seja atingida, ou seja, quando n for igual a 1. 25 | 26 | Ao chamar a função fatorial com um valor de entrada, a função irá chamar a si mesma várias vezes até atingir a condição de parada e retornar o resultado final. Por exemplo, o fatorial de 5 seria calculado da seguinte forma: 27 | 28 | ´´´c 29 | fatorial(5) = 5 * fatorial(4) 30 | fatorial(4) = 4 * fatorial(3) 31 | fatorial(3) = 3 * fatorial(2) 32 | fatorial(2) = 2 * fatorial(1) 33 | fatorial(1) = 1 * 1 = 1 34 | ´´´ 35 | Portanto, 36 | 37 | ´´´c 38 | fatorial(1) = 1 * 1 = 1 39 | fatorial(2) = 2 * 1 = 2 40 | fatorial(3) = 3 * 2 = 6 41 | fatorial(4) = 4 * 6 = 24 42 | fatorial(5) = 5 * 24 = 120 43 | ´´´ 44 | 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /root/sort-algorithms/README.md: -------------------------------------------------------------------------------- 1 | Dado o seguinte algoritmo: 2 | 3 | ```c 4 | void algoritmo(int * vetor, int tamanho){ 5 | int index, key, count; 6 | for (index = 1; index < tamanho; index++) { 7 | key = vetor[index]; 8 | count = index - 1; 9 | while (count >= 0 && vetor[count] > key) { 10 | vetor[count + 1] = vetor[count]; 11 | count-=1; 12 | } 13 | vetor[count + 1] = key; 14 | } 15 | } 16 | ``` 17 | 18 | Esse algoritmo é uma implementação do algoritmo de ordenação por inserção (_insertion sort_). Vamos analisar sua complexidade: 19 | 20 | - No melhor caso, o vetor já está ordenado. Nesse caso, a condição do `while` nunca será verdadeira, e a cada iteração do loop externo, apenas uma comparação será feita para verificar se `index` é menor que `tamanho`, e uma atribuição de `key` será feita. Assim, a complexidade será aproximadamente O(n), onde n é o tamanho do vetor. 21 | 22 | - No pior caso, o vetor está ordenado de forma inversa. Isso significa que, em cada iteração do loop externo, o elemento atual precisa ser movido para a primeira posição do vetor. Isso envolve deslocar todos os elementos anteriores a ele para frente. Portanto, no pior caso, cada iteração do loop externo pode envolver até 'index' comparações e movimentos. Assim, a complexidade será quadrática, $O(n^2)$. 23 | 24 | Podemos representar a complexidade do algoritmo de ordenação por inserção em termos de tempo como: 25 | 26 | $$ O(n^2) $$ 27 | 28 | Isso se dá porque, no pior caso, a cada elemento do vetor, precisamos percorrer todos os elementos anteriores a ele, resultando em um comportamento quadrático. 29 | 30 | Então, para resumir: 31 | 32 | - Melhor caso: $O(n)$ 33 | - Pior caso: $O(n^2)$ 34 | 35 | ## Exemplo 36 | 37 | O seguinte programa `main` faz o uso da função definida anteriormente. 38 | 39 | ```c 40 | void main(){ 41 | int v[3] = { 12,13, 11}; 42 | algoritmo(v, 3); 43 | int i; 44 | for(i=0;i<3;i++){ 45 | printf("%d\t", v[i]); 46 | } 47 | } 48 | ``` 49 | 50 | * Qual a saída do programa? Explique mostrando os valores assumidos pelas variáveis durante a execução do programa. 51 | 52 | 53 | A saída do programa será: 54 | 55 | 11 12 13 56 | 57 | 58 | Explicação passo a passo: 59 | 60 | 1. Inicialização do vetor `v` com os valores `{12, 13, 11}`. 61 | 2. Chamada da função `algoritmo(v, 3)` para ordenar o vetor. 62 | 3. Na primeira iteração do algoritmo de ordenação por inserção: 63 | - `index` é 1, `key` é 13 e `count` é 0. 64 | - Como `vetor[count] (v[0]) > key`, o elemento 12 é deslocado uma posição para a direita. 65 | - O vetor fica `{13, 13, 11}`. 66 | 4. Na segunda iteração: 67 | - `index` é 2, `key` é 11 e `count` é 1. 68 | - Como `vetor[count] (v[1]) > key`, o elemento 13 é deslocado uma posição para a direita. 69 | - `vetor` se torna `{12, 13, 13}`. 70 | - Como `vetor[count - 1] (v[0]) > key`, o elemento 12 é deslocado uma posição para a direita. 71 | - Finalmente, o `vetor[count + 1]` (v[1]) recebe o valor de `key`, resultando em `{11, 12, 13}`. 72 | 5. O loop termina e o vetor é impresso usando o loop `for`: 73 | - A saída é `11 12 13`. 74 | 75 | -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/bubblesort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | void bubbleSort(int *vetor, int tamanho) { 4 | int i, j, aux; 5 | for (i = 0; i < tamanho; i++) { 6 | for (j = 0; j < tamanho - 1; j++) { 7 | if (vetor[j] > vetor[j + 1]) { 8 | aux = vetor[j]; 9 | vetor[j] = vetor[j + 1]; 10 | vetor[j + 1] = aux; 11 | } 12 | } 13 | } 14 | } 15 | 16 | int main() { 17 | int vetor[] = {5, 3, 2, 4, 7, 1, 0, 6}; 18 | int tamanho = sizeof(vetor) / sizeof(int); 19 | int i; 20 | 21 | bubbleSort(vetor, tamanho); 22 | 23 | for (i = 0; i < tamanho; i++) { 24 | printf("%d ", vetor[i]); 25 | } 26 | printf(" Ordenado com Bubble Sort "); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/combsort.c: -------------------------------------------------------------------------------- 1 | // Implementar o algortimo de ordenação comb sort 2 | 3 | #include 4 | 5 | void combSort(int *vetor, int tamanho) { 6 | int gap = tamanho; 7 | int troca = 1; 8 | int aux; 9 | while (gap > 1 || troca == 1) { 10 | if (gap > 1) { 11 | gap = gap / 1.3; 12 | } 13 | int i = 0; 14 | troca = 0; 15 | while (i + gap < tamanho) { 16 | if (vetor[i] > vetor[i + gap]) { 17 | aux = vetor[i]; 18 | vetor[i] = vetor[i + gap]; 19 | vetor[i + gap] = aux; 20 | troca = 1; 21 | } 22 | i++; 23 | } 24 | } 25 | } 26 | 27 | int main() { 28 | int vetor[] = {5, 3, 2, 4, 7, 1, 0, 6}; 29 | int tamanho = sizeof(vetor) / sizeof(int); 30 | int i; 31 | 32 | combSort(vetor, tamanho); 33 | 34 | for (i = 0; i < tamanho; i++) { 35 | printf("%d ", vetor[i]); 36 | } 37 | printf(" Ordenado com Comb Sort "); 38 | return 0; 39 | } -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/gnomesort.c: -------------------------------------------------------------------------------- 1 | // Implementar o algoritmo de ordenação gnome sort 2 | 3 | #include 4 | 5 | void gnomeSort(int *vetor, int tamanho) { 6 | int i = 0; 7 | int aux; 8 | while (i < tamanho) { 9 | if (i == 0 || vetor[i - 1] <= vetor[i]) { 10 | i++; 11 | } else { 12 | aux = vetor[i]; 13 | vetor[i] = vetor[i - 1]; 14 | vetor[i - 1] = aux; 15 | i--; 16 | } 17 | } 18 | } 19 | 20 | int main() { 21 | int vetor[] = {5, 3, 2, 4, 7, 1, 0, 6}; 22 | int tamanho = sizeof(vetor) / sizeof(int); 23 | int i; 24 | 25 | gnomeSort(vetor, tamanho); 26 | 27 | for (i = 0; i < tamanho; i++) { 28 | printf("%d ", vetor[i]); 29 | } 30 | printf(" Ordenado com Gnome Sort "); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/insertionsort.c: -------------------------------------------------------------------------------- 1 | // Implementar o algortimo de ordenação Insertion Sort 2 | 3 | #include 4 | 5 | void insertionSort(int *vetor, int tamanho) { 6 | int i, j, aux; 7 | for (i = 1; i < tamanho; i++) { 8 | aux = vetor[i]; 9 | j = i - 1; 10 | while (j >= 0 && vetor[j] > aux) { 11 | vetor[j + 1] = vetor[j]; 12 | j--; 13 | } 14 | vetor[j + 1] = aux; 15 | } 16 | } 17 | 18 | int main() { 19 | int vetor[] = {5, 3, 2, 4, 7, 1, 0, 6}; 20 | int tamanho = sizeof(vetor) / sizeof(int); 21 | int i; 22 | 23 | insertionSort(vetor, tamanho); 24 | 25 | for (i = 0; i < tamanho; i++) { 26 | printf("%d ", vetor[i]); 27 | } 28 | printf(" Ordenado com Insertion Sort "); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/mergesort.c: -------------------------------------------------------------------------------- 1 | // Implementar o algortimo de ordenação merge sort 2 | 3 | #include 4 | 5 | void merge(int *vetor, int inicio, int meio, int fim) { 6 | int i, j, k; 7 | int n1 = meio - inicio + 1; 8 | int n2 = fim - meio; 9 | int L[n1], R[n2]; 10 | for (i = 0; i < n1; i++) { 11 | L[i] = vetor[inicio + i]; 12 | } 13 | for (j = 0; j < n2; j++) { 14 | R[j] = vetor[meio + 1 + j]; 15 | } 16 | i = 0; 17 | j = 0; 18 | k = inicio; 19 | while (i < n1 && j < n2) { 20 | if (L[i] <= R[j]) { 21 | vetor[k] = L[i]; 22 | i++; 23 | } else { 24 | vetor[k] = R[j]; 25 | j++; 26 | } 27 | k++; 28 | } 29 | while (i < n1) { 30 | vetor[k] = L[i]; 31 | i++; 32 | k++; 33 | } 34 | while (j < n2) { 35 | vetor[k] = R[j]; 36 | j++; 37 | k++; 38 | } 39 | } 40 | 41 | void mergeSort(int *vetor, int inicio, int fim) { 42 | if (inicio < fim) { 43 | int meio = inicio + (fim - inicio) / 2; 44 | mergeSort(vetor, inicio, meio); 45 | mergeSort(vetor, meio + 1, fim); 46 | merge(vetor, inicio, meio, fim); 47 | } 48 | } 49 | 50 | int main() { 51 | int vetor[] = {5, 3, 2, 4, 7, 1, 0, 6}; 52 | int tamanho = sizeof(vetor) / sizeof(int); 53 | int i; 54 | 55 | mergeSort(vetor, 0, tamanho - 1); 56 | 57 | for (i = 0; i < tamanho; i++) { 58 | printf("%d ", vetor[i]); 59 | } 60 | printf(" Ordenado com Merge Sort "); 61 | return 0; 62 | } -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/quicksort.c: -------------------------------------------------------------------------------- 1 | // implementar o algoritmo de ordenação quicksort 2 | 3 | #include 4 | 5 | void quickSort(int *vetor, int inicio, int fim) { 6 | int i, j, pivo, aux; 7 | i = inicio; 8 | j = fim - 1; 9 | pivo = vetor[(inicio + fim) / 2]; 10 | while (i <= j) { 11 | while (vetor[i] < pivo && i < fim) { 12 | i++; 13 | } 14 | while (vetor[j] > pivo && j > inicio) { 15 | j--; 16 | } 17 | if (i <= j) { 18 | aux = vetor[i]; 19 | vetor[i] = vetor[j]; 20 | vetor[j] = aux; 21 | i++; 22 | j--; 23 | } 24 | } 25 | if (j > inicio) { 26 | quickSort(vetor, inicio, j + 1); 27 | } 28 | if (i < fim) { 29 | quickSort(vetor, i, fim); 30 | } 31 | } 32 | 33 | int main() { 34 | int vetor[] = {5, 3, 2, 4, 7, 1, 0, 6}; 35 | int tamanho = sizeof(vetor) / sizeof(int); 36 | int i; 37 | 38 | quickSort(vetor, 0, tamanho); 39 | 40 | for (i = 0; i < tamanho; i++) { 41 | printf("%d ", vetor[i]); 42 | } 43 | printf(" Ordenado com Quick Sort "); 44 | return 0; 45 | } -------------------------------------------------------------------------------- /root/sort-algorithms/sort-algorithms/shellsort.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | void shellsort(int v[], int n) { 5 | /* v: vetor a ser ordenado 6 | n: tamanho do vetor 7 | */ 8 | int gap, i, j, temp; 9 | //gap: distância entre elementos a serem comparados 10 | //i: índice do elemento atual 11 | //j: índice do elemento anterior 12 | //temp: variável auxiliar para troca de valores 13 | for (gap = n / 2; gap > 0; gap /= 2) //inicializa gap com o tamanho da metade do vetor e vai diminuindo pela metade até chegar a 1 14 | for (i = gap; i < n; i++) //percorre o vetor iniciando em gap e indo até o final do vetor 15 | for (j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap) { //compara o elemento atual com o anterior 16 | temp = v[j]; //troca os elementos se o anterior for maior que o atual 17 | v[j] = v[j + gap]; // vetor na posição j recebe o valor do vetor na posição j + gap 18 | v[j + gap] = temp; // vetor na posição j + gap recebe o valor do vetor na posição j 19 | } 20 | } 21 | 22 | int main() { 23 | int v[] = { 5, 4, 3, 2, 1 }; 24 | int n = sizeof(v) / sizeof(v[0]); 25 | shellsort(v, n); 26 | int i; 27 | for (i = 0; i < n; i++) 28 | printf("%d ", v[i]); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /root/ufersa.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/ufersa.jpg -------------------------------------------------------------------------------- /root/vectors/README.md: -------------------------------------------------------------------------------- 1 | # Alocação dinâmica de Vetores 2 | 3 | # Introdução a vetores 4 | 5 | ## Vetores 6 | 7 | Um vetor é uma variável que armazena vários valores do mesmo tipo. 8 | 9 | ## Declaração de Vetores 10 | 11 | Para declarar um vetor, basta colocar colchetes depois do nome da variável. 12 | 13 | ```c 14 | int x[5]; 15 | ``` 16 | 17 | ## Atribuição de Vetores 18 | 19 | Para atribuir um vetor, basta colocar os valores entre chaves. 20 | 21 | ```c 22 | 23 | int x[5] = {1, 2, 3, 4, 5}; 24 | ``` 25 | 26 | ## Acesso aos Valores de um Vetor 27 | 28 | Para acessar os valores de um vetor, basta colocar o índice entre colchetes. 29 | 30 | ```c 31 | 32 | int x[5] = {1, 2, 3, 4, 5}; 33 | 34 | printf("%d", x[0]); 35 | ``` 36 | 37 | ## Acesso ao Endereço de um Vetor 38 | 39 | Para acessar o endereço de um vetor, basta colocar um & antes do nome da variável. 40 | 41 | ```c 42 | 43 | int x[5] = {1, 2, 3, 4, 5}; 44 | 45 | printf("%d", &x); 46 | ``` 47 | 48 | ## Ponteiros e Vetores 49 | 50 | Um vetor é um ponteiro para o primeiro elemento do vetor. 51 | 52 | ```c 53 | 54 | int x[5] = {1, 2, 3, 4, 5}; 55 | 56 | int *p = x; 57 | 58 | printf("%d", *p); 59 | ``` 60 | 61 | ## Alocação Dinâmica de Vetores 62 | 63 | Para alocar dinamicamente um vetor, basta usar a função malloc. 64 | 65 | ```c 66 | 67 | int *x = malloc(5 * sizeof(int)); 68 | 69 | x[0] = 1; 70 | x[1] = 2; 71 | x[2] = 3; 72 | x[3] = 4; 73 | x[4] = 5; 74 | 75 | printf("%d", x[0]); 76 | ``` 77 | 78 | ## Desalocação de Vetores 79 | 80 | Para desalocar um vetor, basta usar a função free. 81 | 82 | ```c 83 | 84 | int *x = malloc(1 * sizeof(int)); 85 | 86 | x[0] = 1; 87 | 88 | free(x); 89 | ``` 90 | 91 | ## Função realloc 92 | 93 | A função realloc é usada para realocar um vetor. 94 | 95 | ```c 96 | 97 | int *x = malloc(1 * sizeof(int)); 98 | 99 | x[0] = 1; 100 | 101 | x = realloc(x, 5 * sizeof(int)); 102 | 103 | x[1] = 2; 104 | x[2] = 3; 105 | x[3] = 4; 106 | x[4] = 5; 107 | 108 | printf("%d", x[0]); 109 | ``` 110 | 111 | ## Função calloc 112 | 113 | A função calloc é usada para alocar um vetor e inicializar todos os valores com 0. 114 | 115 | ```c 116 | 117 | int *x = calloc(5, sizeof(int)); 118 | 119 | printf("%d", x[0]); 120 | ``` 121 | 122 |
123 | 124 | 125 |
126 | 127 | #### Nota: Tente primeiro fazer seu código e só depois disso acesse a possível resposta. 128 | *Questão 1)* Implemente uma função que receba como parâmetro um vetor de números inteiros (vet) de tamanho n e retorne quantos números pares estão 129 | armazenados nesse vetor. Essa função deve obedecer ao protótipo: int pares(int n, int* vet); [Acesse a resposta](https://github.com/roscibely/algorithms-and-data-structure/blob/main/vectors/question-1.c) 130 | 131 | 132 | *Questão 2)* Uma empresa fez uma pesquisa para saber se as pessoas gostaram ou não de um 133 | novo produto. Um número N de pessoas de ambos os sexos foi entrevistado, e o questionário 134 | consistia em apenas duas perguntas: (i) o sexo do entrevistado (M/F) e (ii) sua opinião sobre o 135 | produto (gostou/não gostou). Escreva um programa em C que: 136 | 137 | * a) leia as respostas contidas no questionário e armazene-as em dois arrays vinculados, um deles contendo a resposta para a primeira pergunta e o outro contendo a resposta para a segunda pergunta. 138 | * b) determine a porcentagem de pessoas do sexo feminino que responderam que gostaram do produto. 139 | * c) determine a porcentagem de pessoas do sexo masculino que responderam que não gostaram do produto. 140 | [Acesse a resposta](https://github.com/roscibely/algorithms-and-data-structure/blob/main/vectors/question-2.c) 141 | 142 | *Questão 3)* Implemente uma função que preencha um vetor de N elementos com valores 143 | inteiros fornecidos via teclado, de modo que, à medida que um novo elemento 144 | é inserido, o vetor já permaneça organizado de maneira ordenada crescente. 145 | Escreva um programa que utiliza esta função, que deve obedecer ao seguinte 146 | protótipo: void preenche_ordenado(int n, int* vet); [Acesse a resposta](https://github.com/roscibely/algorithms-and-data-structure/blob/main/vectors/question-3.c) 147 | -------------------------------------------------------------------------------- /root/vectors/question-1.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int pares(int n, int* vet){ 5 | /* Função que conta a quantidade de números pares em um vetor 6 | 7 | int n: números de elementos do vetor (tamanho do vetor vet) 8 | int *vet: endereço para o primeiro elemento do vetor 9 | 10 | Return: 11 | int soma: quantidade de elementos pares existentes no vetor vet 12 | 13 | */ 14 | 15 | int i, soma; 16 | soma=0; 17 | for(i=0; i 2 | #include 3 | 4 | int main(void) 5 | { 6 | 7 | /* Função principal do programa */ 8 | 9 | int i, somaF, somaM, j, n; 10 | somaM = somaF = 0; 11 | /* i e j: contadores auxilares para o laço de repetição for 12 | somaF e somaM variáveis para armazenar a quantidade de mulheres (somaF) e homens (somaM) entrevistados 13 | n: variável para armazenar a quantidade de usuarios entrevistados*/ 14 | 15 | printf("Informe a quantidade de usuarios entrevistados \n"); 16 | scanf("%d", &n); 17 | 18 | char *sexo = (char *)malloc(n * sizeof(char)); //Alocação dinâmica do vetor sexo. Vetor que guardará o sexo dos entrevistados F ou M 19 | int *op = (int *)malloc(n * sizeof(int)); //Alocação dinâmica do vetor op. Vetor de guardará valor 0 ou 1. 20 | //0 quando o usuario não gostou do produto e 1 quando ele gostar do produto. 21 | 22 | printf("----QUESTIONARIO----: \n"); 23 | 24 | //Laço de repetição for para ler e armazenar os dados nos vetores sexo e op 25 | for (i = 0; i < n; i++) 26 | { 27 | printf("Sexo do entrevistado: Digite F ou M \n"); 28 | scanf(" %c", &sexo[i]); 29 | printf("Opniao sobre o produto: \n 0. nao gostou \n 1. gostou \n"); 30 | scanf("%d", &op[i]); 31 | } 32 | 33 | // Laço de repetição para somar a quantidade de pessoas do sexo F que gostaram do produto e 34 | //somar a quantidade de pessoas do sexo M que não gostaram 35 | for (j = 0; j < n; j++) 36 | { 37 | // Verificar se o sexo é F e a op 1, isto é, gostou 38 | if ((sexo[j] == 'F') && (op[j] == 1)) 39 | { 40 | somaF++; 41 | } 42 | // Verificar se o sexo é M e a op 0, isto é, não gostou 43 | if ((sexo[j] == 'M') && (op[j] == 0)) 44 | { 45 | somaM++; 46 | } 47 | } 48 | 49 | somaF = ((somaF * 100.0f) / n); //determine a porcentagem de pessoas do sexo feminino que responderam que gostaram do produto 50 | somaM = ((somaM * 100.0f) / n); //determine a porcentagem de pessoas do sexo masculino que responderam que não gostaram do produto 51 | 52 | printf("\n %d %% das mulheres gostaram do produto \n %d %% dos homens nao gostaram do produto \n", somaF, somaM); 53 | 54 | // libera a memória alocada 55 | free(sexo); 56 | free(op); 57 | 58 | return 0; 59 | } -------------------------------------------------------------------------------- /root/vectors/question-3.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void preenche_ordenado(int n, int*vet){ 5 | 6 | int i,j, aux; 7 | 8 | for(i=0; ivet[j]){ 12 | vet[i] = vet[j]; 13 | vet[j] = aux; 14 | } 15 | } 16 | 17 | } 18 | 19 | } 20 | 21 | 22 | int main(void){ 23 | 24 | int n,i,j; 25 | 26 | printf("Insira a quatidade de elementos do vetor: \t"); 27 | scanf("%d", &n); 28 | 29 | int *vet; 30 | vet = (int*) malloc(n*sizeof(int)); 31 | 32 | for(i=0; i=0; j--){ 38 | printf("%d \t", vet[j]); 39 | } 40 | 41 | free(vet); 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /root/vectors/question-4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | 6 | /*Faça um programa que perunte ao user quantos valores eele deseja armazenar em um vetor tipo double com alocação dinamica, 7 | esse vetor deve ter um tamanho maior ou igual a 10. Abriua aos 10 primeiros elementos valores aleatorios com a função rand() entre 0 a 100 */ 8 | 9 | int main(void){ 10 | int tamanho; 11 | double *vetor; 12 | printf("Digite o tamanho do vetor: "); 13 | scanf("%d", &tamanho); 14 | while(tamanho<10){ 15 | printf("Digite um tamanho maior ou igual a 10: "); 16 | scanf("%d", &tamanho); 17 | } 18 | vetor = (double*)malloc(tamanho*sizeof(double)); 19 | int i; 20 | for(i=0; i<10; i++){ 21 | vetor[i] = rand()%100; 22 | } 23 | for(i=0; i<10; i++){ 24 | printf("%.0lf ", vetor[i]); 25 | } 26 | free(vetor); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /root/vectors/vetor-alocacao-dinamica.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/vectors/vetor-alocacao-dinamica.png -------------------------------------------------------------------------------- /root/vectors/vetores.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/roscibely/algorithms-and-data-structure/8edf1a2b427bf854a4392477bbcc9618d8665c77/root/vectors/vetores.png --------------------------------------------------------------------------------