CES11 ALGORITMOS E ESTRUTURAS DE DADOS Aulas Prticas

CES-11 ALGORITMOS E ESTRUTURAS DE DADOS Aulas Práticas – 2019 Capítulo I Encadeamento de

Programa 1. 1: Alocação, preenchimento e escrita de uma nova estrutura #include <stdio. h>

Programa 1. 2: Alocação, preenchimento e escrita de 3 novas estruturas (visto em aula

n Seja a execução dos comandos: E a 2 prox a 3 prox E

a 2 E prox a 3 prox q E = (st *) malloc (sizeof(st));

Programa 1. 3: Inserindo cada estrutura no início do encadeamento typedef struct st st;

n Seja a execução dos comandos: ? E E = (st *) malloc (sizeof(st));

? E E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL;

a prox E E = (st *) malloc (sizeof(st)); E->a = 2; E->prox =

a 2 E prox q E = (st *) malloc (sizeof(st)); E->a = 2;

a prox a 2 E prox q E = (st *) malloc (sizeof(st)); E->a

a 3 E q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox

a 3 E prox a 2 prox q E = (st *) malloc (sizeof(st));

Programa 1. 4: Lendo o no de estruturas e os valores a serem nelas

/* Inicializacao do encadeamento E = NULL; */ Buffer do teclado i E n

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado /* Leitura do

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado 3 /* Leitura

/* Inicializacao do encadeamento */ E = NULL; 2 Buffer do teclado 3 5

/* Inicializacao do encadeamento */ E = NULL; 3 Buffer do teclado 5 /*

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado 5 /* Leitura

/* Inicializacao do encadeamento */ Buffer do teclado E = NULL; /* Leitura do

/* Escrita do conteudo do encadeamento de estruturas */ printf ("nn. Conteudo do encadeamento:

Programa 1. 5: Alterando o Programa 1. 4 para que a formação do encadeamento

/* main: cabecalho e declaracoes locais */ int main () { pontst E 1;

/* Funcao Novo. Encadeamento: forma um novo encadeamento de estruturas, preenchendo-o e retornando um

/* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) {

/* Funcao Escrever. Encadeamento: escreve o conteudo do encadeamento de estruturas acoplado ao parametro

Programa 1. 6: Alterando o Programa 1. 5 para que os elementos do encadeamento

Exercício 1. 1: Vetor de encadeamentos de habitantes de uma cidade n Fazer um

n Como sugestão, usar as seguintes declarações globais: /* Declaracoes dos tipos */ typedef

n E também as seguintes inclusões de arquivos: #include #include n <stdio. h> <stdlib.

/* main: cabecalho e declaracoes locais */ int main () { char c; int

/* Escrita dos nomes dos habitantes de cada encadeamento */ clrscr (); for (i

n Fazer a função Inserir. Habitante, para inserir um nome em uma das 26

n Fazer a função Escrever. Encadeamento para escrever no vídeo os nomes dos habitantes

Exercício 1. 2: Cruzamento de dois vetores de encadeamentos de habitantes de uma cidade

n Como sugestão, novas declarações globais: /* Declaracoes dos tipos */ typedef char string[16];

n Como sugestão, novas declarações globais: /* Declaracoes dos prototipos das funcoes auxiliares */

n O campo fet é um ponteiro para formar listas de habitantes com a

Exercício 1. 3 (exercício do Lab 1): Cruzamento de mais vetores de encadeamentos de

n As escolaridades deverão ser: Nenhuma, fundamental, médio, graduação, mestrado e doutorado. n Criar

Criar novas funções e aumentar a função main de forma a poder responder perguntas

n Tudo isso além de poder listar os habitantes com cada escolaridade e nascidos

Slides: 102

Download presentation

CES-11 ALGORITMOS E ESTRUTURAS DE DADOS Aulas Práticas – 2019 Capítulo I Encadeamento de Estruturas

Programa 1. 1: Alocação, preenchimento e escrita de uma nova estrutura #include <stdio. h> #include <stdlib. h> typedef struct st st; struct st {int a; st *prox; }; E ? a prox ? 2 ? Vídeo 2 int main () { st *E; E = (st *) malloc (sizeof(st)); Copiar, E->a = 2; salvar e printf ("%4 d", E->a); executar printf ("nn"); system ("pause"); return 0; }

Programa 1. 2: Alocação, preenchimento e escrita de 3 novas estruturas (visto em aula teórica) typedef struct st st; struct st {int a; st *prox; }; typedef st *pontst; Copiar, salvar e executar int main () { pontst E, q; E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); printf ("nn"); system ("pause"); return 0; }

n Seja a execução dos comandos: E a 2 prox a 3 prox E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); a 5 prox

a 2 E prox a 3 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); a 5 prox

a 2 E prox a 3 prox a 5 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo 2

a 2 E q prox a 3 prox a 5 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo 2

E a 2 prox a 3 prox a 5 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo 2

E a 2 prox a 3 prox a 5 q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 3; E->prox = (st *) malloc (sizeof(st)); E->prox->a = 5; E->prox->prox = NULL; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); prox q Vídeo 2 3

Programa 1. 3: Inserindo cada estrutura no início do encadeamento typedef struct st st; struct st {int a; st *prox; }; typedef st *pontst; Copiar, salvar e executar int main () { pontst E, q; E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); printf ("nn"); system ("pause"); return 0; }

n Seja a execução dos comandos: ? E E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

? E E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

a prox E E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

a 2 E prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

a prox a 2 E prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

a 3 E q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); prox a 2 prox q Vídeo

a 3 E prox a 2 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

a prox a 3 E prox a 2 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

E a 5 prox a 3 prox a 2 prox q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); Vídeo

a 5 E prox a 3 prox a 2 q q E = (st *) malloc (sizeof(st)); E->a = 2; E->prox = NULL; q = E; E = (st *) malloc (sizeof(st)); E->a = 3; E->prox = q; q = E; E = (st *) malloc (sizeof(st)); E->a = 5; E->prox = q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); prox A inserção no início é mais simples que no final Usa-se quando a ordem de armazenamento for irrelevante Vídeo 5 3 2

Programa 1. 4: Lendo o no de estruturas e os valores a serem nelas guardados (inserindo sempre no início) #include <stdio. h> #include <stdlib. h> /* Declaracoes dos tipos */ typedef struct st st; struct st {int a; st *prox; }; typedef st *pontst; /* main: cabecalho e declaracoes locais */ int main () { int i, n; pontst E, q;

Buffer do teclado i E n

/* Inicializacao do encadeamento E = NULL; */ Buffer do teclado i E n

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); i E n

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado 3 /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); i E n

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); i E n 3

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); /* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%d", &E->a); E->prox = q; } } E i n 3

/* Inicializacao do encadeamento */ E = NULL; 2 Buffer do teclado 3 5 /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); /* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%d", &E->a); E->prox = q; } } i 1 n E q 3

/* Inicializacao do encadeamento */ E = NULL; 3 Buffer do teclado 5 /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); /* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%d", &E->a); E->prox = q; } } E i 1 n 2 q 3

/* Inicializacao do encadeamento */ E = NULL; Buffer do teclado 5 /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); /* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%d", &E->a); E->prox = q; } } E i 2 n 3 2 q 3

/* Inicializacao do encadeamento */ Buffer do teclado E = NULL; /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n); /* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%d", &E->a); E->prox = q; } } E i 5 3 q 3 n 2 3

/* Escrita do conteudo do encadeamento de estruturas */ printf ("nn. Conteudo do encadeamento: nnt"); for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); /* Fechamento da tela e encerramento */ printf ("nn"); system ("pause"); return 0; } i E 5 3 q 4 n 2 3

Programa 1. 5: Alterando o Programa 1. 4 para que a formação do encadeamento e a escrita do mesmo fiquem em funções auxiliares #include <stdio. h> #include <stdlib. h> /* Declaracoes dos tipos */ typedef struct st st; struct st {int a; st *prox; }; typedef st *pontst; /* Declaracoes dos prototipos das funcoes auxiliares */ pontst Novo. Encadeamento (void); void Escrever. Encadeamento (pontst);

/* main: cabecalho e declaracoes locais */ int main () { pontst E 1; /* Formacao de um encadeamento */ printf ("Formacao de um encadeamento: nn"); E 1 = Novo. Encadeamento (); /* Escrita do conteudo do encadeamento formado */ printf ("n. Conteudo do encadeamento: nnt"); Escrever. Encadeamento (E 1); /* Encerramento */ printf ("nn"); system ("pause"); return 0; }

/* Funcao Novo. Encadeamento: forma um novo encadeamento de estruturas, preenchendo-o e retornando um ponteiro para primeira estrutura do encadeamento */ pontst Novo. Encadeamento () { int i, n; pontst E, q; /* Inicializacao do encadeamento */ E = NULL; /* Leitura do numero de estruturas */ printf ("Digite o numero de elementos do encadeamento: "); scanf ("%d", &n);

/* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%d", &E->a); E->prox = q; } } /* Retornando o ponteiro para a primeira estrutura */ Na função main: return E; E 1 = Novo. Encadeamento (); } E E 1 (main) 5 3 2

/* Funcao Escrever. Encadeamento: escreve o conteudo do encadeamento de estruturas acoplado ao parametro E */ void Escrever. Encadeamento (pontst E){ pontst q; for (q = E; q != NULL; q = q->prox) printf ("%4 d", q->a); } Copiar, salvar e executar Na função main: Escrever. Encadeamento (E 1); 5 E 1 (main) E 3 2

Programa 1. 6: Alterando o Programa 1. 5 para que os elementos do encadeamento sejam nomes, em vez de números #include <stdio. h> #include <stdlib. h> /* Declaracoes dos tipos */ typedef char string[31]; typedef struct st st; struct st {string nome; st *prox; }; typedef st *pontst; /* Declaracoes dos prototipos das funcoes auxiliares */ pontst Novo. Encadeamento (void); void Escrever. Encadeamento (pontst);

/* Formacao e preenchimento do encadeamento de estruturas */ if (n > 0) { printf ("n. Digite os elementos: "); for (i = 1; i <= n; i++) { q = E; E = (st *) malloc (sizeof(st)); scanf ("%s", E->nome); E->prox = q; } } /* Retornando o ponteiro para a primeira estrutura */ return E; }

Exercício 1. 1: Vetor de encadeamentos de habitantes de uma cidade n Fazer um programa para montar um vetor de 26 encadeamentos de habitantes de uma cidade, sendo cada encadeamento correspondente a uma letra do alfabeto n No encadeamento correspondente a uma determinada letra, os nomes dos habitantes que ali aparecem devem ser iniciados por tal letra, seja ela maiúscula ou minúscula n Nomes não iniciados por letras não devem ser

Exemplo:

n Como sugestão, usar as seguintes declarações globais: /* Declaracoes dos tipos */ typedef char string[16]; typedef struct habitante; struct habitante {string nome; habitante *inic; }; typedef habitante *ponthab; /* Variavel global */ ponthab Letra[26] = {NULL}; /* Declaracoes dos prototipos das funcoes auxiliares */ void Inserir. Habitante (string);

n E também as seguintes inclusões de arquivos: #include #include n <stdio. h> <stdlib. h> <conio. h> <ctype. h> <string. h> E ainda a função main a seguir:

/* main: cabecalho e declaracoes locais */ int main () { char c; int i; string nome; /* Insercao dos habitantes dados por seus nomes*/ printf ("Inserir nome? (s/n): "); do scanf ("%c", &c); while (c!='s' && c!='n' && c!='S' && c!='N'); while (c == 's' || c == 'S') { clrscr (); printf ("Nome: "); setbuf (stdin, NULL); scanf ("%s", nome); Inserir. Habitante (nome); printf ("nn. Inserir nome? (s/n): "); do scanf ("%c", &c); while (c!='s' && c!='n' && c!='S' && c!='N'); }

/* Escrita dos nomes dos habitantes de cada encadeamento */ clrscr (); for (i = 0; i <= 25; i++) if (Letra[i] != NULL) { printf ("n%c: ", i+65); Escrever. Encadeamento (Letra[i]); printf ("n"); } /* Encerramento */ printf ("nn"); system ("pause"); return 0; }

n Fazer a função Inserir. Habitante, para inserir um nome em uma das 26 listas, conforme sua inicial n Para a inserção, não diferenciar maiúsculas de minúsculas e não inserir nomes que não comecem por letras, sendo: n Inicial ‘A’ ou ‘a’: Letra[0]; Inicial ‘B’ ou ‘b’: Letra[1]; n . . . n Inicial ‘Z’ ou ‘z’: Letra[25]

n Fazer a função Escrever. Encadeamento para escrever no vídeo os nomes dos habitantes de um encadeamento genérico do vetor, fornecido como argumento

Exercício 1. 2: Cruzamento de dois vetores de encadeamentos de habitantes de uma cidade n Aumentar o programa do exercício anterior para montar um outro vetor de 6 encadeamentos dos mesmos habitantes daquele exercício, sendo cada encadeamento correspondente a uma das seguintes faixas etárias: Bebê, criança, adolescente, jovem, adulto e idoso n As idades para essas faixas etárias são dadas por: Bebê: até 2 anos; Adolescente: de 12 a 17 anos; Criança: de 3 a 11 anos; Jovem: de 18 a 30 Adulto: de 31 a 60 anos; Idoso: a partir de 61 anos;

Exemplo:

n Como sugestão, novas declarações globais: /* Declaracoes dos tipos */ typedef char string[16]; typedef enum faixa; enum faixa {bebe, crianca, adolescente, jovem, adulto, idoso}; string nomefaixa[6] = {"Bebes", "Criancas", "Adolescentes", "Jovens", "Adultos", "Idosos"}; typedef struct habitante; struct habitante {string nome; int idade; habitante *inic, *fet; }; typedef habitante *ponthab; /* Variaveis globais */ ponthab Letra[26] = {NULL}; ponthab Faixa. Etaria[6] = {NULL};

n Como sugestão, novas declarações globais: /* Declaracoes dos prototipos das funcoes auxiliares */ void Inserir. Habitante (string, int); void Escrever. Encadeamento. Letras. Iniciais (ponthab); void Escrever. Encadeamento. Faixa. Etaria (ponthab);

n O campo fet é um ponteiro para formar listas de habitantes com a mesma faixa etária n Alterar a função Inserir. Habitante do exercício anterior para formar vetores cruzados das listas daquele exercício com as de faixas etárias n Fazer uma função para escrever no vídeo os nomes de uma lista encadeada pelo campo fet, fornecida como argumento n Aumentar a função main de forma a ler também a idade de cada habitante e a formar e escrever também as listas das faixas etárias

Exercício 1. 3 (exercício do Lab 1): Cruzamento de mais vetores de encadeamentos de habitantes de uma cidade Incluir na estrutura habitante campos para: n Guardar a escolaridade de cada habitante n Guardar a sigla do estado de nascimento de cada habitante, supondo que só haja brasileiros no processo n Formar encadeamentos de todos os habitantes com mesma escolaridade n Formar encadeamentos de todos os habitantes nascidos num mesmo estado

n As escolaridades deverão ser: Nenhuma, fundamental, médio, graduação, mestrado e doutorado. n Criar um vetor de encadeamentos de habitantes contendo cada um todos os habitantes com a mesma escolaridade n Criar outro vetor em que cada encadeamento contenha todos os habitantes nascidos num mesmo estado

Criar novas funções e aumentar a função main de forma a poder responder perguntas do tipo: n Quais os habitantes nascidos num determinado estado com um determinado grau de escolaridade? n Quais os habitantes nascidos num determinado estado pertencentes a uma determinada faixa etária? n Quais os habitantes de uma determinada faixa etária com um determinado grau de escolaridade nascidos num determinado estado? n Quais os habitantes de uma determinada faixa etária com os nomes iniciados por uma determinada letra?

n Tudo isso além de poder listar os habitantes com cada escolaridade e nascidos em cada estado n Este exercício é parte do Lab 1 de CES-11/2019 n A proposta completa de tal laboratório está no documento intitulado “ 1º Laboratório de CES 11/2019 – Turma 4”, que se encontra na aba de Laboratórios do professor n O aluno deverá estudar cuidadosamente esse documento e aproveitar as sugestões apresentadas no presente conjunto de slides, para realizar o laboratório n Não é necessário entregar os exercícios apresentados