Vetores em C

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Vetores em C 
1 Variáveis Compostas Homogêneas Unidimensionais – Vetores em C 
As Variáveis Compostas Homogêneas Unidimensionais ou Vetores correspondem 
a posições de memória (variáveis) identificadas por um mesmo nome, onde uma posição 
individual é acessada por um índice e cujo conteúdo é do mesmo tipo de dado. Em outras 
palavras, um vetor pode ser definido como um conjunto finito e ordenado de elementos 
homogêneos. Por finito entende-se que existe um número específico de elementos no vetor; 
por ordenado entende-se que os elementos do vetor são organizados de tal forma que exista 
um elemento 0, um elemento 1, elemento 2, um elemento 3 e assim por diante, onde 0, 1, 2, 
3,... são os índices; por homogêneo entende-se que todos os elementos do vetor precisam ser 
do mesmo tipo de dados. 
Sintaxe de declaração em C: 
 
tipo-de-dado nome[tamanho]; 
 
onde: 
nome: é o nome do vetor; 
tamanho: é a quantidade máxima de elementos (posições) do vetor; 
tipo-de-dado: é um tipo de dado válido em C. 
 
 A referência ao conteúdo do n-ésimo elemento de um vetor tem a sintaxe: 
 
nome[n] 
 
onde: 
nome: é o nome do vetor; 
n é o índice que corresponde a um número inteiro ou uma variável do tipo inteiro. 
 
Em C, considera-se que o primeiro elemento tem o índice 0. 
 
 Exemplo de vetor: 
 
/* Declaração de um vetor de nome nota que pode conter até 10 
 elementos */ 
float nota[10]; 
 
 2 
Esquematicamente tem-se: 
 
nota 5.5 6.0 9.0 2.5 4.5 9.5 7.0 8.5 7.5 3.0 
 0 1 2 3 4 5 6 7 8 9 
 
 
 
 
Para atribuir um valor a n-ésima posição de um vetor, usa-se a seguinte sintaxe: 
 
 nome[n] = valor; 
 
onde: 
nome: é o nome do vetor; 
n é o índice que corresponde a um número inteiro ou uma variável do tipo inteiro; 
valor é uma variável ou um valor do mesmo tipo de dado do vetor. 
 
 Considerando o vetor do exemplo anterior, para atribuir o valor 9.5 para a posição 5, 
faz-se: 
 nota[5] = 9.5; 
2 Usando Vetores 
Um vetor é usado para manter uma grande quantidade de elementos de dados na 
memória e para referenciar todos os elementos de maneira uniforme. 
Supor a necessidade de ler 100 notas, calcular sua média aritmética e determinar o 
quanto cada nota se desvia dessa média. Nesse caso é necessário que as 100 notas lidas sejam 
armazenadas em variáveis para que o desvio seja calculado após o cálculo da média 
aritmética. Utilizar 100 variáveis para armazenar as 100 notas seria uma solução, mas o 
código do programa ficaria um tanto extenso, pois além de declarar 100 variáveis, seria 
necessário escrever código para 100 leituras de variáveis e 100 cálculos de desvios. Então, a 
solução é agrupar as 100 notas em uma única variável composta homogênea, ou seja, em um 
vetor. 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[100] /* vetor de notas */: numérico real; 
 i /* conterá os índices do vetor */: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das notas */ 
 para i ← 0 até 99 passo 1 faça 
 início 
 escreva(“Digite uma nota”); 
 leia(nota[i]); 
 soma ← soma + nota[i]; 
 fim 
 media ← soma/100; 
 escreva(“Media = ”, media); 
 /* Cálculo dos devios */ 
 para i ← 0 até 99 passo 1 faça 
 início 
desvio ← nota[i] – media; 
escreva(“Desvio da nota ”, nota[i], desvio); 
 fim 
fim 
nota[5] 
 3 
Em C fica: 
 
#include <stdio.h> 
main() 
 { 
 float soma, media, desvio, nota[100] /* vetor de notas */; 
 int i /* conterá os índices do vetor */; 
 soma = 0; /* valor inicial para a sumarização das notas */ 
 for (i = 0; i < 100; i++) 
 { 
 printf(“Digite uma nota: ”); 
 scanf(“%f”, &nota[i]); 
 soma = soma + nota[i]; 
 } 
 media = soma/100; 
 printf(“Media = %f”, media); 
 /* Cálculo dos devios */ 
 for (i = 0; i < 100; i++) 
 { 
 desvio = nota[i] – media; 
 printf(“Desvio da nota %f = %f”, nota[i], desvio); 
 } 
} 
 
É possível escrever o algoritmo anterior, solicitando do usuário a quantidade de notas 
ao invés de fixar em 100. O problema é que um vetor tem que ter um tamanho máximo e, 
nesse caso, é necessário garantir que o usuário entre com a quantidade de notas menor ou 
igual ao tamanho máximo. Ou seja, não há necessidade de utilizar todas as posições de um 
vetor, mas nunca se deve utilizar posições além de seu tamanho máximo. O tamanho mínimo 
também deve ser garantido – maior que 0. 
Algoritmo 
 início 
 declare soma, media, desvio, 
 nota[100] /* vetor de notas */: numérico real; 
 tam, i /* índices do vetor */: numérico inteiro; 
 /* Entrada da quantidade de notas e verificação dos limites 
 do vetor */ 
repita 
 escreva(“Digite a quantidade de notas – mínimo 1 e máximo 
100: ”); 
 leia(tam); 
 se (tam > 100 ou tam ≤ 0) 
 então escreva(“Quantidade de notas inválida”); 
 até (tam > 0 e tam ≤ 100); 
 soma ← 0; /* valor inicial para a sumarização das notas */ 
 para i ← 0 até tam-1 passo 1 faça 
 início 
 escreva(“Digite uma nota”); 
 leia(nota[i]); 
 soma ← soma + nota[i]; 
 fim 
 media ← soma/tam; 
 escreva(“Media = ”, media); 
 /* Cálculo dos devios */ 
 para i ← 0 até tam-1 passo 1 faça 
 início 
desvio ← nota[i] – media; 
 4 
escreva(“Desvio da nota ”, nota[i], desvio); 
 fim 
fim 
 
Em C ainda é possível dar um nome ao tamanho máximo do vetor por meio de 
#define, sendo que se for necessário modificar o tamanho máximo do vetor, basta alterar o 
valor que estiver definido no #define. 
 
#include <stdio.h> 
 
#define MAXVET 100 /* define o tamanho máximo do vetor como MAXVET */ 
main() 
 { 
 float soma, media, desvio, nota[MAXVET] /* vetor de notas */; 
 int tam, i /* conterá os índices do vetor */; 
 /* Entrada da quantidade de notas e verificação dos limites 
 do vetor */ 
 do { 
printf(“Digite a quantidade de notas – mínimo 1 e máximo %d: ”, 
MAXVET); 
 scanf(“%d”, &tam); 
 if (tam > MAXVET || tam <= 0) 
 printf(“Quantidade de notas inválida”); 
 } while (tam > MAXVET ||tam <= 0); 
 soma = 0; /* valor inicial para a sumarização das notas */ 
 for (i = 0; i < tam; i++) 
 { 
 printf(“Digite uma nota: ”); 
 scanf(“%f”, &nota[i]); 
 soma = soma + nota[i]; 
 } 
 media = soma/tam; 
 printf(“Media = %f”, media); 
 /* Cálculo dos devios */ 
 for (i = 0; i < tam; i++) 
 { 
 desvio = nota[i] – media; 
 printf(“Desvio da nota %f = %f”, nota[i], desvio); 
 } 
} 
3 Exemplos de Programas 
1) Faça um algoritmo que: 
• leia dois vetores, contendo 5 números inteiros cada um; 
• intercale os elementos dos dois vetores, formando um novo vetor de 10 elementos; 
• escreva o vetor resultante da intercalação. 
Solução: 
Entrada: dois vetores de 5 números inteiros; 
Processo: intercalação dos dois vetores gerando um vetor de 10 elementos; 
Saída: vetor de 10 elementos resultante. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare v1[5], v2[5], vr[10], i: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Carregando o primeiro vetor:”); 
 5 
 para i ← 0 até 4 passo 1 faça 
 início 
 escreva(“Digite um número inteiro: ”); 
 leia(v1[i]); 
 fim 
 escreva(“Carregando o segundo vetor:”); 
 para i ← 0 até 4 passo 1 faça 
 início 
 escreva(“Digite um número inteiro: ”); 
 leia(v2[i]); 
 fim 
 /* Processo – Intercalação dos vetores */ 
para i ← 0 até 4 passo 1 faça 
 início 
 vr[2*i] = v1[i]; 
 vr[2*i+1] = v2[i]; 
 fim 
/* Saída de dados */ 
escreva(“Vetor resultante:”); 
para i ← 0 até 9 passo 1 faça 
 escreva(vr[i]); 
fim 
 
#include <stdio.h> 
 
#define MAXVET 5 
#define MAXVETRES MAXVET*2 
main() 
{ 
 /* Declaração de variáveis */ 
 int v1[MAXVET], v2[MAXVET], vr[MAXVETRES], i;/* Entrada de dados */ 
 printf(“Carregando o primeiro vetor:\n”); 
 for(i = 0; i < MAXVET; i++) 
 { 
 printf(“Digite um número inteiro: ”); 
 scanf(“%d”, &v1[i]); 
 } 
 printf(“Carregando o segundo vetor:\n”); 
 for(i = 0; i < MAXVET; i++) 
 { 
 printf(“Digite um número inteiro: ”); 
 scanf(“%d”, &v2[i]); 
 } 
 /* Processo – Intercalação dos vetores */ 
 for(i = 0; i < MAXVET; i++) 
 { 
 vr[2*i] = v1[i]; 
 vr[2*i+1] = v2[i]; 
 } 
 /* Saída de dados */ 
 printf(“Vetor resultante:\n”); 
 for(i = 0; i < MAXVETRES; i++) 
printf(“%d “, vr[i]); 
} 
 6 
2) Um vetor X de 150 posições contém o número de matrícula de N alunos (N ≤ 150) de 
uma Universidade. Um outro vetor Y de 150 posições contém as notas dos N alunos 
(N ≤ 150), sendo que as posições de ambos os vetores se relacionam, por exemplo, a 
nota do aluno de matrícula X[i] é dada por Y[i]. Faça um algoritmo que: 
• leia a quantidade N de alunos; 
• leia as informações dos N alunos carregando os vetores X e Y; 
• leia um determinado número de matrícula e determine a nota do aluno correspondente, 
repetindo o processo até que o usuário deseje parar. 
Solução: 
Entrada: número N de alunos e informações sobre os alunos a serem carregadas nos 
vetores X e Y; 
Processo e Saída: consulta a notas de alunos a partir do número da matrícula. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare N, X[150], i, mat, achou: numérico inteiro; 
 Y[150]: numérico real; 
 resp: caractere; 
 /* Entrada de dados */ 
repita 
escreva(“Digite a quantidade de alunos (entre 1 e 150): ”); 
 leia(N); 
 se (N > 150 ou N ≤ 0) 
 então escreva(“Quantidade de alunos inválida”); 
 até (N > 0 e N ≤ 150); 
para i ← 0 até N-1 passo 1 faça 
 início 
 escreva(“Digite o número da matrícula do aluno: ”); 
 leia(X[i]); 
 escreva(“Digite a nota do aluno: ”); 
 leia(Y[i]); 
 fim 
 /* Processo e Saída */ 
 repita 
 /* Lê a matrícula do aluno para consulta */ 
 escreva(“Entre com a matrícula do aluno para consulta: ”); 
 leia(mat); 
 /* Percorre o vetor X, procurando pela matricula */ 
 achou ← 0; /* não achou */ 
 i ← 0; 
 enquanto (i < N e achou = 0) faça 
 início 
 se (X[i] = mat) 
 então início 
 achou ← 1; /* achou */ 
 escreva(“Nota = ”, Y[i]); 
fim 
 i ← i + 1; 
 fim 
 /* Verifica se a matrícula não foi encontrada */ 
 se (achou = 0) /* não achou */ 
 então escreva(“Matricula não encontrada”); 
 /* Permite que o usuário faça mais uma consulta se desejar */ 
 escreva(“Deseja consultar mais um aluno? (S/N)”); 
 leia(resp); 
 até (resp = ‘N’); 
fim 
 7 
#include <stdio.h> 
#include <conio.h> 
#include <ctype.h> 
 
#define MAXVET 150 
 
main() 
{ 
 /* Declaração de variáveis */ 
 int N, X[MAXVET], i, mat, achou; 
 float Y[MAXVET]; 
 char resp; 
 /* Entrada de dados */ 
 do { 
 printf(“Digite a quantidade de alunos (entre 1 e %d): ”, MAXVET); 
 scanf(“%d”, &N); 
 if (N > MAXVET || N <= 0) 
 printf(“Quantidade de alunos inválida...\n”); 
 } while(N > MAXVET || N <= 0); 
 for(i = 0; i < N; i++) 
 { 
 printf(“Digite o número da matrícula do aluno: ”); 
 scanf(“%d”, &X[i]); 
 printf(“Digite a nota do aluno: ”); 
scanf(“%f”, &Y[i]); 
 } 
 /* Processo e Saída */ 
 do { 
 /* Lê a matrícula do aluno para consulta */ 
 printf(“\nEntre com a matrícula do aluno para consulta: ”); 
 scanf(“%d”, &mat); 
 /* Percorre o vetor X, procurando pela matricula */ 
 achou = 0; /* não achou */ 
 i = 0; 
 while (i < N && achou == 0) 
 { 
 if (X[i] == mat) 
 { 
 achou = 1; /* achou */ 
printf(“Nota = %f”, Y[i]); 
 } 
 i = i + 1; 
 } 
 /* Verifica se a matrícula não foi encontrada */ 
 if (achou == 0) /* não achou */ 
 printf(“Matricula não encontrada”); 
 /* Permite que o usuário faça mais uma consulta se desejar */ 
 printf(“\nDeseja consultar mais um aluno? (S/N)”); 
 resp = getche(); 
 } while (toupper(resp) == ‘S’); 
} 
 8 
3) Faça um algoritmo que carregue um vetor com 10 números inteiros, ordene o vetor em 
ordem crescente e mostre o vetor ordenado. 
Solução: 
Entrada: vetor de 10 número inteiros; 
Processo: ordenação do vetor em ordem crescente; 
Saída: vetor ordenado. 
Algoritmo 
início 
/* Declaração de variáveis */ 
declare v[10], i, j, aux: numérico inteiro; 
/* Entrada de Dados */ 
para i ← 0 até 9 passo 1 faça 
início 
 escreva(“Digite um número inteiro: ”); 
 leia(v[i]); 
fim 
/* Processo – Ordenação do vetor pelo método Bubble Sort */ 
para i ← 0 até 9 passo 1 faça 
 para j ← 0 até 8-i passo 1 faça 
 se (v[j] > v[j+1]) 
 então início 
 aux ← v[j]; 
 v[j] ← v[j+1]; 
 v[j+1] ← aux; 
 fim 
/* Saída */ 
para i ← 0 até 9 passo 1 faça 
 escreva(v[i]); 
fim 
 
#include <stdio.h> 
 
#define MAXVET 10 
 
main() 
{ 
 /* Declaração de variáveis */ 
 int v[MAXVET], i, j, aux; 
 /* Entrada de Dados */ 
 for(i = 0; i < MAXVET; i++) 
 { 
printf(“Digite um número inteiro: ”); 
scanf(“%d”, &v[i]); 
 } 
 /* Processo – Ordenação do vetor pelo método Bubble Sort */ 
 for(i = 0; i < MAXVET; i++) 
for(j = 0; j < MAXVET-1-i; j++) 
 if (v[j] > v[j+1]) 
 { 
 aux = v[j]; 
 v[j] = v[j+1]; 
 v[j+1] = aux; 
 } 
 /* Saída */ 
 for(i = 0; i < MAXVET; i++) 
 printf(“%d ”, v[i]); 
} 
 9 
4 Exercícios de Fixação 
1) Um número é primo se for divisível apenas por si próprio e por 1. Faça um algoritmo e 
programa C que carregue um vetor de 10 números inteiros, mostre apenas os números 
primos e suas respectivas posições. 
2) Faça um algoritmo e programa C que leia um vetor de N números inteiros (N ≤ 50), 
determine e escreva quantos desses números são pares e quantos são ímpares. 
3) Faça um algoritmo e programa C que leia um vetor de N números inteiros (N ≤ 50), 
calcule e mostre a soma dos números que estiverem nas posições pares do vetor. 
4) Faça um algoritmo e programa C para corrigir provas de múltipla escolha. Cada prova 
tem 10 questões e cada questão vale 1 ponto. O primeiro conjunto de dados a ser lido é 
o gabarito da prova. Os outros dados serão os números dos alunos e suas respectivas 
respostas. Existem 15 alunos matriculados. Calcule e mostre: 
• para cada aluno, sua nota; 
• a percentagem de aprovação, sabendo-se que a nota mínima é 6.0. 
5) Está disponível para entrada de dados o estoque de mercadorias de uma loja. São 
dados os códigos das mercadorias e as respectivas quantidades existentes. A seguir, 
estão disponíveis os pedidos dos clientes. Fazer um algoritmo e programa C para 
atualização do estoque, tal que: 
• seja lido o estoque inicial: considerar um vetor contendo os códigos das 
mercadorias e outro contendo a quantidade em estoque, sendo que as posições de 
ambos os vetores se relacionam, por exemplo, a quantidade em estoque da 
mercadoria[i] é dada por estoque[i] (máximo de 100 mercadorias); 
• sejam lidos os pedidos dos clientes, constituídos, cada um, do número do cliente, 
código da mercadoria e quantidade desejada; 
• seja verificado, para cada pedido, se ele pode ser integralmente atendido. Em caso 
negativo, sejam impressos o número do cliente e a mensagem “NÃO TEMOS A 
MERCADORIA EM ESTOQUE SUFICIENTE”; 
• seja atualizado o estoque após cada operação; 
• seja listado o estoque final.