APOSTILA DE ORDENAÇÃO E PESQUISA

(1)

Instituto Doctum de Educação e Tecnologia

Curso de Sistemas de Informação

Faculdades Unificadas Doctum de Cataguases

APOSTILA D E

ORD EN AÇÃO E PESQU ISA

Prof. Giuliano Prado de Morais Giglio

giucontato@gmail.com

(2)

CAPÍTULO 3

MODULARIZAÇÃO

A modular ização consist e num mét odo ut ilizado par a f acilit ar a const r ução de gr andes

pr ogr amas, at r avés de sua divisão em pequenas et apas, que são os módulos ou subprogr amas. A

pr imeir a delas, por onde começa a execução do t r abalho, r ecebe o nome de pr ogramaprincipal, e

as out r as são os subprogramas pr opr iament e dit os, que são execut ados sempr e que ocor r e uma

chamada dos mesmos, o que é f eit o at r avés da especif icação de seus nomes.

Vant agens da ut ilização de subprogramas:

• Economia de código: escr eve-se menos;

• Desenvolviment o modular izado: pensa-se no algor it mo por par t es;

• Facilidade de depur ação (cor r eção/ acompanhament o): é mais f ácil cor r igir / det ect ar um er r o

apenas uma vez do que dez vezes;

• Facilidade de alt er ação do código: se é pr eciso alt er ar , alt er a-se apenas uma vez;

• Gener alidade de código com o uso de par âmet r os: escr eve-se algor it mos par a sit uações

genér icas.

Há duas espécies de subpr ogr amas: PROCEDI MENTO e FUNÇÃO.

3. 1. PROCEDI MENTO

Um subpr ogr ama do t ipo PROCEDI MENTO é, na r ealidade, um pr ogr ama com vida pr ópr ia, mas

que, par a ser pr ocessado, t em que ser solicit ado pelo pr ogr ama pr incipal que o cont ém, ou por

out r o subpr ogr ama, ou por ele mesmo.

Declaração:

PROCEDURE nome;

declaração dos objetos locais ao Procedimento

BEGIN

(3)

onde: nome é o ident if icador associado ao pr ocediment o. EXEMPLO:

O pr ogr ama abaixo calcula a média ar it mét ica ent r e 2 not as, sem o uso de pr ocediment os.

Program CALCULA_MÉDIA; {sem o uso de procedimentos}

var

NOTA1,NOTA2,MEDIA : real;

begin

{lê as notas}

write('Digite a primeira nota: ');

readln(NOTA1);

write('Digite a segunda nota: ');

readln(NOTA2);

{calcula a media}

MEDIA := (NOTA1 + NOTA2) / 2;

{escreve o resultado}

writeln('Media = ',MEDIA,4:1)

end.

Most r ar emos agor a o mesmo pr ogr ama, ut ilizando um pr ocediment o.

Program CALCULA_MÉDIA; {usando procedimento}

var

NOTA1,NOTA2,MEDIA : real;

{declaração do procedimento}

procedure LER_NOTAS;

begin

write('Digite a primeira nota: ');

readln(NOTA1);

write('Digite a segunda nota: ');

readln(NOTA2);

end;

{Programa Principal}

begin

LER_NOTAS; {ativação do procedimento LER_NOTAS}

(4)

3. 2. FUNÇÃO

As f unções, embor a bast ant e semelhant es aos pr ocediment os, t êm a car act er íst ica especial de

r et or nar ao pr ogr ama que as chamou um valor associado ao nome da f unção. Est a car act er íst ica

per mit e uma analogia com o conceit o de f unção da Mat emát ica.

Declaração:

FUNCTION nome : tipo;

declaração dos objetos locais à Função

BEGIN

Comandos da Função

END;

onde: nome é o ident if icador associado à f unção.

t ipo é o t ipo da f unção, ou sej a, o t ipo do valor de r et or no.

EXEMPLO:

O pr ogr ama abaixo calcula a média dos element os de um vet or , sem uso de Pr ocediment os ou

Funções.

Program SOMA_VETOR; {sem o uso de procedimentos ou funções}

const N = 30;

var VETOR : array[1..N] of integer;

I,SOMA,MEDIA : integer;

begin

{lê os valores do vetor}

for I:=1 to N do

readln(VETOR[I]);

{calcula a media}

SOMA := 0;

for I:=1 to N do

SOMA := SOMA + VETOR[I];

MEDIA := SOMA div N;

{escreve o resultado}

writeln(MEDIA)

end.

Most r ar emos agor a o mesmo pr ogr ama, ut ilizando um pr ocediment o par a ler os valor es do vet or e

(5)

Program SOMA_VETOR; {usando uma função e um procedimento}

const

N = 30;

var

VETOR : array[1..N] of integer;

{declaração do procedimento}

procedure LER_DADOS;

var I : integer;

begin

for I:=1 to N do

readln(VETOR[I]);

end;

{declaração da função}

function MEDIA : integer;

var I,SOMA : integer;

begin

SOMA := 0;

for I:=1 to N do

SOMA := SOMA + VETOR[I];

MEDIA := SOMA div N;

end;

{Programa Principal}

begin

{ativa o procedimento LER_DADOS}

LER_DADOS;

{escreve o resultado, chamando a função MEDIA}

writeln(

MEDIA

)

end.

3. 3. Variáveis GLOBAI S e Variáveis LOCAI S

Obser ve que, no exemplo ant er ior , declar amos uma var iável no pr ogr ama pr incipal e out r as

nos subpr ogr amas. Podemos dizer que a var iável VETOR, que f oi declar ada no pr ogr ama pr incipal

é uma variável global aos subpr ogr amas, enquant o que a var iável I é dit a variável local ao

pr ocediment o LER_DADOS e as var iáveis I e SOMA são locais à f unção MEDI A. É impor t ant e

r essalt ar que a var iável I do pr ocediment o LER_DADOS é dif er ent e da var iável I da f unção

(6)

O uso de var iáveis globais dent r o de pr ocediment os e f unções ser ve par a implement ar um

mecanismo de t r ansmissão de inf or mações de um nível mais ext er no par a um mais int er no.

As var iáveis locais dos pr ocediment os e f unções são cr iadas e alocadas quando da sua

at ivação e aut omat icament e liber adas quando do seu t ér mino.

A ut ilização de var iáveis globais não const it ui, no ent ant o, uma boa pr át ica de

pr ogr amação. Assim, t odos subpr ogr amas devem apenas ut ilizar as var iáveis locais, conhecidas

dent r o dos mesmos, e a t r ansmissão de inf or mações par a dent r o e f or a dos subpr ogr amas deve

ser f eit a at r avés dos parâmet ros de t r ansmissão, que ser ão apr esent ados a seguir .

3. 4. Parâmet ros

Quando se desej a escr ever um subpr ogr ama que sej a o mais genér ico possível, deve-se

usar a passagem de par âmet r os.

A passagem de par âmet r os f or maliza a comunicação ent r e os módulos. Além dist o,

per mit e que um módulo sej a ut ilizado com oper andos dif er ent es, dependendo do que se desej a do

mesmo.

Dá-se a designação de parâmet ro real ou de chamada ao obj et o ut ilizado na unidade

chamador a/ at ivador a e de parâmet ro f or mal ou de def inição ao r ecebido como par âmet r o no

subpr ogr ama.

Dent r e os modos de passagem de par âmet r os, podemos dest acar a passagem por valor e

a passagem por r ef erência.

Na passagem de par âmet r os por valor, as alt er ações f eit as nos par âmet r os f or mais,

dent r o do subpr ogr ama, não se r ef let em nos par âmet r os r eais. O valor do par âmet r o r eal é

copiado no par âmet r o f or mal, na chamada do subpr ogr ama. Assim, quando a passagem é por valor ,

ist o signif ica que o par âmet r o é de ent r ada.

Na passagem de par âmet r os por ref erência, a t oda alt er ação f eit a num par âmet r o f or mal

cor r esponde a mesma alt er ação f eit a no seu par âmet r o r eal associado. Assim, quando a passagem

é por r ef er ência, ist o signif ica que o par âmet r o é de ent r ada- saída.

Na linguagem Pascal, a declar ação dos pr ocediment os e f unções com par âmet r os se

(7)

cabeçalho. Est a deve vir ent r e par ênt eses e cada par âmet r o deve t er o seu t ipo especif icado. A

f or ma ger al é:

PROCEDURE nome (lista de parâmetros formais)

FUNCTION nome (lista de parâmetros formais) : tipo

A list a de parâmet ros f ormais t em a seguint e f or ma:

parâmetro1 : tipo; parâmetro2 : tipo; ...; parâmetro n : tipo

Exemplos da list a de par âmet r os:

procedure PROC (X,Y,Z:integer; K:real)

function FUNC (A,B:real; C:string) : integer

Na f or ma apr esent ada, a passagem dos par âmet r os ser á por valor . Par a se ut ilizar a passagem por

r ef er ência, deve-se acr escent ar a palavr a VAR ant es do nome do par âmet r o.

EXEMPLO:

Procedure PROC(A:integer; var B,C:integer)

Na chamada de pr ocediment os ou f unções ut ilizando par âmet r os, devemos acr escent ar

após o nome do pr ocediment o ou f unção uma list a de par âmet r os r eais (de chamada), os quais

devem ser do mesmo t ipo e quant idade dos par âmet r os f or mais declar ados.

O exemplo a seguir demonst r a a dif er ença ent r e a passagem de par âmet r os por

r ef er ência e a passagem de par âmet r os por valor :

Program EXEMPLO_PASSAGEM_PARÂMETROS;

var N1,N2 : integer;

Procedure PROC(X:integer; var Y:integer);

begin

X:=1;

Y:=1;

end;

(8)

N1:=0; N2:=0;

PROC(N1,N2);

writeln(N1); {será exibido o valor 0}

writeln(N2); (será exibido o valor 1}

end.

3. 4. 1. Exercícios Resolvidos

1. Escrever uma função chamada MAIOR que receba dois números inteiros e retorne o maior deles. Escrever um programa para ler dois números inteiros e, utilizando a função MAIOR, calcular e exibir o maior valor entre os números lidos.

Program CALCULA_MAIOR;

var X,Y,M : integer;

function MAIOR (NUM1,NUM2:integer) : integer;

begin

If NUM1 > NUM2 then

MAIOR := NUM1

else

MAIOR := NUM2;

end;

begin

readln(X,Y);

M := MAIOR(X,Y);

writeln(M);

end.

2. Escr ever um pr ocediment o chamado DOBRA que mult iplique um númer o int eir o (r ecebido como par âmet r o) por 2. Escr ever um pr ogr ama par a ler um valor int eir o e , ut ilizando o pr ocediment o DOBRA, calcular e exibir o dobr o do mesmo.

Program CALCULA_DOBRO;

var X : integer;

procedure DOBRA (var NUM:integer);

begin

NUM := NUM * 2

end;

begin

(9)

3. 5. Recursividade

Diz-se que uma FUNCTI ON ou uma PROCEDURE é r ecur siva, quando ela chama a si

pr ópr ia, est a car act er íst ica pode , a pr incípio par ecer est r anha, ou at é mesmo desnecessár ia

devido ao nível de pr ogr amas o qual est amos t r abalhando, mas o uso da r ecur sividade muit as

vezes , é a única f or ma de r esolver pr oblemas complexos. No nível que ser á dado est e cur so,

bast ar á saber o conceit o e o f uncionament o de uma sub-Rot ina r ecur siva.

Abaixo seguem exemplos de sub-Rot inas r ecur sivas:

a ) PROCEDURE Recursão(A : BYTE);

BEGIN

IF a > 0 THEN BEGIN

WRITE(A); Recursão (A - 1); END;

END;

b) PROCEDURE Recursão( A : BYTE);

BEGIN

IF a > 0 THEN BEGIN

Recursão ( A -1 );

WRITE( A ); { Esta linha será executada ao final de cada execução da Rotinarecursiva }

END; END;

No pr imeir o Exemplo, a saída ger ada ser á a seguint e seqüência de númer os: 5 4 3 2 1.

No segundo Exemplo, a saída ger ada ser á a seguint e seqüência de númer os: 1 2 3 4 5 .

c) PROCEDURE Recursão(A : BYTE) ;

VAR

Valor : BYTE; BEGIN

Valor : = A DIV 2; IF valor > 0 THEN BEGIN

Recursão(Valor); END;

WRITE(valor); END;

Par a um valor inicial igual a 80, a seqüência ger ada ser á a seguint e: 0 1 2 5 10 20 40

No Exemplo acima ser á cr iado, a chamada da Rot ina Recur são, uma var iável dif er ent e de

(10)

Uma car act er íst ica impor t ant e das Rot inas r ecur sivas diz r espeit o a f or ma de

t r at ament o das var iáveis e par âmet r os. Usando como Exemplo o it em acima, vemos que exist e um

par âmet r o chamado “A” e uma var iável local a sub-Rot ina, chamado Valor . É impor t ant e not ar que

a cada at ivação da Rot ina r ecur siva, t odos os par âmet r os e var iáveis locais, são t r at ados como

sendo posições de memór ia t ot alment e dif er ent es e independent es, apesar de t er em o mesmo

Nome.

Segue abaixo uma r epr esent ação das var iáveis e seus cont eúdos em cada uma das chamadas:

1a_Chamada _{A=80 Valor =40}

5a_Chamada _A=5 _{Valor =2}

Um exemplo clássico e comum de uma def inição r ecur siva é o da f unção f at or ial de “n”.

A f unção f at or ial é denot ada mat emat icament e por n! e expr essa o valor do pr odut o de t odos os

númer os int eir os at é (e inclusive) “n”. Assim, o f at or ial de “n” é def inido como:

1, se n = 0 n! =

n * ( n - 1) ! , se n > 0

Est a f unção pode ser escr it a f acilment e ut ilizando-se a r ecur sividade:

function Fatorial (N : integer) : integer;

begin

if (N > 0)

then Fatorial := N * Fatorial(N - 1)

else Fatorial := 1;

end;

Embor a não sej a usada nenhuma est r ut ur a de r epet ição, est á sendo r ealizado um

(11)

3. 5. 1. Exercícios Propost os:

1. Explique qual ser á o r esult ado e o f uncionament o dos seguint es pr ogr amas:

a)- PROGRAM Teste;

FUNCTION XXX(A : WORD) : WORD; BEGIN

IF a = 0 THEN BEGIN

XXX : = 1; ELSE

XXX : =A * XXX(A - 1); END;

END; BEGIN

WRITE(XXX(5)); END.

b) PROGRAM Teste;

PROCEDURE Recursão(a : BYTE); BEGIN

a : = a - 1; IF a > 0 THEN BEGIN

Recursão(a); END;

WRITE(a); END;

BEGIN

Recursão(5); END.

c) PROGRAM Teste;

PROCEDURE Recursão(VAR a: BYTE); BEGIN

a : = a - 1; IF a > 0 THEN BEGIN

Recursão(a); END;

WRITE(a); END;

BEGIN

(12)

CAPÍTULO 5

MÉTODOS DE PESQUISA

5. 1. Conceit os

A pesquisa (ou busca) de chaves em uma est r ut ur a de dados é uma oper ação que se

encont r a pr at icament e em t odos os sist emas. A escolha da t écnica de pesquisa a ser ut ilizada é

muit o impor t ant e, pois vai inf luenciar dir et ament e o desempenho do sist ema.

Os dois t ipos de pesquisa mais ut ilizados em est r ut ur as est át icas são a pesquisa

seqüencial e a pesquisa binár ia.

Pesquisa seqüencial

Consist e em per cor r er a est r ut ur a do início ao f im, ou at é a posição onde se encont r a a

chave pr ocur ada.

Consider ando:

§ N : númer o de element os em um vet or

§ V : vet or com N element os

§ Chave : valor sendo pesquisado

Void PesquisaSequencial(int V[], int N, int Chave) {

int ind;

ind = 0;

while (ind < N) and (V[ind] != Chave) ind = ind + 1;

if (ind > N)

printf(“Chave não encontrada”)

else printf (“Chave encontrada na posicao %d”, ind); }

A pesquisa pode ser agilizada incluindo um element o após a últ ima posição do vet or com

a chave pr ocur ada. Assim pr ecisamos apenas de uma compar ação dur ant e o laço.

Consider ando:

§ N : númer o de element os or iginais em um vet or

§ V : vet or com N+1 element os

(13)

void PesquisaSequencialRapida(int V[], int N, int Chave) {

int ind;

V[N+1] = Chave; ind = 0;

while (V[ind] != Chave) ind = ind + 1;

if (ind = N+1)

Se os element os est iver em or denados no vet or , o algor it mo pode ser modif icado.

Consider ando:

§ N : númer o de element os or iginais em um vet or

§ V : vet or com N+1 element os

§ Chave : valor sendo pesquisado

§ MaxValor : Maior valor que a chave pode assumir ;

void PesquisaSequencialOrdenada(int V[], int N, int Chave) {

int ind;

V[N+1] = MaxValor; ind = 0;

while (V[ind] < Chave) ind = ind + 1; if (V[ind] > Chave)

5. 1. 2 Pesquisa binária

Est a é a t écnica mais ut ilizada par a pesquisa em um conj unt o ordenado de valor es.

Consist e em obt er o element o do meio da est r ut ur a e compar ar est e valor com a chave pr ocur ada.

Como r esult ado dest a compar ação podemos t er :

§ Se Chave é menor que o valor do meio, ela deve ser pr ocur ada no int er valo ent r e o

início do vet or at é o meio.

§ Se Chave é maior que o valor do meio, ela deve ser pr ocur ada no int er valo ent r e o

meio do vet or e seu f inal.

§ Se Chave é igual ao valor do meio, a pesquisa é encer r ada.

Consider ando:

§ N : númer o de element os em um vet or

§ V : vet or com N element os

(14)

§ I ni : limit e inicial par a pesquisa

§ Fim : limit e f inal par a pesquisa

§ Meio : posicao no meio do vet or

void PesquisaBinaria(int V[], int N, int Chave) {

int ini, fim, meio; ini = 0;

fim = N-1;

while (ini <= fim) {

meio = (ini+fim)/2); if (Chave < V[meio]) fim = meio – 1; else

if (Chave > V[meio]) ini = meio + 1 else

ini = fim + 1; }

if (Chave != V[meio])

(15)

CAPÍTULO 6

MÉTODOS DE CLASSIFICAÇÃO

6. 1. Conceit os

Classif icação ou or denação de dados const it ui uma das t ar ef as mais f r eqüent es e

impor t ant e em pr ocessament o de dados.

Classif icação de dados é o pr ocesso pelo qual é det er minada a or dem em que devem se

apr esent ar as ent r adas de uma t abela ou os r egist r os de um ar quivo, baseado no valor de um ou

mais campos. Est es campos são chamados de chaves de classif icação (ou or denação).

Exist em basicament e dois t ipos de or denação:

§ I nt erna: onde a or denação é r ealizada t ot alment e na memór ia pr incipal;

§ Ext erna: onde é ut ilizada a memór ia secundár ia, ger alment e car act er izada por um disco.

Exist em diver sos mét odos de classif icação int er na: por inser ção, por seleção, por t r oca,

por dist r ibuição e por int er calação.

6. 2. Classif icação com I nserção Diret a (I nsert Sort )

Consist e em r ealizar a or denação da list a de valor es pela inser ção de cada um dos

element os em sua posição cor r et a dent r o da list a, segundo a chave de or denação. É usado apenas

com pequenos conj unt os de dados.

Nest e mét odo, o vet or V é dividido em dois segment os. I nicialment e o pr imeir o

segment o possui apenas o pr imeir o element o, est ando por t ant o classif icado, enquant o o segundo

segment o cont em os element os V[2] a V[N]. At r avés de it er ações sucessivas é f eit a a inser ção de

t odos os element os do segundo segment o no pr imeir o, de f or ma or denada. Após cada inser ção, o

pr imeir o segment o possuir á mais um element o e o segundo, menos um.

Consider ando:

§ N : númer o de element os no vet or

§ V : vet or com N posições (1 a N) cont endo as chaves

(16)

§ J : Limit e do 1o_{. segment o em det er minado inst ant e}

§ X : Chave do 2o_{. segment o a ser inser ida no 1}o_.

void OrdenacaoInsercao(int V[],int N) {

int i, j, X;

for (i= 1; i < N; i++) {

X = V[i]; j = i;

while ((X < V[j-1]) && (j > 0)) {

V[j] = V[j-1]; j = j -1; }

V[j] = X; }

}

6. 3. Classif icação por Seleção

Consist e em f azer seleções sucessivas da menor chave de or denação e colocar o

element o cor r espondent e na sua posição def init iva dent r o da list a.

Consider ando:

§ N : númer o de element os do vet or

§ i : limit e inf er ior do vet or em dado inst ant e

§ PosMenor : posição da menor chave

§ V[PosMenor } : valor da menor chave selecionada em uma passada

§ J : var iável auxiliar

§ Aux: var iável auxiliar par a r ealizar a t r oca

void OrdenacaoSelecao(int V[],int N) {

int i, j, PosMenor, Aux;

for (i= 0; i < N –1; i++) {

PosMenor = i;

for (j = i+1; j < N; j++) {

if (V[j] < V[PosMenor]) PosMenor = j;

}

Aux = V[PosMenor]; V[PosMenor] = V[i]; V[i] = Aux;

(17)

6. 4. Classif icação por Troca (BubbleSort )

Também conhecido como “mét odo da bolha”, consist e na compar ação de par es de chaves

de or denação, t r ocando os element os cor r espondent es, caso est ej am f or a de or dem.

Consider ando:

§ N : númer o de element os do vet or

§ i : limit e inf er ior do vet or em dado inst ant e § j : var iável auxiliar

void BublleSort(int V[],int N) {

int i,j, Aux;

for (i = 0; i < N; i++)

for (j = i+1; j < N; j++) {

if (V[i] > V[j]) {

Aux = V[i]; V[i] = V[j]; V[j] = Aux; }

} }

6. 5. Classif icação Rápida por t roca (QuickSort )

Em 1962, Hoar e desenvolveu um dos algor it mos mais ef icient es de or denação. O

algor it mo par t iciona o vet or a ser or denado em dois subconj unt os, um à esquer da e out r o à

dir eit a, de t al f or ma que t odo element o do subconj unt o à esquer da sej a menor que qualquer

element o do subconj unt o à dir eit a. Cada subconj unt o é r epar t icionado segundo est e mesmo

cr it ér io, e assim sucessivament e. I st o nos leva a uma solução r ecur siva.

O par t icionament o ocor r e a par t ir de um element o que ser á o pivô. É a compar ação ent r e

est e pivô e as demais chaves que det er mina o cor r et o posicionament o dos element os par a um novo

par t icionament o. Nest e exemplo, o pivô ser á o element o cent r al de cada par t ição.

Consider ando:

§ PosEsquer da : posição inicial da par t ição

§ PosDir eit a : posição f inal da par t ição

(18)

void QuickSort (int V[], int N, int PosEsquerda, int PosDireita) {

int Esq, Dir, Pivo;

Esq = PosEsquerda; Dir = PosDireita;

Pivo = V[ROUND(float)((PosEsquerda+PosDireita)/2)]; while (Esq <= Dir)

{

while V[Esq] < Pivo { Esq := Esq + 1 }; while V[Dir] > Pivo { Dir := Dir – 1 }; if (Esq <= Dir)

{

Aux = V[Esq]; V[Esq] = V[Dir]; V[Dir] = Aux; Esq = Esq + 1; Dir = Dir – 1; }

}