ESTRUTURA DE DADOS TIPO ARRAY
Definição
Um array é um tipo de dado estruturado consistindo de um número fixo
de componentes, todos do mesmo tipo.
Cada componente de um array
pode ser explicitamente acessado através de um índice , ou subscrito.
As variáveis desse tipo se
subdividem em duas categorias, as uni-dimentsionais
(também chamados de vetores ),
e as multi-dimensionais, a depender
do número de índices usados para individualizar cada elemento do conjunto. Os arrays
bi-dimensionais são comumente
chamados de matrizes, onde no
primeiro índice visualizamos como sendo as linhas de um tabela, e o segundo índice,
as colunas.
Declaração do Tipo Array
A definição de um tipo array é feita de acordo com a seguinte
sintaxe:
[packed] array [
tipo-do-índice [ , tipo-do-índice ] ... ] of
tipo-do-dado
Onde :
Tipo-do-índice : Corresponde ao tipo dos índices, podendo ser um dos seguintes :
·
Um tipo enumerado
·
O identificador de um tipo escalar ordenado
·
Um subintervalo
Tipo-do-dado : Corresponde ao tipo dos componentes do array.
OBSERVAÇÕES
1.
Os símbolos (. e .)
são substitutos que podem ser utilizados no lugar de [ e ].
2.
O uso da palavra reservada packed faz com que o array
seja melhor alocado na memória de forma a economizar espaço, em detrimento de
um pequena perda de performance. No
Turbo Pascal, isso é feito automáticamente, de forma que a palavra packed sempre será desprezada.
EXEMPLOS
type
TMatriz = array[ 1..10, 1..10 ] of real;
TSituacao = array[ boolean ] of integer;
TCores = ( Vermelho,
Amarelo, Azul );
TIntensidade = array[ TCores ] of real;
Referência aos Elementos de um Array
Um elemento de um array é selecionado colocando-se uma
expressão entre colchetes, logo depois do seu nome. Neste caso, o elemento com o índice é
denominado de variável subscrita.
No caso de um array multi-dimensional, as expressões
usadas para indexação devem ser separadas umas das outras através de vírgulas.
EXEMPLOS
var
A : TMatriz;
Intensidade : TIntensidade;
BEGIN
A[ 1, 5 ] := 0.5;
Intensidade[ Amarelo ] := 0.3;
END.
OBSERVAÇÕES
1.
Se nos referenciar-mos a um array utilizando um índice fora dos limites do array, isso provocará um erro em tempo de execução.
Ex. : A[ 11, 5 ] := 10; { O limite de linhas da matriz A é 10 e não
11 }
Todos os elementos de um array podem ser copiados em outro com
um único comando de atribuição desde que as duas variáveis sejam do mesmo tipo.
Se os arrays forem
multi-dimensionais, pode-se também copiar parte deles, como mostrado abaixo:
type
TMatriz = array[ 1..10, 1..10 ] of integer;
TVetor = array[ -50..50 ] of
real;
var
A, B : TMatriz;
X, Y : TVetor;
BEGIN
X := Y; { Atribui a X todos os elementos de Y }
A[ 1 ] := B[ 2 ]; { Atribui a
linha 2 de B à linha 1 de A }
END.
OBSERVAÇÕES
Duas variáveis são do mesmo tipo se elas forem definidas na mesma lista
do comando var. Assim, se tivermos :
var
Vetor1 : array[ 1..5 ] of
integer;
Vetor2 : array[ 1..5 ] of
integer;
Vetor3, Vetor4 : : array[ 1..5 ] of integer;
as variáveis Vetor1 e Vetor2 não são consideradas como sendo do mesmo tipo no Pascal. Dessa maneira, a atribuição abaixo daria erro
de compilação :
Vetor1 := Vetor2;
Ao passo que a atribuição
abaixo estaria correta :
Vetor3 := Vetor4;
Arrays de Caracteres
Os arrays de caracteres podem ser manipulados como strings, vejamos um
exemplo:
EXEMPLO
program TesteArrayChar;
var
Digitos : array[ 1..10 ] of
Char;
I : integer;
BEGIN
Digitos := ‘0123456789’;
for I := 1 to 10 do
write( Digitos[ I ] );
writeln;
writeln( Digitos );
END.
Leitura e Impressão de Arrays
A leitura e impressão de arrays são feitas indicando individualmente
quais elementos se deseja ler ou imprimir.
EXEMPLOS
var
Vetor : array[ 1..10 ] of
integer;
Matriz : array[ 1..10, 1..20 ] of real;
I, J : integer;
BEGIN
{ Leitura de um vetor }
for I := 1 to 10 do
readln( Vetor[ I ] );
{ Impressão de um vetor }
for I := 1 to 10 do
writeln( Vetor[ I ] );
{ Leitura de uma matriz - Linha por Linha }
for I := 1 to 10 do
for J := 1 to 20 do
readln( Matriz[ I, J ] );
{ Impressão de uma matriz - Linha por Linha }
for I := 1 to 10 do
for J := 1 to 20 do
writeln( Matriz[ I, J ] );
{ Leitura de uma matriz - Coluna por Coluna }
for I := 1 to 20 do
for J := 1 to 10 do
readln( Matriz[ I, J ] );
END.
Arrays Multi-Dimensionais
Para ilustrar o uso de arrays
multi-dimensionais, considere o seguinte problema:
Um professor atribui a cada aluno
de uma turma de 50 alunos, três notas resultantes de três avaliações; o
professor deseja saber a média de cada aluno e a média da turma em cada
avaliação.
Uma maneira natural de tratar
esse problema é com o uso de um array bi-dimensional ( MATRIZ ), tal como
ilustrado abaixo na matriz NOTAS. Onde
cada linha representa um aluno e cada coluna representa uma avaliação (dessa
forma teríamos uma matriz 50 X 3), assim para sabermos a nota do aluno No
10 na 2a Avaliação, teríamos NOTAS[ 10, 2 ] .
|
|
10.0
|
10.0
|
10.0
|
Þ
|
10.0
|
|
|
|
2.0
|
0.0
|
1.0
|
Þ
|
1.0
|
|
|
|
8.0
|
6.0
|
9.0
|
Þ
|
7.7
|
|
|
|
8.0
|
5.0
|
10.0
|
Þ
|
7.7
|
|
|
|
ß
|
ß
|
ß
|
|
Média do Aluno
|
|
|
Média da Avaliação
|
7.0
|
5.3
|
7.5
|
|
|
|
Usaremos dois arrays
uni-dimensionais ( VETORES ) para conter as médias. O array Media_Alunos conterá a média de cada
aluno e Media_Avaliacao conterá a média de cada avaliação.
Program Analise_de_Notas;
{
Programa que irá
ler as notas obtidas pelos alunos de uma turma colocando-as
em um array
bi-dimensional. A seguir será calculada
a média obtida por cada
aluno e a média de
cada avaliação, imprimindo os resultados.
}
const
Num_Avaliacoes
= 3;
Num_Alunos = 10;
type
IndiceAluno = 1..Num_Alunos;
IndiceAvaliacao =
1..NumAvaliacoes;
var
Notas : array[ IndiceAluno, IndiceAvaliacao ]
of real;
MediaAlunos : array[ IndiceAluno ] of real;
MediaAvaliacao :
array[ IndiceAvaliacao ] of real;
I, J : integer;
Soma : real;
BEGIN
{ Leitura da Matriz
de Notas }
for I := 1 to
NumAlunos do
{ Leitura das
Noras do I-esimo aluno }
for J := 1 to
NumAvaliacoes do
read( Notas[
I, J ] );
{ Calculo da média
de cada avaliação guardando-as no array MediaAvaliacao }
for J := 1 to
NumAvaliacoes do
begin
Soma := 0;
for I := 1 to
NumAlunos do
Soma := Soma
+ Notas[ I, J ];
MediaAvaliacao[
J ] := Soma / NumAlunos;
end;
{ Calculo da média
de cada aluno guardando-as no array MediaAlunos }
for I := 1 to
NumAlunos do
begin
Soma := 0;
for J := 1 to
NumAvaliacoes do
Soma := Soma
+ Notas[ I, J ];
MediaAlunos[ I ]
:= Soma / NumAvaliacoes;
end;
{ Impressao das
Médias dos Alunos e suas notas }
writeln( ´Aluno´,
´Media´:7, ´ ´:10, ´Notas´, );
for I := 1 to
NumAlunos do
begin
write( I:4,
MediaAlunos[ I ]:8:1, ´ ´:4 );
for J := 1 to
NumAvaliacoes do
write( Notas[
I, J ]:5:1 );
writeln;
end;
{ Impressao das
medias das avaliaçoes }
write( ´Media das
Avaliações : ´);
for J := 1 to
NumAvaliacoes do
write(
MediaAvaliacoes[ J ]:5:1 );
END.
Arrays Constantes
As constantes já vistas se
enquadram entre as constantes denominadas escalares. No Pascal existem outros tipos de constantes,
denominadas estruturadas, para as
quais estão associadas não um valor, como nas escalares, mas um coleção de
valores.
Um dos tipos de constantes
estruturadas do Pascal são os Arrays Constantes, os quais são definidos da
seguinte forma:
const
ident-constante : array[ tipo-do-índice [ , tipo-do-índice ] ... ] of tipo-do-dado = valores;
EXEMPLO
const
DIGITOS : array[ 1..10 ] of integer = ( 0, 1, 2,
3, 4, 5, 6, 7, 8, 9 );
A declaração de um array constante contém a especificação
de cada um dos valores dos elementos do array.
O tipo dos elementos de uma
constante de array pode ser qualquer
um dos tipos de dados da linguagem Pascal, com exceção do tipo file.
EXEMPLOS
type
TStatus = ( Ativo, Passivo, Esperando );
TStatusString = array[ Status ] of string[ 7 ];
const
StatusString :
TStatusString = ( ‘Ativo’, ‘Passivo’, ‘Esperando’ );
Dessa forma, esses são os
valores dos elementos do array constante StatusString :
StatusString[
Ativo ] = ‘Ativo’
StatusString[
Passivo ] = ‘Passivo’
StatusString[ Esperando ]
= ‘Esperando’
Um exemplo com array multi-dimensionais :
type
TMatriz = array[ 1..2, 1..3 ] of integer;
const
MATRIZ : TMatriz = ( ( 1,
2, 3 ), ( 4, 5, 6) );
MATRIZ[ 1, 1 ] = 1 MATRIZ[
1, 2 ] = 4 MATRIZ[ 1, 3 ] = 7
MATRIZ[ 2, 1 ] = 2 MATRIZ[ 2, 2 ] = 5 MATRIZ[ 2, 3 ] = 8
MATRIZ[ 3, 1 ] = 3 MATRIZ[ 3, 2 ] = 6 MATRIZ[ 3, 3 ] = 9
Uso de Índices com Conteúdo Semântico
Como vimos, os índices de um
array servem para acessar individualmente seus elementos. Freqüentemente, esses índices têm um
significado intrínseco. Por exemplo, se
desejássemos contar as letras existentes em um texto, poderíamos declarar o
contador da seguinte maneira:
type
Faixa = 1..26;
var
Contador : array[ Faixa ] of integer;
ficando subentendido que
Contador[ 1 ] é o contador da letra ´a´, Contador[ 2 ] é o contador da letra
´b´ e assim sucessivamente. No entanto,
o entendimento ficaria mais claro se usássemos como índice não um número
inteiro para indicar a letra, mas a própria letra, isto é, Contador[ ´a´ ] para
indicar o contador da letra ´a´,
Contador[ ´b´ ] para para indicar o contador da letra ´b´, etc. Isto é possível uma vez que o índice de um
array pode ser qualquer escalar ordenado (
char, integer, boolean, enumerated, subrange ) Assim, a declaração anterior ficaria melhor
da seguinte forma :
type
Letras = ´a´..´z´;
var
Contador : array[ Letras ] of integer;
EXEMPLO
Vejamos um exemplo completo
usando o recurso de índices com conteúdo semântico.
program
Vendedor;
{
Programa para ler as vendas efetuadas durante uma semana por uma equipe
de
vendedores. A seguir será
impresso o valor das vendas indicando quais os
dias que tiveram vendas abaixo e acima da média.
}
type
TDias = ( Seg, Ter, Qua, Qui, Sex, Sab, Dom );
var
Vendas : array[ TDias ] of real;
Dia
: TDias;
Total,
Media
: real;
BEGIN
{ Leitura das vendas da semana }
for Dia := Seg to Dom do
read( Vendas[ Dia ] );
{ Cálculo da Média }
Total := 0;
for Dia := Seg to Dom do
Total := Total + Vendas[ Dia ];
Media := Total / 7;
writeln( ´Vendas Diárias Comparadas com a
Média´ );
writeln( ´ SEG
TER QUA QUI
SEX SAB DOM´ );
for Dia := Seg to Dom do
write( Vendas[ Dia ] :9:2 );
writeln;
for Dia := Seg to Dom do
if Vendas[ Dia ] > Media then
write( ´+´ : 9 )
else
if Vendas[ Dia ] < Media then
write(
´-´ : 9 )
else
write(
´0´ : 9 );
END.
