├── .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 | 
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 | 
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 | 
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 | 
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 | 
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 | 
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 | 
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
--------------------------------------------------------------------------------