Buscar

Aula 06 - Estruturas de dados homogêneas I - Vetores Numéricos

Prévia do material em texto

DCC 119 Algoritmos
2
Em diversas situações os tipos básicos de dados 
(inteiro, real, caracter, ....) não são suficientes para 
representar a informação que se deseja armazenar. 
Exemplo, uma palavra: AULA .
Valor de 50 produtos em uma loja
Existe a possibilidade de construção de novos tipos 
de dados a partir da composição (ou abstração) de 
tipos de dados primitivos.
Esses novos tipos têm um formato denominado 
ESTRUTURA DE DADOS, que define como os tipos 
primitivos estão organizados.
Estruturas de Dados
3
Problema 1: Como poderíamos fazer um 
algoritmo para ler 50 notas de uma turma e 
calcular sua média?
Motivação
principal
{ 
inteiro i; //variável de controle
real nota, media, soma = 0;
para (i 1; i <= N; i i+1) faça
{
imprima("Digite uma nota:");
leia(nota);
soma soma + nota;
}
media soma/N;
imprima("Media = ", media);
}
Problema: 
Qual o valor 
da 1a ou 5a
ou 40a nota?
4
Problema 2: Fazer um programa para ler 50 notas de uma 
turma e calcular a sua média. Imprimir as notas lidas juntamente
com a média da turma como na tabela. 
Motivação
Nota Media
8.0 7.75
4.6 7.75
2.3 7.75
3.7 7.75
7.8 7.75
9.0 7.75
.... ...
Como fazê-lo? No exemplo 
anterior, uma nota é
sobreposta por outra em 
cada iteração do para.
A solução é armazenar 
todas as 50 notas lidas...
Mas como?!?
5
Quando uma determinada estrutura de dados 
for composta de variáveis com o mesmo tipo 
primitivo, temos um conjunto homogêneo de 
dados.
Essas variáveis são chamadas de variáveis 
compostas homogêneas.
Variáveis Compostas Homogêneas
6
As variáveis compostas homogêneas 
unidimensionais são utilizadas para 
representar arranjos unidimensionais de 
elementos de um mesmo tipo, em outras 
palavras, são utilizadas para representar 
vetores.
Variáveis Compostas Homogêneas 
Unidimensionais (Vetores)
7
A sintaxe para declaração de uma variável deste tipo, tanto na 
pseudolinguagem quanto em C é a seguinte:
tipo identificador [qtd de elementos];
Exemplo:
// vetor com 5 elementos do tipo inteiro
inteiro dados[5] ; // em C seria ficaria int dados[5];
Vetores: Declaração
0 1 2 3 4
dados
5 elementos quaisquer do tipo inteiro
Í ndices do vetor
8
Cada um dos elementos de um vetor é referenciado individualmente por meio de 
um número inteiro entre colchetes após o nome do vetor.
Exemplos:
Considerando o vetor dados, quais valores serão atribuídos a X e Y nos exemplos 
abaixo???
A instrução abaixo atribui um valor ao elemento 0 (zero) do vetor dados:
Vetores: Referência (Manipulação)
0 1 2 3 4
dados 3 2 74 1
PseudoLinguagem
X dados[1]; 
Y dados[4];
Linguagem c
dados[0] = 6; ou
I = 0;
dados[i] = 6; 
PseudoLinguagem
dados[0] 6; ou
I 0;
dados[i] 6; 
Linguagem c
X = dados[1]; 
Y = dados[4];
9
O programa a seguir, usa o comando para para inicializar com zeros 
os elementos de um array inteiro n de 10 elementos e o imprime sob 
a forma de uma tabela. 
Vetores: Exemplos
principal
{
inteiro n[10], i;
para (i 0; i <= 9; i i+1) faça
{
n[i] 0;
}
imprima("Elemento Valor");
para (i 0; i <= 9; i i+1) faça
{
imprima(i," ", n[i]);
}
}
Elemento Valor
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
10
Exemplo anterior em C:
Vetores: Exemplos
//inicializando um vetor (array)
#include <stdio.h>
int main()
{
int n[10], i;
for (i=0; i<= 9; i++)
{
n[i] = 0;
}
printf("%s%13s\n","Elemento", "Valor");
for (i=0; i<= 9; i++)
{
printf("%7d%13d\n",i,n[i]);
}
return 0;
}
Elemento Valor
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
11
O programa abaixo inicializa os dez elementos de um array s com os 
valores: 2, 4, 6, ..., 20 e imprime o array em um formato de tabela. 
Vetores: Exemplos
Elemento Valor
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
principal
{
constante inteiro TAMANHO 10;
inteiro s[TAMANHO], j;
para (j 0; j <= TAMANHO - 1; j j+1) faça
{
s[j] 2 + 2*j;
}
imprima("Elemento Valor"); 
para (j 0; j <= TAMANHO - 1; j j+1) faça
{
imprima (j, " ",s[j]);
}
}
12
Vetores: Exemplos
#include <stdio.h>
#define TAMANHO 10
int main()
{
int s[TAMANHO], j;
for (j=0; j<= TAMANHO - 1; j++)
{
s[j] = 2 + 2*j;
}
printf("%s%13s\n","Elemento", "Valor");
for (j=0; j<= TAMANHO - 1; j++)
{
printf("%8d%13d\n",j,s[j]);
}
return 0;
}
Elemento Valor
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
Exemplo anterior em C:
13
Em pseudolinguagem, a passagem de parâmetros 
em procedimentos e funções é feita por cópia. Para 
realizar a passagem por referência, utilize a palavra 
ref antes do tipo de vetor.
Em C, vetores são passados sempre por referência.
14
No exemplo abaixo é apresentado um procedimento imprimeVetor
que imprime um vetor de tamanho tam.
imprimeVetor (inteiro vet[], inteiro tam)
{
inteiro i;
para (i 0; i <= tam - 1; i i+1) faça
{
imprima (vet[i]);
}
}
principal
{
constante inteiro TAMANHO 10;
inteiro s[TAMANHO], j;
para (j 0; j <= TAMANHO - 1; j j+1)
{
imprima ("Informe o valor do vetor na posição ", j);
leia (s[j]);
}
imprimeVetor(s, TAMANHO);
}
15
Exemplo anterior em C:
#include <stdio.h>
#define TAMANHO 10
void imprimeVetor (int vet[], int tam)
{
int i;
for (i = 0; i <= tam - 1; i++)
{
printf("%d\n", vet[i]);
}
}
int main()
{
int s[TAMANHO], i;
for (i = 0; i <= tam - 1; i++)
{
printf ("Informe o valor do vetor na posição %d: ", i);
scanf ( %d", &s[j]);
}
imprimeVetor(s, TAMANHO);
}
16
Vamos ver agora o teste de mesa para o 
seguinte problema:
Criar uma função que receba um vetor de 
números reais e seu tamanho e retorne o índice 
do maior valor contido no vetor. Se houver mais 
de uma ocorrência do maior valor, retornar o 
índice do primeiro. Faça um programa principal 
para testar a função.
17
Exercício 1 - Solução Proposta
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior)
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
18
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior)
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Inicialmente são 
criadas as variáveis
19
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior)
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Chama a função 
encontraMaior
20
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior)
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Vetor e seu 
tamanho são 
passados como 
parâmetro
21
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior)
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 3.0
indice = 0
Variávies locais da 
função são inicializadas
22
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se(vet[i] > maior)
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 3.0
indice = 0
i = 1
Começa a busca pelo 
índice 1, uma vez que o 
índice zero já foi utilizada 
para inicializar a variável 
indice
23
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 4.3 > 3.0 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 3.0
indice = 0
i = 1
Executa o primeiro teste
24
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 4.3 > 3.0 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 4.3
indice = 1
i = 1
Sendo o teste verdadeiro, 
atualiza variáveis maior e 
indice.
25
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 4.3
indice = 1
i = 2
Passa para a próxima 
iteração do loop.
26
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 5.6 > 4.3 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 4.3
indice = 1
i = 2
Mais um teste verdadeiro.
27
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 5.6 > 4.3 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 2
Sendo o teste verdadeiro, 
atualiza variáveis maior e 
indice.
28
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 3
Passa para a próxima 
iteração do loop.
29
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 2.8 > 5.6 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 3
Valor do vetor é menor, 
não entra na condição.
30
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 4
Passa para a próxima 
iteração do loop.
31
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 7.9 > 5.6 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 5.6
indice = 2
i = 4
Mais um teste verdadeiro.
32
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 7.9 > 5.6 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 4
Sendo o teste verdadeiro, 
atualiza variáveis maior e 
indice.
33
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 4
Passa para a penúltima 
iteração do loop.
34
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( 3.4 > 7.9 )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 4
Valor do vetor é menor, 
não entra na condição.
35
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
Passa para a última 
iteração do loop (nesse 
caso, não entra)
36
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne 4;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
Retorna o valor do maior 
valor
37
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;
posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
posicao = 4
Volta para a função principal, 
pegando o retorno do índice 
do maior valor
38
Exercício 1 - Teste de Mesa
int encontraMaior (real vet[], inteiro tam)
{
inteiro indice, i;
real maior = vet[0];
indice 0;
para (i 1; i < tam; i i+1) faça
{
se( vet[i] > maior )
{
maior vet[i];
indice i;
}
}
retorne indice;
}
principal
{
real vetor[6] = {3.0, 4.3, 5.6, 2.8, 7.9, 3.4};
inteiro posicao;posicao encontraMaior( vetor, 6)
imprima("Maior valor esta na posicao ", posicao);
}
Variáveis
maior = 7.9
indice = 4
i = 5
posicao = 4
Maior valor esta na posicao 4
Imprime o índice do 
maior valor
39
Criar uma função em C que receba um vetor 
de números reais e um valor inteiro 
representando o seu tamanho. Essa função 
deverá ordenar o vetor em ordem crescente.
40
Exercício 2 - Solução Proposta
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
41
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Vamos supor para esse 
exercício que o vetor de 
entrada tenha 5 posições e 
os seguintes valores
11.0, 22.0, 3.0, 44.0, 5.0
42
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Inicialmente função é
chamada passando-se 
os valores propostos
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
43
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
A seguir são criadas as 
variáveis auxiliares
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 
j = 
aux = 
44
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
A idéia central é ir puxando
os menores valores através de 
trocas para o início do vetor
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 
aux = 
45
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
É no loop interno que iremos iterar 
sobre o vetor efetuando essas trocas, 
conforme os menores valores forem 
sendo identificados.
Repare que iremos iterar do último 
elemento até o elemento i+1.
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 
46
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Os testes são feitos sempre entre os 
valores i e o seu antecessor (i-1)
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 
47
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
Como é menor, efetua a troca
5.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 5.0
48
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.044.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 5.0
49
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 44.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 4
aux = 5.0
50
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 3
aux = 5.0
51
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 3.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 3
aux = 5.0
Aqui o teste falha. Vai para a próxima 
iteração do loop interno.
52
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 2
aux = 5.0
53
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.03.022.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 2
aux = 5.0
54
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.03.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 2
aux = 3.0
Como valor é menor, efetua a troca 
como visto anteriormente.
55
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.03.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 1
aux = 3.0
56
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.03.011.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 1
aux = 3.0
57
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 3.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 1
aux = 3.0
Como valor é menor, efetua a troca 
como visto anteriormente.
58
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 0 
j = 0
aux = 3.0
Nesse ponto, como j = 0, saiu do laço 
interno e volta para o externo.
59
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 0
aux = 3.0
Como o i é incrementado, a posição 
0 do vetor não será mais modificada
60
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 4
aux = 3.0
61
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 5.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 4
aux = 3.0
62
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 3
aux = 3.0
63
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.05.022.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 3
aux = 3.0
64
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 5.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.05.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 3
aux = 5.0
Como valor é menor, efetua a troca 
como visto anteriormente.
65
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.05.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 2
aux = 5.0
66
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (5.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.05.011.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 2
aux = 5.0
67
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (5.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 2
aux = 5.0
Como valor é menor, efetua a troca 
como visto anteriormente.
68
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 1 
j = 1
aux = 5.0
Nesse ponto, como j = 1, saiu do laço 
interno e volta para o externo.
69
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if (vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 1
aux = 5.0
Como o i é incrementado, a posição 
1 do vetor não será mais modificada
70
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 4
aux = 5.0
71
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 22.0 < 11.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 3
aux = 5.0
72
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 2 
j = 2
aux = 5.0
Como j = 2, saiu do laço interno e 
volta para o externo.
73
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 3 
j = 2
aux = 5.0
Como o i é incrementado, a posição 
2 do vetor não será mais modificada
74
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 3 
j = 4
aux = 5.0
75
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 3 
j = 3
aux = 5.0
Como j = 3, saiu do laço interno e 
volta para o externo.
76
Exercício 2 Teste de Mesa
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( 44.0 < 22.0 )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
44.022.011.05.03.0
0 1 2 3 4 
Variáveis:
tam = 5
i = 4 
j = 3
aux = 5.0
Como o i é incrementado, e sai do laço 
externo, finalizando a procedimento.
77
#include <stdio.h>
void ordena(float vet[], int tam)
{
int i, j;
float aux;
for(i = 0; i <= (tam-2); i++)
{
for(j = tam-1; j > i; j--)
{
if ( vet[j] < vet[j-1] )
{
aux=vet[j];
vet[j]= vet[j-1];
vet[j-1]=aux;
}
}
}
}
int main()
{
int i;
float vet[5]={11.0,22.0,3.0,44.0,5.0}; 
ordena(vet, 5);
for (i=0; i < 5; i++)
printf("%.2f\n",vet[i]);
return 0;
}
Programa Completo
78
Exercícios
1) Quais são os elementos do vetor referenciados pelas 
expressões abaixo ?
vet
a) vet[3] b) vet[0] c) vet[13]
2) Qual é a diferença entre os números 3 das duas 
instruções abaixo ?
inteiro vet[3];
vet[3] 5;
1 2 4 7 4 2 8 9 0 6 5 4 3
79
Exercícios
3) Dada um tabela contendo a idade de 10 alunos, faça um algoritmo que 
calcule o número de alunos com idade superior a média.
4) Faça um algoritmo para ler e somar dois vetores de 10 
elementos inteiros. Imprima ao final os valores dessa soma.
5) Refaça o exercício anterior criando um procedimento para 
efetuar a leitura dos vetores e um segundo procedimento que 
imprimirá a soma dos vetores.
80
Exercícios
6) Refaça o exercício anterior criando uma funçãoque receba 
o vetor com a idade dos alunos e retorne a quantidade de 
alunos com idade superior a média.
7) Faça um algoritmo que leia, via teclado, 20 valores do tipo 
inteiro e determine qual o menor valor existente no vetor e 
imprima valor e seu índice no vetor.
8) Refaça o exercício anterior criando um procedimento que 
receba como parâmetro o vetor e imprima o menor valor e 
seu índice no vetor.
81
DCC 120
82
O vetor é uma estrutura: 
Homogênea 
Estática
Todas as componentes são de um mesmo tipo 
e seu tamanho permanece o mesmo durante 
toda a execução do programa.
Vetores
83
A sintaxe em C para declaração de variável do tipo 
vetor é a seguinte
tipo_primitivo identificador[qtde_elementos];
Exemplo:
// vetor com 5 (0 a 4) elementos do tipo int
int dados[5];
Vetores: Declaração
0 1 2 3 4
dados
5 elementos quaisquer do tipo int
Í ndices do vetor
84
Cada um dos elementos de um vetor é referenciado individualmente por meio de 
um número inteiro entre colchetes após o nome do vetor.
Exemplos:
X = valores[1]; //atribui a x o valor da posição 1 do vetor valores
Y = valores[4]; //atribui a x o valor da posição 4 do vetor valores
valores[0] = 3.2; // a posição zero do vetor valores recebe o valor 3.2
Vetores: Referência 
(Manipulação)
0 1 2 3 4
valores 3.6 2.7 7.94.2 1.2
85
É possível fornecer valores a cada elemento de 
um vetor no momento da sua declaração. 
Exemplo:
float valores[5] = {3.6, 2.7, 4.2, 7.9, 1.2};
float nros[5] = {0.0}; // como fica o vetor????
Vetores: Inicialização
0 1 2 3 4
valores 3.6 2.7 7.94.2 1.2
86
Observações:
Os vetores NÃO são automaticamente inicializados!!! 
Se houver menos valores do que o número de elementos do vetor ,
os elementos restantes são inicializados automaticamente com o valor 
zero.
int n[5] = {32, 64, 27};
A seguinte declaração causa um erro de sintaxe:
int n[5] = {32, 64, 27, 18, 95, 14};
O tamanho do vetores pode ser omitido:
int n[ ] = {1, 2, 3, 4, 5};
Vetores: Inicialização
87
Vetores: Exemplo
Leia um vetor de 10 posições (inteiros) e imprima-o na ordem 
invertida (da última para a primeira posição).
#include <stdio.h>
#include <stdlib.h>
int main()
{
int numeros[10],i;
for (i=0; i<10;i++){
printf("Digite valor %d: ",i);
scanf("%d", &numeros[i]);
}
printf("Vetor na ordem invertida:\n");
for (i=9; i>=0; i--)
printf("%d\n",numeros[i]);
return 0;
}
88
Em C, vetores são passados sempre por 
referência.
Ou seja, as modificações feitas na subrotina
refletem nos dados do vetor passado como 
parâmetro pela função chamadora. 
89
O exemplo a seguir apresenta subrotinas
para leitura e impressão do vetor e cálculos 
do maior, menor e média dos elementos. 
90
Vetores e Subrotinas: Exemplo (1/3)
#include <stdio.h>
#define TAMANHO 10
void leVetor(int vet[], int tam)
{
int i;
for(i = 0; i < tam; i++)
{
printf("Informe o valor do vetor na posição %d: ", i);
scanf("%d", &vet[i]);
}
}
void imprimeVetor(int vet[], int tam)
{
int i;
printf("Vetor: ");
for(i = 0; i < tam; i++)
{
printf("%d ", vet[i]);
}
}
91
Vetores e Subrotinas: Exemplo (2/3)
int maiorElemento(int vet[], int tam)
{
int i, maior = vet[0];
for(i = 1; i < tam; i++)
{
if(vet[i] > maior)
maior = vet[i];
}
return maior;
}
int menorElemento(int vet[], int tam)
{
int i, menor = vet[0];
for(i = 1; i < tam; i++)
{
if(vet[i] < menor)
menor = vet[i];
}
return menor;
}
92
Vetores e Subrotinas: Exemplo (3/3)
float mediaVetor(int vet[], int tam)
{
int i, soma = 0;
for(i = 0; i < tam; i++)
{
soma = soma + vet[i];
}
return soma / (float)tam;
}
int main()
{
int v[TAMANHO];
leVetor(v, TAMANHO);
imprimeVetor(v, TAMANHO);
printf("\nO maior elemento do vetor é %d.", maiorElemento(v, TAMANHO));
printf("\nO menor elemento do vetor é %d.", menorElemento(v, TAMANHO));
printf("\nA média dos valores do vetor é %.2f.",mediaVetor(v, TAMANHO));
return 0;
} 
93
Exercícios
1) Desenvolva um programa que leia um vetor de números reais, um
escalar e imprima o resultado da multiplicação do vetor pelo escalar.
2) Faça um procedimento que faça a leitura um vetor de 10 elementos 
inteiros e imprima somente os valores armazenados nos índices pares. 
3) Faça um programa que leia um vetor com 15 valores reais. A seguir, 
encontre o menor elemento do vetor e a sua posição dentro do vetor, 
mostrando: O menor elemento do vetor esta na posição XXXX e tem o 
valor YYYYY.
4) Faça um programa que leia um vetor de 15 posições (reais) e depois 
um valor a ser procurado no vetor. Imprima se o valor foi ou não
encontrado e a quantidade de vezes que o valor está presente no vetor.
94
Exercícios
5) Faça uma função que receba um vetor de números inteiros e um
valor inteiro. A função deverá procurar este segundo valor neste vetor e 
retornar seu índice se for encontrado. Se o elemento não for encontrado, 
retornar -1.
6) Dada uma tabela com as notas de uma turma de 20 alunos, faça 
funções que retornem:
a) A média da turma.
b) a quantidade de alunos aprovados (>=60)
c) a quantidade de alunso reprovados.(< 60)
7) Faça um programa que leia um conjunto de 20 valores e armazene-os 
num vetor V. Particione-o em dois outros vetores, P e I, conforme os 
valores de V forem pares ou ímpares. No final, imprima os valores dos 3 
vetores.
95
Exercícios
8) Faça um programa que leia um vetor G[13] que é o gabarito de um 
teste da loteria esportiva, contendo os valores 1 quando for coluna 1, 0 
quando for coluna do meio e 2 quando for coluna 2. 
Ler a seguir, para 5 apostadores, seu cartão de apostas (R[13]) e depois 
da leitura imprimir quantos acertos o apostador teve.
Faça o teste através de funções.
9) Com relação ao exercício anterior, calcule e mostre o percentual dos 
apostadores que fizeram de 10 a 13 pontos e o percentual dos 
apostadores que fizeram menos do que 10 pontos.
10) Faça um programa que leia um vetor de valores inteiros e imprima-o 
na ordem crescente. O vetor deve ter tamanho N (utilize a diretiva 
#define).

Outros materiais