Apostila de Estrutura de Dados C Atualizada

1
Apostila de Estrutura de Dados e Algoritmos em C#

Prof. Ms. Eduardo R. Marcelino

eduardormbr@gmail.com

2008/2011
Contedo
Tipos Abstratos de Dados (TAD)...................................................................................................................................... 3
Tipos de Dados Concretos (TDC) .................................................................................................................................... 3
Limitaes de uma implementao .................................................................................................................................. 3
Complexidade Computacional ......................................................................................................................................... 5
Anlise assimpttica .................................................................................................................................................... 5
Notao O, (Omega) e Theta ................................................................................................................................... 6
Melhor Caso - ( ) .................................................................................................................................................. 6
Pior Caso - O( ) ...................................................................................................................................................... 6
Caso mdio - ( )..................................................................................................................................................... 6
Exemplos de Complexidade ........................................................................................................................................ 7
Complexidade Constante ........................................................................................................................................ 7
Complexidade Linear - O(n).................................................................................................................................... 7
Complexidade Logaritmica ...................................................................................................................................... 7
Complexidade Quadrtica - O(n
2
) ........................................................................................................................... 8
Funes limitantes superiores mais conhecidas: ..................................................................................................... 8
Exemplo de crescimento de vrias funes ............................................................................................................. 8
Tempos de execuo dos algoritmos: ...................................................................................................................... 9
PILHAS ......................................................................................................................................................................... 10
Implementao de Uma Pilha Esttica ....................................................................................................................... 11
Exerccios sobre Pilhas ............................................................................................................................................. 13
FILAS ............................................................................................................................................................................ 14
Implementao da Fila Esttica Circular .................................................................................................................... 15
Exerccio de Fila e Pilha: ........................................................................................................................................... 17
LISTAS ESTTICAS ..................................................................................................................................................... 18
Implementao de Lista Esttica ............................................................................................................................... 19
Exerccios Sobre Listas, Filas e Pilhas ....................................................................................................................... 21
Exerccio 1: ............................................................................................................................................................... 21
Exerccio 2: ............................................................................................................................................................... 21
Exerccio 3: ............................................................................................................................................................... 21
Ponteiros (ou Apontadores) ........................................................................................................................................... 22
Pilhas Dinmicas (utilizando encadeamento) ................................................................................................................. 23
Implementao da Pilha dinmica utilizando objetos encadeados.......................................................................... 24
Exerccios: ............................................................................................................................................................ 26
Listas Simplesmente Encadeadas ................................................................................................................................. 27
Listas Duplamente Encadeadas ..................................................................................................................................... 27
Listas Encadeadas circulares......................................................................................................................................... 28
Recursividade ou Recurso ........................................................................................................................................... 29
Exerccios.................................................................................................................................................................. 30
Exerccio 1: ........................................................................................................................................................... 30
Exerccio 2: ........................................................................................................................................................... 30
Exerccio 3: ........................................................................................................................................................... 30
Exerccio 4: ........................................................................................................................................................... 30
rvores .......................................................................................................................................................................... 31
Percurso (ou Caminhamento) em rvores ..................................................................................................................... 32
Percurso prefixado .................................................................................................................................................... 32
Percurso ps-fixado ................................................................................................................................................... 32
rvores Binrias ............................................................................................................................................................ 33
rvores Binrias de Busca ............................................................................................................................................. 34
Implementao de uma rvore Binria de Busca em C#............................................................................................ 36
Grafos ........................................................................................................................................................................... 39
Ordenao..................................................................................................................................................................... 40
Quicksort ................................................................................................................................................................... 41
2
Complexidade ........................................................................................................................................................... 41
Implementaes ........................................................................................................................................................ 41
Pesquisa em Memria Primria ..................................................................................................................................... 44
Pesquisa seqencial .................................................................................................................................................. 44
Pesquisa Binria ....................................................................................................................................................... 44

Referncias bsicas para o material desta apostila:

[1]PEREIRA, Silvio do Lago. Estruturas de dados fundamentais Conceitos e aplicaes. So Paulo: rica, 1996.

[2]ZIVIANI, Nivio. Projeto de Algoritmos com implementaes em Pascal e C, 2. ed. So Paulo: Pioneira Thomson
Learning, 2005.

[3]GOODRICH, M.T., TAMASSIA, R. Estruturas de Dados e Algoritmos em Java, 2. ed. Porto Alegre: Bookman,
2002.

[4] FORBELLONE, A.L.V., EBERSPACHER, H.F., Lgica de Programao A Construo de Alboritmos e Estrutura
de Dados. 2. ed. So Paulo: 2000. Makron Books.

3

T
TTI
IIP
PPO
OOS
SS A
AAB
BBS
SST
TTR
RRA
AAT
TTO
OOS
SS D
DDE
EE D
DDA
AAD
DDO
OOS
SS (
((T
TTA
AAD
DD)
))

formado por um conjunto de valores e por uma srie de funes que podem ser aplicadas sobre estes valores.
Funes e valores, em conjunto, constituem um modelo matemtico que pode ser empregado para modelar e
solucionar problemas do mundo real, servido para especificar as caractersticas relevantes dos objetos envolvidos no
problema, de que forma eles se relacionam e como podem ser manipulados. O TAD define o que cada operao faz,
mas no como o faz.

EX: TAD para uma PILHA:
Empilha (valor) Insere um valor no topo da pilha
Entrada: valor. Sada: nenhuma.

Desempilha - Retira um valor do topo da pilha e o devolve.
Entrada: nenhuma. Sada: valor.

T
TTI
IIP
PPO
OOS
SS D
DDE
EE D
DDA
AAD
DDO
OOS
SS C
CCO
OON
NNC
CCR
RRE
EET
TTO
OOS
SS (
((T
TTD
DDC
CC)
))

Sendo o TAD apenas um modelo matemtico, sua definio no leva em considerao como os valores sero
representados na memria do computador, nem se preocupa com o tempo que ser gasto para aplicar as funes
(rotinas) sobre tais valores. Sendo assim, preciso transformar este TAD em um ti po de dados concreto. Ou seja,
precisamos implementar (programar) as funes definidas no TAD. durante o processo de implementao que a
estrutura de armazenamento dos valores especificada, e que os algoritmos que desempenharo o papel das funes
so projetados.

Tipo Abstrato de Dados Implementao Tipo de Dados Concreto

L
LLI
IIM
MMI
IIT
TTA
AA
E
EES
SS D
DDE
EE U
UUM
MMA
AA I
IIM
MMP
PPL
LLE
EEM
MME
EEN
NNT
TTA
AA
O
OO

importante notar que nem todo TAD pode ser implementado em toda sua generalidade. Imagine por exemplo um TAD
que tenha como funo mapear todos os nmeros primos. Claramente, este um tipo de dados abstrato que no pode
ser implementado universalmente, pois qualquer que seja a estrutura escolhida para armazenar os nmeros primos,
nunca conseguiremos mapear num espao limitado de memria um conjunto infinito de valores.

Frequentemente, nenhuma implementao capaz de representar um modelo matemtico completamente; assim,
precisamos reconhecer as limitaes de uma implementao particular. Devemos ter em mente que podemos chegar a
diversas implementaes para um mesmo tipo de dados abstrato, cada uma delas apresentando vantagens e
desvantagens em relao s outras. O projetista deve ser capaz de escolher aquela mais adequada para resolver o
problema especfico proposto, tomando como medidas de eficincia da implementao, sobretudo, as suas
necessidades de espao de armazenamento e tempo de execuo. Abaixo, veja o quadro com a complexidade de
alguns jogos:

Damas - 5 x 10 na potncia 20
Cerca de
500.000.000.000.000.000.000
posies possveis.
S em 1994 um programa foi capaz
de vencer um campeo mundial. Em
2007 o jogo foi "solucionado" a
ponto de ser possvel um programa
imbatvel
Poker americano (Texas holdem) -
10 na potncia 18
Cerca de 1.000.000.000.000.000.000
posies possveis.
O campeonato mundial de humanos
contra mquinas comeou nesta
semana, com favoritismo para os
humanos. Um programa imbatvel
pode surgir nos prximos anos

Xadrez - 1 x 10 na potncia 45
Cerca de
1.000.000.000.000.000.000.000.000.000.000.000.000.
000.000.000 posies possveis.
Em 1997, um supercomputador venceu um campeo
mundial depois de penar muito. Para criar um
programa imbatvel, porm, seria preciso de um
computador quntico, uma mquina que por enquanto
s existe na cabea dos cientistas.

4
Trecho da entrevi sta com JONATHAN SCHAEFFER, pesquisador na rea de intel igncia artifi ci al .

Disponvel em: (acesso em 25/072007)
http://circuitointegrado.folha.blog.uol.com.br/arch2007-07-22_2007-07-28.html#2007_07-25_07_57_02-11453562-0

FOLHA - Voc pretende continuar trabalhando no problema para chegar ao que os matemticos
chamam de uma "soluo forte", mapeando cada uma das posies do jogo?
SCHAEFFER - No, por uma boa razo. Pondo em perspectiva, vemos que as damas possuem 5 x 10 na potncia 20
posies. Muitas pessoas tm computadores com discos rgidos de 100 gigabytes [10 na potncia 11 bytes]. Se voc
tiver uma mquina "hiper-super" voc deve ter um disco de 1 terabyte [10 na potncia 12]. Se voc for a um dos 50
supercomputadores mais poderosos do mundo, voc encontrar um disco de 1 petabyte [10 na potncia 15]. Um disco
rgido desses custa cerca de US$ 1 milho. As damas tm 10 na potncia 20 posies. Para poder gravar a soluo
forte do problema eu precisaria de 500 mil petabytes _o que custaria US$ 500 bilhes hoje. Acho que no muito
factvel. Se eu processasse a soluo, eu simplesmente no teria onde salv-la.

FOLHA - Voc acha possvel que algum encontre uma soluo para xadrez como a que o sr.
tem para damas? Quando isso vai ocorrer?
SCHAEFFER - No consigo conceber algum conseguindo isso por um longo tempo, a no ser que haja avanos
fundamentais de grande impacto. O nmero de posies do xadrez da ordem de 10 na potncia 45. at difcil de
imaginar quo grande isso . No acho que isso possa ser feito com os computadores que temos hoje ou com os que
teremos nas prximas dcadas.
H uma tecnologia experimental despontando, chamada computao quntica, que pode um dia vir a se tornar
realidade. Talvez a computao quntica possa dar conta desse processamento, mas ainda h muito futuro at l. Eu
gostaria de viver tempo o suficiente para ver isso, mas no acho que vai ser possvel.

Referncias:
PEREIRA, Silvio do Lago. Estruturas de dados fundamentais Conceitos e aplicaes. So Paulo: rica, 1996.

O jogo que utiliza o algoritmo criado por
J onathan est disponvel em:

http://www.cs.ualberta.ca/~chinook/

5
C
CCO
OOM
MMP
PPL
LLE
EEX
XXI
IID
DDA
AAD
DDE
EE C
CCO
OOM
MMP
PPU
UUT
TTA
AAC
CCI
IIO
OON
NNA
AAL
LL

Fontes:http://www.dca.fee.unicamp.br/~ting/Courses/ea869/faq1.html
http://pt.wikipedia.org/wiki/Complexidade_computacional
http://pt.wikipedia.org/wiki/Complexidade_quadr%C3%A1tica

O que um problema computvel?

Um problema computvel se existe um procedimento que o resolve em um nmero finito de passos, ou seja se existe
um algoritmo que leve sua soluo.

Observe que um problema considerado "em princpio" computvel pode no ser tratvel na prtica, devido s limitaes
dos recursos computacionais para executar o algoritmo implementado.

Por que importante a anlise de complexidade computacional de um algoritmo?

A complexidade computacional de um algoritmo diz respeito aos recursos computacionais - espao de memria e tempo
de mquina - requeridos para solucionar um problema.

Geralmente existe mais de um algoritmo para resolver um problema. A anlise de complexidade computacional
portanto fundamental no processo de definio de algoritmos mais eficientes para a sua soluo. Apesar de parecer
contraditrio, com o aumento da velocidade dos computadores, torna-se cada vez mais importante desenvolver
algoritmos mais eficientes, devido ao aumento constante do "tamanho" dos problemas a serem resolvidos.

O que entendemos por tamanho de um probl ema?

O tamanho de um problema o tamanho da entrada do algoritmo que resolve o problema. Vejamos os seguintes
exemplos:
A busca em uma lista de N elementos ou a ordenao de uma lista de N elementos requerem mais operaes
medida que N cresce;
O clculo do fatorial de N tem o seu nmero de operaes aumentado com o aumento de N;
A determinao do valor de F_N na sequncia de Fibonacci F_0, F_1, F_2, F_3, ... envolve uma quantidade de
adies proporcional ao valor de N.

A Teoria da complexidade computacional a parte da teoria da computao que estuda os recursos necessrios durante
o clculo para resolver um problema. O termo foi criado pelo J uris Hartmanis e Richard Stearns[1]. Os recursos
comumente estudados so o tempo (nmero de passos de execuo de um algoritmo para resolver um problema) e o
espao (quantidade de memria utilizada para resolver um problema). Pode-se estudar igualmente outros parmetros,
tais como o nmero de processadores necessrios para resolver o problema em paralelo. A teoria da complexidade difere
da teoria da computabilidade a qual se ocupa de factibilidade de se solucionar um problema como algoritmos efetivos
sem levar em conta os recursos necessrios para ele.

Os problemas que tm uma soluo com ordem de complexidade linear so os problemas que se resolvem em um tempo
que se relaciona linearmente com seu tamanho.

Os problemas com custo fatorial ou combinatrio esto agrupados em NP. Estes problemas no tm uma soluo prtica,
significa dizer quer, uma mquina no pode resolver-los em um tempo razovel.

Anlise assimpttica
A importncia da complexidade pode ser observada no exemplo abaixo, que mostra 5 algoritmos A1 a A5 para resolver
um mesmo problema, de complexidades diferentes. Supomos que uma operao leva 1 milisegundo para ser efetuada.
A tabela seguinte d o tempo necessrio por cada um dos algoritmos.

Tk(n) a complexidade do algoritmo.

6

A
1
A
2
A
3
A
4
A
5

n
T
1
(n) = n| T
2
(n) = nlogn T
3
(n) = n
2
T
4
(n) = n
3
T
5
(n) = 2
n

16 0,016s 0,064s 0,256s 4s 1m4s
32 0,032s 0,16s 1s 33s 46 dias
512 0,512s 9s 4m22s 1 di a 13h
10
137
sculos

A complexidade do tempo de um problema o nmero de passos que se toma para resolver uma instncia de um
problema, a partir do tamanho da entrada utilizando o algoritmo mais eficiente disposio. Intuitivamente, caso se tome
uma instncia com entrada de longitude n que pode resolver-se em n passos, se diz que esse problema tem uma
complexidade em tempo de n. Supostamente, o nmero exato de passos depende da mquina em que se programa, da
linguagem utilizada e de outros fatores. Para no ter que falar do custo exato de um clculo se utiliza a notaco
assimpttica. Quando um problema tem custo dado em tempo O(n) em uma configurao de computador e linguagem,
este custo ser o mesmo em todos os computadores, de maneira que esta notao generaliza a noo de custo
independentemente do equipamento utilizado.

Notao O, (Omega) e Theta

So usadas trs perspectivas no estudo do caso da complexidade:

Mel hor Caso - ( )
Representado por ( ) (mega), consiste em assumir que vai acontecer o melhor. Pouco utilizado e de baixa
aplicabilidade.
Exemplo 1: Em uma lista telefnica queremos encontrar um nmero, assume-se que a complexidade do caso melhor
(1), pois est pressupondo-se o nmero desejado est no topo da lista.

Exemplo 2: Extrair qualquer elemento de um vetor. A indexao em um vetor ou array, leva o mesmo tempo seja qual for
o ndice que se queira buscar. Portanto uma operao de complexidade constante (1).

Pior Caso - O( )
Representado normalmente por O( ) (BIG O) . Se dissermos que um determinado algoritmo representado por g(x) e a
sua complexidade Caso Pior n, ser representada por g(x) =O(n). Consiste em assumir que o pior dos casos pode
acontecer, sendo de grande utilizao e tambm normalmente o mais fcil de ser determinado.

Exemplo 1: Ser tomado como exemplo o jogo de azar com 3 copos, deve descobrir-se qual deles possui uma moeda
debaixo dele, a complexidade caso pior ser O(3) pois no pior dos casos a moeda ser encontrada debaixo do terceiro
copo, ou seja, ser encontrada apenas na terceira tentativa.

Exemplo 2: O processo mais comum para ordenar um conjunto de elementos tm complexidade quadrtica. O
procedimento consiste em criar uma coleo vazia de elementos. A ela se acrescenta, em ordem, o menor elemento do
conjunto original que ainda no tenha sido eleito, o que implica percorrer completamente o conjunto original (O(n), sendo
n o nmero de elementos do conjunto). Esta percorrida sobre o conjunto original se realiza at que se tenha todos seus
elementos na seqncia de resultado. Pode-se ver que h de se fazer n selees (se ordena todo o conjunto) cada uma
com um custo n de execuo: o procedimento de ordem quadrtica O(n). Deve esclarecer se de que h diversos
algoritmos de ordenao com melhores resultados.

Caso mdi o - ( )
Representado por ( ) (Theta). Este o caso que o mais difcil de ser determinado, pois, necessita de anlise
estatstica e em conseqncia de muitos testes, contudo muito utilizado, pois o que representa mais corretamente a
complexidade do algoritmo.

Exemplo: Procurar uma palavra em um dicionrio. Pode-se iniciar a busca de uma palavra na metade do dicionrio.
Imediatamente se sabe se foi encontrada a palavra ou, no caso contrrio, em qual das duas metades deve se repetir o
processo ( um processo recursivo) at se chegar ao resultado. Em cada busca (ou sub-busca), o problema (as pginas
em que a palavra pode estar) vo se reduzindo metade, o que corresponde com a funo logartmica. Este
7
procedimento de busca (conhecido como busca binria) em uma estrutura ordenada tm complexidade logartmica
(log
2
n).

Exemplos de Complexidade

Complexidade Constante

Representada por O(1). Complexidade algortmica cujo tempo de execuo independe do nmero de elementos na
entrada.

Consol e. Wr i t e( "Di gi t e umt ext o: ") ;
t ext o = Consol e. ReadLi ne( ) ;

Consol e. Wr i t e( "Di gi t e uma l et r a: " ) ;
l et r a = Consol e. ReadLi ne( ) [ 0] ;

Apesar de termos 4 instrues, o processo como um todo ser considerado como O(1), pois neste caso executar 1 ou 4
instrues irrelevante.

Complexidade Li near - O(n)

Representada por O(n). Complexidade algortmica em que um pequeno trabalho realizado sobre cada elemento da
entrada. Esta a melhor situao possvel para um algoritmo que tem que processar n elementos de entrada ou produzir
n elementos de sada. Cada vez que n dobra de tamanho o tempo de execuo dobra.

Programa exemplo: Determinar o maior elemento em um vetor:

st at i c voi d Mai n( st r i ng[ ] ar gs)
{
i nt [ ] numer os = { 7, 5, 21, 33, 79, 8, 6, 29, 44, 10, - 5 };

i nt mai or = numer os[ 0] ;

f or ( i nt n = 1; n < numer os. Lengt h; n++)
{
i f ( numer os[ n] > mai or )
mai or = numer os[ n] ;
}

Consol e. Wr i t eLi ne( mai or ) ;
}

A complexidade dada por n elementos (o elemento que determina a taxa de crescimento do algoritmo acima) ou O(n)
(linear). Ou sej a, depende da quanti dade de el ementos no vetor!

Complexidade Logaritmica

Representada por O(log n). Complexidade algortmica no qual algoritmo resolve um problema transformando-o em
partes menores. Nestes casos, o tempo de execuo pode ser considerado como sendo menor do que uma constante
grande. Por exemplo, quando n um milho, log
2
n aproximadamente 20.

8
Complexidade Quadrti ca - O(n
2
)

Representada por O(n
2
). Complexidade algortmica que ocorrem quando os itens de dados so processados aos pares,
muitas vezes em uma repetio dentro da outra. Por exemplo, quando n mil, o nmero de operaes da ordem de 1
milho. Algoritmos deste tipo somente so teis para resolver problemas de tamanhos relativamente pequenos.

Programa exemplo: Preencher uma matriz NxN com nmeros aleatrios.

st at i c i nt [ , ] Cr i aMat r i z( i nt t amanho)
{
i nt [ , ] mat r i z = new i nt [ t amanho, t amanho] ;

Randomr = new Random( ) ;

/ / pr eenche a mat r i z NxN ( onde N = t amanho) comnmer os r andomi cos
f or ( i nt i = 0; i < t amanho; i ++)
f or ( i nt j = 0; j < t amanho; j ++)
mat r i z[ i , j ] = r . Next ( 1000) ;

r et ur n mat r i z;
}

A complexidade dada por n
2
(i*j) elementos ou O(n
2
) (quadrtica)

Funes limitantes superiores mai s conheci das:

Melhor Pior
Constante Logartmica Linear Quadrtica Exponencial
O(1) O(log n) O(n) O(n
2
) O(a
n
) com a >1

Exemplo de crescimento de vrias funes

n l og n n n
2
2
n

2 1 2 4 4
4 2 4 16 16
8 3 8 64 256
16 4 16 256 65.536
32 5 32 1.024 4.294.967.296
64 6 64 4.096 1,84 x 10
19

128 7 128 16.384 3,40 x 10
38

256 8 256 65.536 1,18 x 10
77

512 9 512 262.144 1,34 x 10
154

1024 10 1024 1.048.576 1,79 x 10
308

9
Tempos de execuo dos algoritmos:

Os Algoritmos tm tempo de execuo proporcional a:

O(1) - muitas instrues so executadas uma s vez ou poucas vezes (se isto for verdade para todo o programa diz-se
que o seu tempo de execuo constante)

O(log N) - tempo de execuo logartmico (cresce linearmente medida que N cresce) (quando N duplica log N
aumenta mas muito pouco;)

O(N) - tempo de execuo linear (tpico quando algum processamento feito para cada dado de entrada) (situao
timas quando necessrio processar N dados de entrada) (ou produzir N dados na sada)

O (N log N) - tpico quando se reduz um problema em subproblemas, se resolve estes separadamente e se combinam
as solues (se N 1 milho, N log N perto de 20 milhes)

O (N
2
) - tempo de execuo tpico N quadrtico (quando preciso processar todos os pares de dados de entrada)
(prtico apenas em pequenos problemas). EX: para N=10, N
2
=100.

O (N
3
) - tempo de execuo cbico. EX: para N =100, N
3
=1 milho

O (2
N
) - tempo de execuo exponencial (provavelmente de pouca aplicao prtica; tpico em solues de fora bruta)
(para N =20, 2
N
=1 milho)

10
P
PPI
IIL
LLH
HHA
AAS
SS
(http://pt.wikibooks.org/wiki/Estrutura_de_Dados_I I/Pilhas)

Uma pilha uma estrutura de dados onde em todas as inseres, retiradas e acessos ocorrem apenas em um dos
extremos (no caso, em seu topo).
Os elementos so removidos na ordem inversa daquela em que foram inseridos de modo que o ltimo elemento que
entra sempre o primeiro que sai, por isto este tipo de estrutura chamada LIFO (Last I n - First Out).
O exemplo mais prtico que costuma utilizar-se para entender o processo de pilha como uma pilha de livros ou pilha de
pratos, no qual ao se colocar diversos elementos uns sobre os outros, se quisermos pegar o livro mais abaixo deveremos
tirar todos os livros que estiverem sobre ele.

Uma pilha geralmente suporta as seguintes operaes bsicas:
Empilhar (push) : insere um novo elemento no topo da lista;
Desempilhar (pop): remove o elemento do topo da lista.
Topo (top): acessa-se o elemento posicionado no topo da pilha;
Vazia (isEmpty): indica se a pilha est vazia.
Tamanho (size): retorna a quantidade de elementos da pilha.
Exemplo de utilizao de uma pilha:
Operao Pilha (topo) ----- (base) Retorno Tamanho da Pilha
Empilhar(1) 1 1
Vazia 1 False 1
Empilhar(2) 2,1 2
Topo 2,1 2 2
Empilhar(7) 7,2,1 3
Tamanho 7,2,1 3 3
Desempilhar 2,1 7 2
Desempilhar 1 2 1
Desempilhar 1 0
Vazia True 0

Topo da pilha: ltimo elemento
inserido

Base da pilha: primeiro elemento
inserido

Empilhar
Desempilhar
Tamanho = 5
11
Implementao de Uma Pilha Esttica

// Esta pilha armazena em cada posio da pilha um dado do tipo String.

/ / Pi l ha. cs
usi ng Syst em;
usi ng Syst em. Col l ect i ons. Gener i c;
usi ng Syst em. Text ;

namespace Pi l haEst at i ca
{
/ / def i ni o da cl asse Pi l ha
publ i c cl ass Pi l ha
{
pr i vat e const i nt CAPACI DADE = 5; / / def i ne o t amanho maxi mo dest a uma pi l ha.
pr i vat e st r i ng[ ] dados = new st r i ng[ CAPACI DADE] ; / / vet or par a guar dar os dados da pi l ha.
pr i vat e i nt t opo = - 1; / / var i vel que i r i ndi car a posi o no vet or do t opo da pi l ha.

/ / est e mt odo i nf or ma o t amanho da pi l ha
publ i c i nt Tamanho( )
{
r et ur n t opo + 1; / / l embr e- se que o vet or i ni ci a da posi o zer o. . .
}

/ / est e mt odo r et or na t r ue se a pi l ha est i ver vazi a
publ i c bool Vazi a( )
{
r et ur n Tamanho( ) == 0;
}

/ / est e mt odo empi l ha umval or st r i ng na pi l ha
publ i c voi d Empi l ha( st r i ng p_val or )
{
i f ( Tamanho( ) ! = CAPACI DADE)
{
t opo++;
dados[ t opo] = p_val or ;
}
el se
{
t hr ow new Except i on( "A pi l ha est chei a! ! ! ") ;
}
}

/ / est e mt odo desempi l ha umval or da pi l ha
publ i c st r i ng Desempi l ha( )
{
i f ( Vazi a( ) == t r ue)
{
t hr ow new Except i on( "A pi l ha est vazi a! ! ! ") ;
}
el se
{
t opo- - ;
r et ur n dados[ t opo + 1] ;
}
}

/ / est e mt odo devol ve o val or que est no t opo
publ i c st r i ng Ret or naTopo( )
{
i f ( Vazi a( ) == t r ue)
t hr ow new Except i on( "A pi l ha est vazi a! ! ! ") ;
el se
r et ur n dados[ t opo] ;
}
}
}

12

/ / Pr ogr ama pr i nci pal ( pr ogr am. cs)

usi ng Syst em;

namespace Pi l haEst at i ca
{
cl ass Pr ogr am
{
{
i nt opcao = 0;
st r i ng val or ;
Pi l ha mi nhaPi l ha = new Pi l ha( ) ; / / cr i a uma i nst nci a da cl asse pi l ha!

do
{
t r y
{
Consol e. Wr i t e( "\ n\ n Escol ha: 1- > empi l ha 2- >desempi l ha " +
" 3- >t opo 4- > t amanho 9- > sai r : ") ;
opcao = Conver t . ToI nt 32( Consol e. ReadLi ne( ) ) ;

i f ( opcao == 1)
{
Consol e. Wr i t e( ">>Di gi t e o val or que desej a empi l har : ") ;
val or = Consol e. ReadLi ne( ) ;
mi nhaPi l ha. Empi l ha( val or ) ;
}
el se i f ( opcao == 2)
{
val or = mi nhaPi l ha. Desempi l ha( ) ;
Consol e. Wr i t eLi ne( ">>Desempi l hado: {0} \ n\ n", val or ) ;
}
{
val or = mi nhaPi l ha. Ret or naTopo( ) ;
Consol e. Wr i t eLi ne( ">>Val or no t opo: {0} \ n\ n" , val or ) ;
}
{
Consol e. Wr i t eLi ne( ">>Tamanho da pi l ha: {0}", mi nhaPi l ha. Tamanho( ) ) ;
}
{
/ / sai do pr ogr ama
}
}
cat ch ( Except i on er r o)
{
Consol e. Wr i t eLi ne( "ERRO: " + er r o. Message) ;
}
}
whi l e ( opcao ! = 9) ;
}
}
}

13
Exerccios sobre Pilhas

1. Crie uma pilha que manipule a seguinte estrutura:

Classe Funcionario
Nome : string;
Salario : Double;

Depois faa um programa para testar esta pilha (como no programa exemplo sobre pilhas).

A pilha deve possuir os seguintes mtodos:

Empilhar (p_funcionario); Empilhar um dado do tipo da estrutura que voc definir.
Desempilhar : Tfuncionario; Desempilhar um valor e retornar o valor desempilhado
RetornaTopo : Tfuncionario; Retorna o valor que est no topo da pilha
Tamanho : integer; Retorna o tamanho da pilha

Observe que no h o mtodo vazio. Portanto, para saber se a pilha est vazia, voc dever utilizar o
mtodo Tamanho.

No programa principal (onde voc ir testar a pilha), adicione as seguintes opo ao menu do programa:
Listar os dados da pilha
Somar Salrios
Observe que em ambos os mtodos, voc NO PODER UTILIZAR O VETOR DA PILHA PARA SOLUCIONAR
O PROBLEMA. Voc tem a disposio apenas os mtodos da pilha: Empilhar, Desempilhar, RetornaTopo e
Tamanho.

2. Preencha a tabela abaixo, de acordo com os mtodos executados na primeira coluna:

Operao Pilha (topo) ----- (base) Retorno Tamanho da Pilha
Tamanho
Empilhar(O)
Empilhar(Z)
RetornaTopo
Empilhar(O)
Vazio?
Desempilhar
Tamanho
Empilhar(X)
RetornaTopo
Desempilhar
Empilhar(O)
Empilhar(B)

14
F
FFI
IIL
LLA
AAS
SS

Uma Fila (Queue) um caso particular de Listas Lineares que obedece ao critrio FIFO (First In, Firts Out,
ou Primeiro a Entrar, Primeiro a Sair). Numa fila os elementos so inseridos em uma das extremidades e
retirados na outra extremidade. Existe uma ordem linear para a fila que a ordem de chegada. Filas
so utilizadas quando desejamos processar itens de acordo com a ordem primeiro-que-chega, primeiro-
atendido.

Uma pilha normalmente possui as seguintes operaes (mtodos):

Enfileira ( valor ) Insere o valor no final da fila.
Desenfileira Retorna o elemento do incio da fila, desenfileirando-o.
Vazia Informa se a fila est fazia
Tamanho retorna o tamanho da fila
RetornaInicio retorna o elemento do incio da fila, mas no o desenfileira.
RetornaFim retorna o elemento do final da fila, mas no o desenfileira.

Em uma implementao com arranjos (vetores), os itens so armazenados em posies contguas da
memria. Por causa das caractersticas da fila, a operao enfileira faz a parte de trs da fila expandir-se
e a operao desenfileira faz a parte da frente da fila contrair-se. Conseqentemente a fila tende a
caminhar pela memria do computador, ocupando espao na parte de trs e descartando espao na parte
da frente. Com poucas inseres e retiradas de itens, a fila vai ao encontro do limite do espao de
memria alocado para ela.

A soluo para o problema acima imaginar um vetor como um crculo, em que a primeira posio segue
a ltima. Observe que a fila segue o sentido horrio. Conforme os elementos vo sendo desenfileirados, a
fila anda no sentido horrio. O mesmo ocorre com os itens que vo sendo enfileirados. Para evitar
sobrepor elementos no vetor, devemos verificar o tamanho da fila antes de efetuar a operao enfileirar.
Os elementos Frente e Trs so variveis que indicaro em que posio no vetor esto o primeiro e o
ltimo elemento inserido na fila.

Exemplo de utilizao de uma Fila:
Operao Fila trs --- frente Retorno Tamanho da Fila
Tamanho 0 0
Enfileirar(A) A 1
Enfileirar(B) BA 2
Vazia BA False 2
Enfileirar(C) CBA 3
RetornaFrente CBA A 3
RetornaTras CBA C 3
Desenfilera CB A 2
Desenfilera C B 1
Desenfilera C 0
Vazia True 0
RetornaFrente ERRO 0

Frente
Trs
Implementao circular para
filas
15
Impl ementao da Fila Esttica Circular

/ / Cl asse Fi l a. cs
usi ng Syst em;
usi ng Syst em. Li nq;

namespace Fi l aCi r cul ar Est at i ca
{
cl ass Fi l a
{
const i nt CAPACI DADE = 5; / / capaci dade mxi ma da f i l a
pr i vat e i nt quant i dade = 0; / / qt de de el ement os enf i l ei r ados
pr i vat e i nt i ni ci o = 0; / / i ndi ca qual a pr i mei r a posi o da f i l a
pr i vat e i nt f i m= 0; / / i ndi ca a pr xi ma posi o
pr i vat e st r i ng[ ] dados = new st r i ng[ CAPACI DADE] ; / / ar mazenar os dados da f i l a

/ / r et or na o t amanho da f i l a
publ i c i nt t amanho( )
{
r et ur n quant i dade;
}

/ / enf i l ei r a umval or st r i ng
publ i c voi d enf i l ei r ar ( st r i ng p_val or )
{
i f ( t amanho( ) == CAPACI DADE)
{
t hr ow new Except i on( "A f i l a est chei a! ! ! ! ") ;
}
el se
{
dados[ f i m] = p_val or ;
f i m= ( f i m+ 1) %CAPACI DADE;
quant i dade++;
}
}

/ / r emove o pr i mei r o el ement o da f i l a e devol ve.
publ i c st r i ng desenf i l ei r a( )
{
i f ( t amanho( ) == 0)
{
t hr ow new Except i on( "A f i l a est vazi a! ") ;
}
el se
{
st r i ng val or = dados[ i ni ci o] ;
i ni ci o = ( i ni ci o + 1) %CAPACI DADE;
quant i dade- - ;
r et ur n val or ;
}
}
}
}

16
/ / Pr ogr ama pr i nci pal ( Pr ogr am. cs)
usi ng Syst em;

namespace Fi l aCi r cul ar Est at i ca
{
cl ass Pr ogr am
{
{
st r i ng opcao = " ", val or ;
Fi l a mi nhaf i l a = new Fi l a( ) ;
Consol e. Wr i t eLi ne( "Si st ema emC# par a t est ar a execuo de uma f i l a ci r cul ar \ n" ) ;
do
{
t r y
{
Consol e. Wr i t eLi ne( "\ n\ nDi gi t e: 1- >Enf i l ei r ar 2- >Desenf i l ei r ar " +
"3- > Tamanho 9- >Sai r ") ;
opcao = Consol e. ReadLi ne( ) ;
swi t ch ( opcao)
{
case "1" :
Consol e. Wr i t eLi ne( "Di gi t e umval or par a enf i l ei r ar : ") ;
mi nhaf i l a. enf i l ei r ar ( val or ) ;
br eak;
case "2" :
Consol e. Wr i t eLi ne( "Desenf i l ei r ado: {0}", mi nhaf i l a. desenf i l ei r a( ) ) ;
br eak;
case "3" :
Consol e. Wr i t eLi ne( "Tamanho da f i l a: {0}", mi nhaf i l a. t amanho( ) ) ;
br eak;
case "9" :
Consol e. Wr i t eLi ne( "Sai ndo do si st ema. . . ") ;
br eak;
def aul t :
Consol e. Wr i t eLi ne( "Opo i nvl i da! ! ! " ) ;
br eak;
}
}
{
Consol e. Wr i t eLi ne( er r o. Message) ;
}
} whi l e ( opcao ! = "9") ;
}
}
}
17
Exerccio de Fila e Pilha:

1-) Dada uma Fila Circular F e uma pilha P, execute os mtodos abaixo e preencha as estruturas pilha e fila.

Fila Circular - F
INICIO

0 1 2 3 4

Pilha - P
BASE

0 1 2 3 4

P.empilha(a)
P.empilha(b)
P.empilha(c)
P.empilha(P.retornaTopo)
F.enfileira(F)
F.enfileira(P.retornaTopo)
F.enfileira(P.desempilha)
F.enfileira(P.retornaTopo)
P.empilha(F.desenfileira)
P.empilha(P.desempilha)
F.enfileira(F.desenfileira)

2-) Faa um programa para inverter os dados de uma Fila. Utilize a classe fila que foi passada como exemplo (string).
No altere a classe Fila, a inverso deve ser feita no programa principal (program.cs). Voc deve utilizar apenas os
mtodos pblicos da Fila. Tente utilizar uma plha para solucionar este problema.

18
L
LLI
IIS
SST
TTA
AAS
SS E
EES
SST
TT
T
TTI
IIC
CCA
AAS
SS

http://www.inf.ufsc.br/~ine5384-hp/Capitulo2/EstruturasLista.html
http://www.icmc.usp.br/~sce182/lestse.html
Uma lista esttica seqencial um arranjo de registros onde esto estabelecidos regras de precedncia entre seus
elementos ou uma coleo ordenada de componentes do mesmo tipo. O sucessor de um elemento ocupa posio
fsica subseqente.
Ex: lista telefnica, lista de alunos

Este conjunto de dados pode possuir uma ordem intrnseca (Lista Ordenada) ou no;
Este conjunto de dados deve ocupar espaos de memria fisicamente consecutivos (implementado com vetor);
Se os dados estiverem dispersos fisicamente na memria, para que este conjunto seja uma lista, ele deve possuir
operaes e informaes adicionais que permitam que seja tratado como tal (Lista Encadeada).
O conjunto de operaes a ser definido depende de cada aplicao. Um conjunto de operaes necessrio a uma maioria
de aplicaes :
1. Criar uma lista linear vazia.
2. Inserir um novo item imediatamente aps o i-simo item.
3. Retirar o i-simo item.
4. Localizar o i-simo item para examinar e/ou alterar o contedo de seus componentes.
5. Combinar duas ou mais listas em uma lista nica.
6. Partir uma lista em duas ou mais listas.
7. Fazer uma cpia da lista.
8. Ordenar os itens da lista em ordem ascendente ou descendente, de acordo com alguns de seus componentes.
9. Pesquisar a ocorrncia de um item com um valor particular em algum componente.
DETAHES DA IMPLEMENTAO DE LISTAS ESTTICAS POR MEIO DE ARRANJ OS
Os itens da lista so armazenados em posies contguas de memria.
A lista pode ser percorrida em qualquer direo.
A insero de um novo item pode ser realizada aps o ltimo item com custo constante.
A insero de um novo item no meio da lista requer um deslocamento de todos os itens localizados aps o ponto
de insero.
Retirar um item do incio da lista requer um deslocamento de itens para preencher o espao deixado vazio.

Vantagem:
Acesso direto indexado a qualquer elemento da lista
Tempo constante para acessar o elemento i - depender somente do ndice.
Desvantagem:
Movimentao quando eliminado/inserido elemento
Tamanho mximo pr-estimado
Quando usar:
Listas pequenas
Insero/remoo no fim da lista
Tamanho mximo bem definido
19
Impl ementao de Lista Esttica
Classe Lista.cs
cl ass Li st a
{
pr i vat e const i nt CAPACI DADE = 10;
pr i vat e st r i ng[ ] dados = new st r i ng[ CAPACI DADE] ;
pr i vat e i nt quant i dade = 0;

publ i c i nt t amanho( )
{
r et ur n quant i dade;
}

publ i c voi d i nser eNaPosi cao( i nt p_posi cao, st r i ng p_val or )
{
i f ( t amanho( ) == CAPACI DADE)
t hr ow new Except i on( "A l i st a est chei a! ! ! \ n\ n" ) ;
el se i f ( p_posi cao > t amanho( ) )
t hr ow new Except i on( "No poss vel i nser i r nest a posi o") ;
el se
{
quant i dade++;
f or ( i nt i = t amanho( ) - 1; i > p_posi cao; i - - )
{
dados[ i ] = dados[ i - 1] ;
}
dados[ p_posi cao] = p_val or ;
}
}

publ i c st r i ng r emoveDaPosi cao( i nt posi cao)
{
i f ( t amanho( ) == 0)
t hr ow new Except i on( "A l i st a est vazi a! ! ! ") ;
el se i f ( posi cao > t amanho( ) - 1)
t hr ow new Except i on( "Posi o i nvl i da! ! ! " ) ;
el se
{
st r i ng aux = dados[ posi cao] ;
f or ( i nt i = posi cao; i < t amanho( ) - 1; i ++)
{
dados[ i ] = dados[ i + 1] ;
}
quant i dade- - ;
r et ur n aux;
}
}

publ i c voi d i nser eNoI ni ci o( st r i ng p_val or )
{
i nser eNaPosi cao( 0, p_val or ) ;
}

publ i c voi d i nser eNoFi m( st r i ng p_val or )
{
i nser eNaPosi cao( t amanho( ) , p_val or ) ;
}

publ i c voi d i mpr i meLi st a( )
{
Consol e. Wr i t eLi ne( "\ n\ nI mpr esso dos dados da l i st a: \ n") ;
f or ( i nt i = 0; i < t amanho( ) ; i ++)
{
Consol e. Wr i t eLi ne( dados[ i ] ) ;
}
}
}
20
Program.cs

cl ass Pr ogr am
{
{
st r i ng opcao = " ", val or ;
i nt posi cao;
Li st a mi nhaLi st a = new Li st a( ) ;
Consol e. Wr i t eLi ne( "Si st ema emC# par a t est ar a execuo de uma l i st a est t i ca\ n" ) ;
do
{
t r y
{
Consol e. Wr i t eLi ne( "\ nDi gi t e: \ n 1- > I nser i r no i n ci o \ n " +
"2- > I nser i r no f i m\ n " +
"3- > I nser i r emuma posi o ( l embr e- se que i ni ci a do do zer o! ) \ n " +
"4- > Tamanho \ n 5- > Li st ar \ n " +
"6- > Remover el ement o de uma posi o \ n 9- > Sai r " ) ;
opcao = Consol e. ReadLi ne( ) ;
swi t ch ( opcao)
{
case "1" :
Consol e. Wr i t eLi ne( "Di gi t e umval or par a i nser i r no i n ci o: ") ;
mi nhaLi st a. i nser eNoI ni ci o( val or ) ;
br eak;
case "2" :
Consol e. Wr i t eLi ne( "Di gi t e umval or par a i nser i r no f i m: ") ;
mi nhaLi st a. i nser eNoFi m( val or ) ;
br eak;
case "3" :
Consol e. Wr i t eLi ne( "Di gi t e umval or par a i nser i r : " ) ;
Consol e. Wr i t eLi ne( "Di gi t e a posi o: " ) ;
posi cao = Conver t . ToI nt 32( Consol e. ReadLi ne( ) ) ;
mi nhaLi st a. i nser eNaPosi cao( posi cao, val or ) ;
br eak;
case "4" :
Consol e. Wr i t eLi ne( "Tamanho da l i st a: {0}", mi nhaLi st a. t amanho( ) ) ;
br eak;
case "5" :
mi nhaLi st a. i mpr i meLi st a( ) ;
br eak;
case "6" :
Consol e. Wr i t eLi ne( "Di gi t e a posi o que desej a r emover : ") ;
posi cao = Conver t . ToI nt 32( Consol e. ReadLi ne( ) ) ;
Consol e. Wr i t eLi ne( "Removi do: {0}", mi nhaLi st a. r emoveDaPosi cao( posi cao) ) ;
br eak;
case "9" :
Consol e. Wr i t eLi ne( "Sai ndo do si st ema. . . ") ;
br eak;
def aul t :
Consol e. Wr i t eLi ne( "Opo i nvl i da! ! ! " ) ;
br eak;
}
}
{
Consol e. Wr i t eLi ne( er r o. Message) ;
}
} whi l e ( opcao ! = "9") ;

}
}
21
Exerccios Sobre Listas, Filas e Pilhas

Exerccio 1:

Utilizando uma Lista (como a implementada na explicao sobre Listas) pode-se simular uma Pilha
e uma Fila. Isso pode ser feito sem que seja necessrio alterar nada na classe Lista.
Partindo deste princpio, crie uma classe Pilha que dever ser implementada usando para isso uma
Lista. Ou seja, na sua classe Pilha, no haver mais um vetor DADOS para armazenar os elementos da
pilha. No lugar disso, eles devero ser armazenados em uma Lista.
A sua pilha dever executar os mtodos Empilhar, Desempilhar e Tamanho.
Utilize a Lista que foi explicada em aula (ela armazena apenas strings).

Exerccio 2:
Faa a mesma coisa que no exerccio anterior, porm, crie desta vez uma Fila.
Deve executar os mtodos: Enfileira, Desenfileira e Tamanho.

Exerccio 3:

Implementar uma lista que seja capaz de armazenar alunos.
Cada aluno possui as propriedades:
RA
Nome

O usurio poder inserir nesta lista at 32 alunos.

Dever ser implementado na classe lista os mtodos RetornaPrimeiro e RetornaUltimo, que iro retornar,
respectivamente, o primeiro e ltimo elemento da lista.

Tambm deve haver um mtodo para localizar um elemento na lista (pesquisar pelo RA).

Crie uma interface grfica para cadastrar, remover e pesquisar alunos na lista.
Tambm deve ser possvel testar os mtodos RetornaPrimeiro e RetornaUltimo.
Deve ser possvel remover um RA da lista.

No permite RAs repetidos na lista!!!

22
P
PPO
OON
NNT
TTE
EEI
IIR
RRO
OOS
SS (
((O
OOU
UU A
AAP
PPO
OON
NNT
TTA
AAD
DDO
OOR
RRE
EES
SS)
))

timo material sobre apontadores:
http://br.geocities.com/cesarakg/pointers.html
http://www.deei.fct.ualg.pt/IC/t20_p.html

Um apontador ou ponteiro um tipo de varivel especial, cujo objetivo armazenar um endereo da memria. Ou seja,
ele no armazena um valor como Ol mundo ou 55. Ao invs disso, ele armazena um endereo na memria e, neste
endereo, encontra-se uma informao til, como um texto ou um nmero.

Um apontador contm o endereo de um lugar na memria.

Quando voc executa comandos tais como:
I := 10 ou J := 1

voc est acessando o contedo da varivel. O compilador procura automaticamente o endereo da varivel e acessa o
seu contedo. Um apontador, entretanto, lhe permite determinar por si prprio o endereo da varivel.

Ex:

I := 42;

PonteiroParaI := &I;

Para mostrar o contedo do endereo para o qual a o ponteiro aponta, podemos utilizar:

Writeln( *PonteiroParaI ); { exibir 42 }

&X retorna o endereo da varivel x
*p o contedo do endereo p

Para que o apontador saiba exatamente o tamanho da informao para a qual ele aponta na memria (veja figura
abaixo), uma varivel do tipo apontador deve estar associada a um tipo especfico de varivel ou registro. Para criar uma
varivel do tipo apontador, coloque o smbolo * na frente do tipo da varivel (ex: i nt * p1; )

Endereo Contedo
E456 E123
E455
E454

E123 42

Varivel apontador:
PonteiroParaI
Varivel Inteira I:
Cada tipo de dado ocupa um tamanho
diferente na memria. O apontador precisa
saber para qual tipo de dado ele vai
apontar, para que ele possa acessar
corretamente a informao.

A esquerda temos 3 tipos de dados em
Pascal: Byte na primeira linha, word na
segunda e longint na terceira. Veja que os
tamanhos so diferentes!
23
Exemplo de um programa que utiliza apontadores:

usi ng Syst em;

namespace Pont ei r os
{
cl ass Pr ogr amPont ei r o
{
{
/ / par a r odar est e pr ogr ama, voc deve conf i gur ar o seu pr oj et o par a r odar cdi go no pr ot egi do.
/ / par a t ant o, v ao menu pr oj ect - > pr oper t i es ( ul t i ma opo do menu) - > escol ha a aba BUI LD
/ / e mar que a opo "ALLOWUNSAFE CODE" . Sal ve o pr oj et o e compi l e- o comF5.
unsaf e
{
i nt * p1; / / cr i a uma var i vel que pode apont ar par a uma
/ / out r a var i vel i nt ei r a
i nt numer o = 7;

/ / &numer o = ender eo da var i vel numer o
p1 = &numer o; / / o pont ei r o p1 vai apont ar par a o mesmo ender eo
/ / que a var i vel numer o

/ / *p1 - > val or ar mazenado no ender eo apont ado por p1
Consol e. Wr i t eLi ne( " Var i vel nmer o: {0} pont ei r o: {1}", numer o, *p1) ;

Consol e. Wr i t e( " \ nDi gi t e umval or par a o pont ei r o: " ) ;
*p1 = Conver t . ToI nt 32( Consol e. ReadLi ne( ) ) ;

Consol e. Wr i t eLi ne( " Var i vel nmer o: {0} " , numer o) ;

Consol e. ReadLi ne( ) ;
}
}
}
}

P
PPI
IIL
LLH
HHA
AAS
SS D
DDI
IIN
NN
M
MMI
IIC
CCA
AAS
SS (
((U
UUT
TTI
IIL
LLI
IIZ
ZZA
AAN
NND
DDO
OO E
EEN
NNC
CCA
AAD
DDE
EEA
AAM
MME
EEN
NNT
TTO
OO)
))

As pilhas criadas utilizando-se apontadores so mais eficientes, pois no precisamos definir um Limite. Cada elemento da
pilha aponta para o anterior, utilizando para isso apontadores.

Para criar uma pilha utilizando apontadores, precisamos definir uma classe que possua os seguintes campos:

CLASSE NODO
Contedo do nodo (valor)
Endereo do nodo anterior

Cada elemento da pilha possui:

Valor que deve ser empilhado.
Apontador para o elemento anterior na pilha.

A base da pilha tem como elemento anterior o valor NULL.
NULL
Anterior
Anterior
Anterior
Base
Topo
24
Implementao da Pil ha di nmica utilizando obj etos encadeados

Classe Nodo.cs

/ / / <summar y>
/ / / Cl asse que i r r epr esent ar 1 el ement o na pi l ha
/ / / </ summar y>
cl ass Nodo
{
pr i vat e st r i ng val or ;
pr i vat e Nodo ant er i or ;

/ / / <summar y>
/ / / Val or que ser ar mazenado
/ / / </ summar y>
publ i c st r i ng Val or
{
get { r et ur n val or ; }
set { val or = val ue; }
}

/ / / <summar y>
/ / / Ender eo do nodo ant er i or na pi l ha
/ / / </ summar y>
publ i c Nodo Ant er i or
{
get { r et ur n ant er i or ; }
set { ant er i or = val ue; }
}
}

Classe Pilha.cs

/ / / <summar y>
/ / / Cl asse Pi l ha Di nmi ca
/ / / </ summar y>
cl ass Pi l ha
{
/ / Repr esent a o t opo da pi l ha
pr i vat e Nodo t opo = nul l ;

/ / quant i dade de el ement os na pi l ha
i nt quant i dade = 0;
publ i c i nt Quant i dade
{
get { r et ur n quant i dade; }
}

/ / / <summar y>
/ / / Mt odo par a empi l har st r i ngs
/ / / </ summar y>
/ / / <par amname="val or "></ par am>
publ i c voi d Empi l har ( st r i ng val or )
{
Nodo novoNodo = new Nodo( ) ;
novoNodo. Val or = val or ;
novoNodo. Ant er i or = t opo;

t opo = novoNodo;
quant i dade++;
}

25

/ / / <summar y>
/ / / Desempi l har el ement os da pi l ha
/ / / </ summar y>
/ / / <r et ur ns></ r et ur ns>
publ i c st r i ng Desempi l har ( )
{
i f ( quant i dade == 0)
t hr ow new Except i on( "A pi l ha est vazi a! ") ;
el se
{
st r i ng r et or no = t opo. Val or ;
t opo = t opo. Ant er i or ;
quant i dade- - ;
r et ur n r et or no;
}
}

/ / / <summar y>
/ / / Mt odo par a r et or nr o t opo da pi l ha
/ / / </ summar y>
/ / / <r et ur ns></ r et ur ns>
publ i c st r i ng Ret or naTopo( )
{
i f ( quant i dade == 0)
t hr ow new Except i on( "A pi l ha est vazi a! ") ;
el se
{
r et ur n t opo. Val or ;
}
}
}

Formulrio Principal para testar a pilha:

publ i c par t i al cl ass For m1 : For m
{
Pi l ha pi l ha = new Pi l ha( ) ;

publ i c For m1( )
{
I ni t i al i zeComponent ( ) ;
}

pr i vat e voi d bt nEmpi l har _Cl i ck( obj ect sender , Event Ar gs e)
{
pi l ha. Empi l har ( t xt Val or . Text ) ;
t xt Val or . Cl ear ( ) ;
}

26
pr i vat e voi d bt nDesempi l har _Cl i ck( obj ect sender , Event Ar gs e)
{
t r y
{
t xt Val or . Text = pi l ha. Desempi l har ( ) ;
}
{
MessageBox. Show( er r o. Message) ;
}

}

pr i vat e voi d bt nTamanho_Cl i ck( obj ect sender , Event Ar gs e)
{
MessageBox. Show( pi l ha. Quant i dade. ToSt r i ng( ) ) ;
}

pr i vat e voi d bt nRet or naTopo_Cl i ck( obj ect sender , Event Ar gs e)
{
t r y
{
t xt Val or . Text = pi l ha. Ret or naTopo( ) ;
}
{
MessageBox. Show( er r o. Message) ;
}
}
}

Exercci os:

1-) Implemente na classe da pilha dinmica um mtodo para retornar um string com todos os elementos empilhados.
Voc pode separar os elementos com um -.

2-) Implemente a Fila utilizando a mesma tcnica utilizada na pilha dinmica. Observe que no ser uma Fila circular,
pois no h mais o problema de ter que descolar os elementos quando utilizamos esta tcnica de elementos
encadeados.

3-) Altere a classe Fila dinmica para que ela armazene objetos da classe Alunos (RA int, nome string).

4-) Implemente na classe Fila um mtodo para listar os seus elementos. Devolva um string. Voc pode separar os
elementos com um -.

27
L
LLI
IIS
SST
TTA
AAS
SS S
SSI
IIM
MMP
PPL
LLE
EES
SSM
MME
EEN
NNT
TTE
EE E
EEN
NNC
CCA
AAD
DDE
EEA
AAD
DDA
AAS
SS

Material retirado da referncia [2], [3] e [4].

Em uma lista simplesmente encadeada, cada elemento contm um apontador que aponta para a o elemento seguinte. Na
implementao de listas utilizando vetores, os dados ocupavam posies contguas da memria. Sendo assim, sempre
que inclumos ou apagamos um elemento no meio da lista, precisamos reorganizar os dados do vetor, o que
computacionalmente pode ser muito custoso. Nas listas simplesmente encadeadas, os dados no ocupam posies
contguas da memria, portando operaes de remoo e incluso so executadas muito mais rapidamente. Um
elemento de uma lista simplesmente encadeada pode ser definido como na figura abaixo:

Quando criamos uma lista utilizando apontadores, precisamos ter uma varivel que aponta sempre para o incio da lista.
Abaixo, temos um exemplo de uma lista simplesmente encadeada para armazenar nomes em ordem alfabtica:

Para incluir um novo elemento, por exemplo, o nome Daniela, devemos apenas alterar o apontador prximo do
elemento que est no endereo E2. Veja abaixo:

Observe que a ordem dos endereos no importa. O que importa a ordem que eles esto encadeados!

O mesmo ocorre ao se remover um elemento da lista. Veja abaixo como ficaria a remoo do elemento Cludia:

L
LLI
IIS
SST
TTA
AAS
SS D
DDU
UUP
PPL
LLA
AAM
MME
EEN
NNT
TTE
EE E
EEN
NNC
CCA
AAD
DDE
EEA
AAD
DDA
AAS
SS

Material retirado da referncia [2], [3] e [4].

A diferena de uma lista duplamente encadeada para uma lista simplesmente encadeada que em uma lista duplamente
encadeada cada elemento contm um segundo apontador que aponta para o elemento que o antecede. Assim, voc no
precisa se preocupar mais com o incio da lista. Se voc tiver um apontador para qualquer elemento da lista, pode
encontrar o caminho para todos os outros elementos. Em uma lista duplamente encadeada, so necessrias variveis
DADOS
Endereo Prximo
Ana
E1 E2
Cludia
E2 E3
Maria
E3 NIL
Endereo do
Primeiro: E1
Ana
E1 E2
Cludia
E2 E4
Maria
E3 NIL
Endereo do
Primeiro: E1
Daniela
E4 E3
Ana
E1 E4
Cludia
E2 E4
Maria
E3 NIL
Endereo do
Primeiro: E1
Daniela
E4 E3
28
para apontar para o incio e para o final da lista. Abaixo temos a representao de um elemento de uma lista duplamente
encadeada:

Exemplo de uma lista duplamente encadeada para armazenar nomes em ordem alfabtica:

Para Inserir e Remover elementos, o processo semelhante ao apresentado na lista simplesmente encadeada. A
diferena que na lista duplamente encadeada necessrio tambm atualizar o campo anterior dos elementos.

L
LLI
IIS
SST
TTA
AAS
SS E
EEN
NNC
CCA
AAD
DDE
EEA
AAD
DDA
AAS
SS C
CCI
IIR
RRC
CCU
UUL
LLA
AAR
RRE
EES
SS

Material retirado da referncia [4].

So listas que possuem a caracterstica especial de ter, como sucessor do fim da lista, seu incio, ou melhor, o fim da lista
aponta para seu incio, formando um crculo que permite uma trajetria contnua na lista. Veja o processo na ilustrao
abaixo:

DADOS
Anterior Prximo
Endereo
Alessandra
NIL E2
E1
Endereo do
Primeiro: E1
Endereo do
ltimo: E3
Daniela
E1 E3
E2
Mnica
E2 NIL
E3
Ana
E1 E2
Cludia
E2 E3
Maria
E3 E1
Endereo do
Primeiro: E1
29
R
RRE
EEC
CCU
UUR
RRS
SSI
IIV
VVI
IID
DDA
AAD
DDE
EE O
OOU
UU R
RRE
EEC
CCU
UUR
RRS
SS
O
OO

Material retirado de:
http://pt.wikipedia.org/wiki/Recursividade (muito bom)
http://pt.wikipedia.org/wiki/Recursividade_%28ci%C3%AAncia_da_computa%C3%A7%C3%A3o%29 (timo)
http://www.di.ufpe.br/~if096/recursao/ (bom)
Referncia [1]

O que Recursividade: Uma Rotina ou Funo recursiva quando ela chama a si mesma, seja de forma direta ou
indireta. Uma funo recursiva DEVE ter um ponto de parada, ou seja, em algum momento ela deve parar de se
chamar. Praticamente todas as linguagens oferecem suporte a recursividade. Trata-se de uma tcnica de programao.

Por exemplo, segue uma definio recursiva da ancestralidade de uma pessoa:
Os pais de uma pessoa so seus antepassados (caso base);
Os pais de qualquer antepassado so tambm antepassados da pessoa em considerao (passo recursivo).

Clculo do Fatorial sem Recurso, usamos apenas
uma estrutura de repetio (iterador)
Clculo do Fatorial com Recurso direta
l ong f at _i t er at i vo( i nt numer o)
{
l ong r =1;

f or ( i nt i =2; i <= numer o; i ++)
{
r = r * i ;
}
r et ur n r ;
}
l ong f at _r ecur si vo( i nt numer o)
{
i f ( numer o == 0)
r et ur n 1;
el se i f ( numer o >= 2)
r et ur n numer o*f at _r ecur si vo( numer o- 1) ;
el se
r et ur n numer o;
}

Teste de Mesa do Fatorial de 5: azul = ida(chamada recursiva) , vermelho = volta (retorno da funo recursiva)

Resposta = Fat_recursivo(5)

Fat_recursivo(5) = 5 * Fat_recursivo( 5 1 )




Fat_recursivo(1) = 1

Recurso versus Iterao

No exemplo do fatorial, a implementao iterativa tende a ser ligeiramente mais rpida na prtica do que a
implementao recursiva, uma vez que uma implementao recursiva precisa registrar o estado atual do processamento
de maneira que ela possa continuar de onde parou aps a concluso de cada nova excecuo subordinada do
procedimento recursivo. Esta ao consome tempo e memria.
Existem outros tipos de problemas cujas solues so inerentemente recursivas, j que elas precisam manter registros de
estados anteriores. Um exemplo o percurso de uma rvore;

Toda funo que puder ser produzida por um computador pode ser escrita como funo recursiva sem o uso de iterao;
reciprocamente, qualquer funo recursiva pode ser descrita atravs de iteraes sucessivas. Todos altoritmo recursivo
pode ser implementado iterativamente com a ajuda de uma pilha, mas o uso de uma pilha, de certa forma, anula as
vantagens das solues iterativas.

1
2
6
24
120
30

Tipos de Recursividade:

Direta: Quando chama a si mesma, quando dada situao requer uma chamada da prpria Rotina em execuo para si
mesma. Ex: O exemplo de fatorial recursivo dado acima.

Indireta: Funes podem ser recursivas (invocar a si prprias) indiretamente, fazendo isto atravs de outras funes:
assim, "P" pode chamar "Q" que chama "R" e assim por diante, at que "P" seja novamente invocada.

Ex:
doubl e Cal cul o( doubl e a, b )
{
r et ur n Di vi de( a, b) + a + b;
}
doubl e Di vi de( doubl e a, b )
{
i f ( b == 0)
b = Cal cul o( a, b + a) ;

r et ur n a/ b;
}

Note que a funo f at or i al usada como exemplo na seo anterior no recursiva em cauda, pois depois que ela
recebe o resultado da chamada recursiva, ela deve multiplicar o resultado por VALOR antes de retornar para o ponto em
que ocorre a chamada.

Qual a desvantagem da Recurso?
Cada chamada recursiva implica em maior tempo e espao, pois, toda vez que uma Rotina chamada, todas as variveis
locais so recriadas.

Qual a vantagem da Recurso?
Se bem utilizada, pode tornar o algoritmo: elegante, claro, conciso e simples. Mas, preciso antes decidir sobre o uso da
Recurso ou da Iterao.

Exerccios
Exercci o 1:

Faa um programa para calcular a potencia de um nmero. O mtodo recursivo deve receber como parmetro a base e
o expoente, e devolver o valor da potncia.

EX: double CalculaPotencia (int base, int expoente)
CalculaPotencia (2,3) = 8

Exercci o 2:
Faa o teste de mesa do seu mtodo para os valores informados acima.

Exercci o 3:

Faa um programa para imprimir a tabuada, usando recursividade.

Exercci o 4:

Faa um mtodo para limpar todos os makedit e os Textbox de um form, mesmo que eles estejam dentro de panels,
groupbox.
Aqui ocorre a
recursividade
indireta!
31
R
RRV
VVO
OOR
RRE
EES
SS

Material retirado da referncia [3].

Uma rvore um tipo abstrato de dados que armazena elementos de maneira hierrquica. Como exceo do elemento
do topo, cada elemento tem um elemento pai e zero ou mais elementos filhos. Uma rvore normalmente desenhada
colocando-se os elementos dentro de elipses ou retngulos e conectando pais e filhos com linhas retas. Normalmente o
elemento topo chamado de raiz da rvore, mas desenhado como sendo o elemento mais alto, com todos os demais
conectados abaixo (exatamente ao contrrio de uma rvore real).

EX: Uma rvore que representa a estrutura de pastas em um Hard Disk:

Uma rvore T um conjunto de nodos que armazenam elementos em relacionamentos pai-filho com as seguintes
propriedades:
T tem um nodo especial, r, chamado de raiz de T.
Cada nodo v de T diferente de r tem um nodo pai u.
Se um nodo u pai de um nodo v, ento dizemos que v filho de u.
Dois nodos que so filhos de um mesmo pai so irmos.
Um nodo externo (ou folha) se no tem filhos.
Um nodo interno se tem um ou mais filhos.
Um subrvore de T enraizada no nodo v a rvore formada por todos os descendentes de v em T (incluindo o
prprio v).
O ancestral de um nodo tanto um ancestral direto como um ancestral do pai do nodo.
Um nodo v descendente de u se u um ancestral de v. Ex: na figura acima, Meus documentos ancestral
de 2 Semestre e 2 Semestre descendente de Meus documentos.
Seja v um nodo de uma rvore T. A profundidade de v o nmero de ancestrais de v, excluindo o prprio v.
Observe que esta definio implica que a profundidade da raiz de T 0 (zero). Como exemplo, na figura acima, a
profundidade do nodo Trabalhos 2, e a profundidade do nodo 2 semestre 3.
A altura de um nodo o comprimento do caminho mais longo desde nodo at um n folha ou externo. Sendo
assim, a altura de uma rvore a altura do nodo Raiz. No exemplo acima, a rvore tem altura 3. Tambm se diz
que a altura de uma rvore T igual profundidade mxima de um nodo externo de T.

A figura abaixo representa uma subrvore da rvore acima. Esta subrvore possui 5 nodos, onde 2 so nodos internos
(Meus Documentos e Trabalhos) e 3 so nodos externos (Provas, 1 Semestre e 2 Semestre). A altura desta subarvore
2.

Meus documentos
Trabalhos Provas
1
Semestre
2
Semestre
C:\
Arquivos de programas Windows Meus documentos
Office 2000 MSN Trabalhos Provas System32 Media Config
1
Semestre
2
Semestre
Raiz
32

Os principais mtodos de uma rvore so:
Raiz: Retorna a raizda rvore
Pai(nodo): Retorna o pai de um nodo. Ocorre um erro se nodo for a raiz.
Filho(nodo): Retorna os filhos de um nodo.
Nodo_ eh_Interno(nodo): Testa se um nodo do tipo interno.
Nodo_ eh_externo(nodo): Testa se um nodo do tipo externo.
Nodo_ eh_raiz(nodo): Testa se um nodo a raiz.
Tamanho: Retorna a quantidade de nodos de uma rvore.

P
PPE
EER
RRC
CCU
UUR
RRS
SSO
OO (
((O
OOU
UU C
CCA
AAM
MMI
IIN
NNH
HHA
AAM
MME
EEN
NNT
TTO
OO)
)) E
EEM
MM
R
RRV
VVO
OOR
RRE
EES
SS

O percurso de uma rvore a maneira ordenada de percorrer todos os nodos da rvore (percorrer todos os seus ns,
sem repetir nenhum e sem deixar de passar por nenhum). utilizada, por exemplo, para consultar ou alterar as
informaes contidas nos ns.

Percurso prefixado
Um nodo visitado antes de seus descendentes. Exemplo de aplicao: Imprimir um documento estruturado.

Os nmeros em vermelho indicam a ordem em que os nodos so visitados. Caso fossem impressos, o resultado seria:
Documento, Captulo 1, Seo 1.1, Seo 1.2, Captulo 2, Seo 2.1, Seo 2.2, Seo 2.3, Referncias.

Percurso ps-fixado
Neste caminho, um nodo visitado aps seus descendentes. Exemplo de aplicao: Calcular o espao ocupado por
arquivos em pastas e subpastas.

Os nmeros em vermelho indicam a ordem em que os nodos so visitados. Caso fossem impressos, o resultado seria:
H1c.doc 3k, h1nc.doc 2k, homeworks/, DDR.java 10k, Stocks.java 25k, Robot.java 20k, programs/, todo.txt 1k,
cs16/.
33

R
RRV
VVO
OOR
RRE
EES
SS B
BBI
IIN
NN
R
RRI
IIA
AAS
SS
Material retirado da referncia [2] e [3].

Uma rvore binria uma rvore ordenada na qual todo nodo tem, no mximo, dois filhos. Uma rvore binria
imprpria aquela que possui apenas 1 filho. J uma rvore binria prpria aquela em que todo nodo tem zero ou dois
filhos, ou seja, todo nodo interno tem exatamente 2 filhos. Isso porque um nodo externo no tem filhos, ou seja, zero
filhos. Para cada filho de um nodo interno, nomeamos cada filho como filho da esquerda e filho da direita. Esses
filhos so ordenados de forma que o filho da esquerda venha antes do filho da direita.

A rvore binria suporta mais 3 mtodos adicionais:

Filho_da_ esquerda(nodo): Retorna o filho da esquerda do nodo.
Filho_da_ direita(nodo): Retorna o filho da direita do nodo.
Irmo(nodo): Retorna o irmo de um nodo

Caminhamento adicional para rvores binrias

Caminhamento interfixado: pode ser informalmente considerado como a visita aos nodos de uma rvore da esquerda
para a direita. Para cada nodo v, o caminhamento interfixado visita v aps todos os nodos da subrvore esqueda de v e
antes de visitar todos os nodos da subrvore direita de v.

O Caminhamento de Euler: sobre uma rvore binria T pode ser informalmente definido como um passeio ao redor
de T, no qual iniciamos pela raiz em direo ao filho da esquerda e consideramos as arestas de T como sendo paredes
que devemos sempre manter nossa esquerda. Cada nodo de T visitado trs vezes pelo caminhamento de Euler.

Propriedades de uma rvore binria

Seja T uma rvore binria (prpria) com n nodos e seja h a altura de T. Ento T tem as seguintes propriedades:

1. O nmero de nodos externos de T pelo menos h+1 e no mximo 2
h
.
2. O nmero de nodos internos de T pelo menos h e no mximo 2
h
1.
3. O nmero total de nodos de T pelo menos 2h +1 e no mximo 2
h+1
-1.
4. A profundidade de T pelo menos log(n+1) -1 e no mximo (n-1)/2.
Os elementos acessados por este
caminhamento formam a expresso:

2 x (a 1) + (3 x b)

Os parnteses foram colocados para facilitar.
Prioridade das aes para efetuar o caminhamento:

Ao pela esquerda (antes do caminho sobre
a subrvore esquerda de v);
Ao por baixo (entre o caminhamento sobre
as duas subrvores de v);
Ao pela direita (depois do caminhamento
sobre a subrvore direita de v).
34
R
RRV
VVO
OOR
RRE
EES
SS B
BBI
IIN
NN
R
RRI
IIA
AAS
SS D
DDE
EE B
BBU
UUS
SSC
CCA
AA

Material retirado da referncia [2] e [3].

Uma rvore de pesquisa binria uma rvore binria em que todo n interno contm um registro, e, para cada n,
todos os registros com chaves menores esto na subrvore esquerda e todos os registros com chaves maiores esto na
subrvore direita.

Podemos usar uma rvore binria de pesquisa T para localizar um elemento com um certo valor x percorrendo para
baixo a rvore T. Em cada nodo interno, comparamos o valor do nodo corrente com o valor do elemento x sendo
pesquisado.
Se a resposta da questo for menor, ento a pesquisa continua na subrvore esquerda.
Se a resposta for igual, ento a pesquisa terminou com sucesso.
Se a resposta for maior, ento a pesquisa continua na subrvore direita.
Se encontrarmos um nodo externo (que vazio), ento a pesquisa terminou sem sucesso.

A figura acima representa uma rvore binria de pesquisa que armazena inteiros. O caminho indicado pela linha azul
corresponde ao caminhamento ao procurar (com sucesso) 36. A linha pontilhada vermelha corresponde ao
caminhamento ao procurar (sem sucesso) por 70. Observe que o tempo de execuo da pesquisa em uma rvore
binria de pesquisa T proporcional altura de T.

Estrutura para armazenar um nodo da rvore binria:

Exemplo para os valores inseridos na ordem:
1. Maria
2. Mnica
3. Daniela

58
31 90
62
75
42
36
25
12
N da
esquerda
N da
direita
Informao
do n
(valor)
Endereo N do pai
E2 E3
Maria
E1 Nil
E4 E5 Daniela
E2 E1
E6 E7 Mnica
E3 E1
Nil Nil
E5 E2
Nil Nil
E4 E2
Nil Nil
E7 E3
Nil Nil
E6 E3
Os nodos folha sem
valor so necessrios
para que a rvore seja
prpria

Ordem em que os
elementos foram
inseridos:
58,90,62,75,31,25,
12,42,36
35

Algoritmo para pesquisar um valor em uma rvore binria de pesquisa:

Pesquisa( nodo, valor_pesquisado ) : Retorno
Inicio
se Nodo_eh_externo(Nodo) = verdadeiro ento
escreva( Erro: Valor procurado no est na rvore!);
pesquisa := nil
caso contrrio
Se valor_pesquisado < nodo.valor ento
pesquisa ( nodo.esquerda, valor_pesquisado )
caso contrrio se valor_pesquisado > nodo.valor ento
pesquisa ( nodo.direita, valor_pesquisado )
caso contrrio
pesquisa := nodo.valor;
Fim

Algoritmo para inserir um valor em uma rvore binria de pesquisa:

Insere( nodo, NovoValor )
Incio
se Nodo_eh_externo(nodo) = verdadeiro ento
CriaNodoExterno( nodo.esquerda )
CriaNodoExterno( nodo.direita )
Nodo.valor := NovoValor
caso contrrio
se NovoValor < nodo.valor ento
Insere ( nodo.esquerda , NovoValor)
caso contrrio se NovoValor > nodo.valor ento
Insere ( nodo.direita , NovoValor)
caso contrrio
escreva(O valor j existe na rvore.);
Fim;

O mtodo CriaNodoExterno cria um
nodo externo (sem valor e sem
filhos)
36
Implementao de uma rvore Binria de Busca em C#

/ / cl asse par a r epr ent ar 1 Nodo na r vor e
cl ass Nodo
{
pr i vat e Nodo no_pai = nul l ;
pr i vat e Nodo no_di r ei t a = nul l ;
pr i vat e Nodo no_esquer da = nul l ;
pr i vat e i nt val or = 0;

publ i c i nt get _val or ( ) { r et ur n val or ; }

publ i c voi d set _val or ( i nt v) { val or = v; }

publ i c voi d set _no_pai ( Nodo no) { no_pai = no; }

publ i c voi d set _no_di r ei t a( Nodo no) { no_di r ei t a = no; }

publ i c voi d set _no_esquer da( Nodo no) { no_esquer da = no; }

publ i c Nodo get _no_pai ( ) { r et ur n no_pai ; }

publ i c Nodo get _no_di r ei t a( ) { r et ur n no_di r ei t a; }

publ i c Nodo get _no_esquer da( ) { r et ur n no_esquer da; }
}

/ / cl asse da r vor e de pesqui sa bi nr i a
cl ass Ar vor eBi n
{
pr i vat e Nodo r ai z = nul l ; / / r ai z da r vor e
pr i vat e i nt qt de = 0; / / qt de de nos i nt er nos
pr i vat e st r i ng r esul t ado = " ";

publ i c i nt qt de_nos_i nt er nos( ) / / devol ve a qt de de ns i nt er nos
{
r et ur n qt de;
}

publ i c bool no_eh_ext er no( Nodo no) / / ver i f i ca se umdet er mi nado Nodo ext er no
{
r et ur n ( no. get _no_di r ei t a( ) == nul l ) && ( no. get _no_esquer da( ) == nul l ) ;
}

publ i c Nodo cr i a_No_ext er no( Nodo Nopai ) / / cr i a umNodo ext er no
{
Nodo no = new Nodo( ) ;
no. set _no_pai ( Nopai ) ;
r et ur n no;
}

N da
esquerda
N da
direita
Informao do
n
(valor)
Endereo N do pai
37

publ i c voi d i nser e( i nt val or ) / / i nser e umval or i nt
{
Nodo no_aux;

i f ( qt de == 0)
{
/ / r vor e vazi a, devemos cr i ar o pr i mei r o Nodo, que ser a r ai z
no_aux = new Nodo( ) ;
r ai z = no_aux;
}
el se
{
/ / l ocal i za onde deve ser i nser i do o novo n.
no_aux = r ai z;
whi l e ( no_eh_ext er no( no_aux) == f al se)
{
i f ( val or > no_aux. get _val or ( ) )
no_aux = no_aux. get _no_di r ei t a( ) ;
el se
no_aux = no_aux. get _no_esquer da( ) ;
}
}
/ / est e er a umNodo ext er no e por t ant o no t i nha f i l hos.
/ / Agor a el e passar a t er val or . Tambmdevemos cr i ar out r os 2
/ / Nodos ext er nos ( f i l hos) par a el e.
no_aux. set _val or ( val or ) ;
no_aux. set _no_di r ei t a( cr i a_No_ext er no( no_aux) ) ;
no_aux. set _no_esquer da( cr i a_No_ext er no( no_aux) ) ;
qt de++;
}

pr i vat e voi d Le_Nodo( Nodo no)
{
i f ( no_eh_ext er no( no) )
r et ur n;

Le_Nodo( no. get _no_esquer da( ) ) ;
r esul t ado = r esul t ado + " - " + Conver t . ToI nt 32( no. get _val or ( ) ) ;
Le_Nodo( no. get _no_di r ei t a( ) ) ;
}

/ / devol ve umst r i ng comos el ement os da r vor e, emor demcr escent e
publ i c st r i ng l i st agem( )
{
r esul t ado = "" ;
Le_Nodo( r ai z) ;
r et ur n r esul t ado;
}
}

38
Interface com o Usurio:

Cdigo da interface com o usurio:

publ i c par t i al cl ass For m1 : For m
{
pr i vat e Ar vor eBi n mi nhaAr vor e = new Ar vor eBi n( ) ;

publ i c For m1( )
{
I ni t i al i zeComponent ( ) ;
}

pr i vat e voi d but t on1_Cl i ck( obj ect sender , Event Ar gs e)
{
t r y
{
mi nhaAr vor e. i nser e( Conver t . ToI nt 32( t xt Val or . Text ) ) ;
l i st Box1. I t ems. Add( " I nser i do: " + t xt Val or . Text ) ;
}
cat ch{
MessageBox. Show( "Val or i nvl i do! Di gi t e apenas nmer os! " ) ;
}
t xt Val or . Cl ear ( ) ;
t xt Val or . Focus( ) ;
}

{
l i st Box1. I t ems. Add( mi nhaAr vor e. l i st agem( ) ) ;
}

{
l i st Box1. I t ems. Add( " Qt de: " + mi nhaAr vor e. qt de_nos_i nt er nos( ) ) ;
}

{
Cl ose( ) ;
}
}

39

G
GGR
RRA
AAF
FFO
OOS
SS

Material sobre grafos: [3], [4] e http://www.inf.ufsc.br/grafos/livro.html

Um grafo um conjunto de pontos, chamados vrtices (ou nodos ou ns), conectados por linhas, chamadas de arestas
(ou arcos). Dependendo da aplicao, arestas podem ou no ter direo, pode ser permitido ou no arestas ligarem um
vrtice a ele prprio e vrtices e/ou arestas podem ter um peso (numrico) associado. Se todas as arestas tm uma
direo associada (indicada por uma seta na representao grfica) temos um grafo dirigido, ou dgrafo. Se todas as
arestas em um grafo foram no-dirigidas, ento dizemos que o grafo um grafo no-dirigido. Um grafo que tem
arestas no-dirigidas e dirigidas chamado de grafo misto.

Algumas definies sobre grafos:
Grau: nmero de arestas ligadas a um vrtice.
Grau de entrada: nmero de setas que chegam em um vrtice X, in(X).
Grau de sada: nmero de setas que saem de um vrtice X, out(X).
Fonte: todo vrtice, cujo grau de entrada 0(zero).
Sumidouro (poo): todo vrtice, cujo grau de sada 0(zero).
Vrtice
Aresta
Exemplo de um grafo no-dirigido com 6 vrtices e 7 arestas.

So Paulo
Rio de
Janeiro
Cuiab
Braslia
Manaus
Exemplo de um grafo dirigido com 8 arestas e 5 vrtices.
40

O
OOR
RRD
DDE
EEN
NNA
AA
O
OO

Material retirado de:
Referncia [2], [3]
http://pt.wikipedia.org/wiki/Algoritmo_de_ordena%C3%A7%C3%A3o (com exemplos em vrias linguagens)

Ordenar corresponde ao processo de rearranjar um conjunto de objetos em uma ordem ascendente ou descendente. O
objetivo principal da ordenao facilitar a recuperao posterior de itens do conjunto ordenado. Imagine como seria
difcil utilizar um catlogo telefnico se os nomes das pessoas no estivessem listados em ordem alfabtica!
Existem diversos mtodos para realizar ordenao. Iremos estudar aqui dois dos principais mtodos.

Bubble sort

O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um algoritmo de ordenao dos mais simples. A
ideia percorrer o vector diversas vezes, a cada passagem fazendo flutuar para o topo o menor elemento da sequncia.
Essa movimentao lembra a forma como as bolhas em um tanque de gua procuram seu prprio nvel, e disso vem o
nome do algoritmo.

No melhor caso, o algoritmo executa (n2) / 2 operaes relevantes. No pior caso, so feitas 2n2operaes. No caso
mdio, so feitas (5n2) / 2 operaes. A complexidade desse algoritmo de Ordem quadrtica. Por isso, ele no
recomendado para programas que precisem de velocidade e operem com quantidade elevada de dados.
O algoritmo pode ser descrito em pseudo-cdigo como segue abaixo. V um VECTOR de elementos que podem ser
comparados e n o tamanho desse vector.

BUBBLESORT ( V[ ] , n)
1 houveTr oca : = ver dade # uma var i vel de cont r ol e
2 enquant o houveTr oca f or ver dade f aa
3 houveTr oca : = f al so
4 par a i de 1 at n- 1 f aa
5 se V[ i ] vemdepoi s de V[ i + 1]
6 ent o t r oque V[ i ] e V[ i + 1] de l ugar e
7 houveTr oca : = ver dade
Implementao em C# utilizando For e While
cl ass C_Bubbl eSor t
{
st at i c i nt [ ] Or dena_Bubbl eSor t ( i nt [ ] vet or )
{
i nt aux;

f or ( i nt i = vet or . Lengt h - 1; i >= 1; i - - )
{
f or ( i nt j = 0; j <= i - 1; j ++)
{
i f ( vet or [ j ] > vet or [ j + 1] )
{
/ / ef et ua a t r oca de val or es
aux = vet or [ j ] ;
vet or [ j ] = vet or [ j + 1] ;
vet or [ j + 1] = aux;
}
}
}
r et ur n vet or ;
}

{
i nt [ ] dados = new i nt [ 10] ;

f or ( i nt i = 0; i < dados. Lengt h; i ++)
{
Consol e. Wr i t eLi ne( "I nf or me umnmer o") ;
dados[ i ] =Conver t . ToI nt 16( Consol e. ReadLi ne( ) ) ;
}

Or dena_Bubbl eSor t ( dados) ;

Consol e. Wr i t eLi ne( "\ n\ nDados or denados: " ) ;
{
cl ass C_Bubbl eSor t
{
st at i c i nt [ ] Or dena_Bubbl eSor t ( i nt [ ] vet or )
{
i nt aux;
bool houvet r oca;

do
{
houvet r oca = f al se;
f or ( i nt j = 0; j <= vet or . Lengt h - 2; j ++)
{
i f ( vet or [ j ] > vet or [ j + 1] )
{
/ / ef et ua a t r oca de val or es
houvet r oca = t r ue;
aux = vet or [ j ] ;
vet or [ j ] = vet or [ j + 1] ;
vet or [ j + 1] = aux;
}
}
}
whi l e ( houvet r oca == t r ue) ;

r et ur n vet or ;
}

{

{
Consol e. Wr i t eLi ne( "I nf or me umnmer o") ;
dados[ i ] = Conver t . ToI nt 16( Consol e. ReadLi ne( ) ) ;
}

41
}
Consol e. ReadKey( ) ;
}
}
Or dena_Bubbl eSor t ( dados) ;

Consol e. Wr i t eLi ne( "\ n\ nDados or denados: " ) ;
{
}

Consol e. ReadKey( ) ;
}
}

Quicksort

O algoritmo Quicksort um mtodo de ordenao muito rpido e eficiente, inventado por C.A.R. Hoare em 1960,
quando visitou a Universidade de Moscou como estudante. Foi publicado em 1962 aps uma srie de refinamentos.
O Quicksort adota a estratgia de diviso e conquista. Os passos so:
1. Escolha um elemento da lista, denominado piv (de forma randmica);
2. Rearranje a lista de forma que todos os elementos anteriores ao piv sejam menores ou iguais a ele, e todos os
elementos posteriores ao piv sejam maiores ou iguais a ele. Ao fim do processo o piv estar em sua posio
final. Essa operao denominada partio;
3. Recursivamente ordene a sublista dos elementos menores e a sublista dos elementos maiores;
A base da recurso so as listas de tamanho zero ou um, que esto sempre ordenadas. O processo finito pois a cada
iterao pelo menos um elemento posto em sua posio final e no ser mais manipulado na iterao seguinte.
Complexidade
O(n lg
2
n) no melhor caso e no caso mdio
O(n
2
) no pior caso;
Implementaes
Al gori tmo em portugus estruturado

pr oc qui cksor t ( x: vet [ n] i nt ; i ni : i nt ; f i m: i nt ; n: i nt )
var
i nt : i , j , y, aux;

i n ci o
i <- i ni ;
j <- f i m;
y <- x[ ( i ni + f i m) di v 2] ;
r epet e
enquant o ( x[ i ] < y) f aa
i <- i + 1;
f i m- enquant o;
enquant o ( x[ j ] > y) f aa
j <- j - 1;
f i m- enquant o;
se ( i <= j ) ent o
aux <- x[ i ] ;
x[ i ] <- x[ j ] ;
x[ j ] <- aux;
i <- i + 1;
j <- j - 1;
f i m- se;
at _que ( i >= j ) ;
se ( j > i ni ) ent o
exec qui cksor t ( x, i ni , j , n) ;
f i m- se;
se ( i < f i m) ent o
exec qui cksor t ( x, i , f i m, n) ;
f i m- se;
f i m.

42

43
I mplementao em C#

Mtodo que efetua a ordenao
st at i c voi d Qui ckSor t ( i nt [ ] vet or , i nt esq, i nt di r )
{
i nt pi vo, aux, i , j ;
i nt mei o;

i = esq;
j = di r ;

mei o = ( i nt ) ( ( i + j ) / 2) ;
pi vo = vet or [ mei o] ;

do
{
whi l e ( vet or [ i ] < pi vo) i = i + 1;
whi l e ( vet or [ j ] > pi vo) j = j - 1;

i f ( i <= j )
{
aux = vet or [ i ] ;
vet or [ i ] = vet or [ j ] ;
vet or [ j ] = aux;
i = i + 1;
j = j - 1;
}
}
whi l e ( j > i ) ;

i f ( esq < j ) Qui ckSor t ( vet or , esq, j ) ;
i f ( i < di r ) Qui ckSor t ( vet or , i , di r ) ;
}

Mtodo MAIN que solicita os nmeros e chama o mtodo quicksort para ordenar.

{

Consol e. Wr i t eLi ne( "Ent r e com{0} nmer os", dados. Lengt h) ;
{
dados[ i ] = Conver t . ToI nt 16( Consol e. ReadLi ne( ) ) ;
}

Qui ckSor t ( dados, 0, dados. Lengt h - 1) ;

Consol e. Wr i t eLi ne( "\ n\ nNmer os or denados: \ n" ) ;
{
Consol e. Wr i t eLi ne ( dados[ i ] ) ;
}

Consol e. ReadLi ne( ) ;
}
44
P
PPE
EES
SSQ
QQU
UUI
IIS
SSA
AA E
EEM
MM M
MME
EEM
MM
R
RRI
IIA
AA P
PPR
RRI
IIM
MM
R
RRI
IIA
AA

Pesquisa seqencial

Retirado de : http://pucrs.campus2.br/~annes/alg3_pesqseq.html
[2]

O mtodo de pesquisa mais simples que existe funciona da seguinte forma: a partir do primeiro registro, pesquise
sequencialmente at encontrar a chave procurada; ento pare. A complexidade desta pesquisa no pior caso n, onde n
o tamanho total do vetor sendo pesquisado.

{Algoritmo em Pascal}
Function PesquisaSequencial(vetor : array of Integer, chave,n : integer) : integer;
Var i: integer;
Achou : boolean;
Begin
PesquisaSequencial := -1; { significa que no encontrou }
Achou := false;
i:= 1;
Repeat
If vetor[i] = chave then
Begin
Achou := true;
PesquisaSequencial := i;
End;
i := i + 1;
Until (i > n) or (achou = true);
End;

Dado o exemplo:

5 7 1 9 3 21 15 99 4 8

No exemplo acima, seriam necessrias 7 iteraes para encontrar o valor 15.

Pesquisa Binria

Retirado de : http://pt.wikipedia.org/wiki/Pesquisa_bin%C3%A1ria
[2]
A pesquisa ou busca binria ( em ingls binary search algorithm ou binary chop ) um algoritmo de busca em vetores
que requer acesso aleatrio aos elementos do mesmo. Ela parte do pressuposto de que o vetor est ordenado, e
realiza sucessivas divises do espao de busca comparando o elemento buscado (chave) com o elemento no meio do
vetor. Se o elemento do meio do vetor for a chave, a busca termina com sucesso. Caso contrrio, se o elemento do meio
vier antes do elemento buscado, ento a busca continua na metade posterior do vetor. E finalmente, se o elemento do
meio vier depois da chave, a busca continua na metade anterior do vetor. A complexidade desse algoritmo da ordem
de log2 n, onde n o tamanho do vetor de busca.
Um pseudo-cdigo recursivo para esse algoritmo, dados V o vetor com elementos comparveis, n seu tamanho e e o
elemento que se deseja encontrar:
BUSCA- BI NRI A ( V[ ] , i ni ci o, f i m, e}
i r ecebe o ndi ce no mei o de i ni ci o e f i m
se V[ i ] i gual a e
ent o devol va o ndi ce i # encont r ei e
45
seno se V[ i ] vemant es de e
ent o f aa a BUSCA- BI NRI A( V, i +1, f i m, e)
seno f aa a BUSCA- BI NRI A( V, i ni ci o, i - 1, e)

{Algortmo em Pascal}
f unct i on BuscaBi nar i a ( Vet or : ar r ay of st r i ng; Chave: st r i ng; Di m: i nt eger ) : i nt eger ;
var i ni ci o, f i m: i nt eger ; {Auxi l i ar es que r epr esent amo i ni ci o e o f i mdo vet or anal i sado}
mei o: i nt eger ; {Mei o do vet or }
begi n
f i m: = Di m; {O val or do l t i mo ndi ce do vet or }
i ni ci o : = 1; {O val or do pr i mei r o ndi ce do vet or }
r epeat
mei o : = ( i ni ci o+f i m) di v 2;
i f ( Chave = vet or [ mei o] ) t hen
BuscaBi nar i a : = mei o;
i f ( Chave < vet or [ mei o] ) t hen
f i m: =( mei o- 1) ;
i f ( Chave > vet or [ mei o] ) t hen
i ni ci o: =( mei o+1) ;
unt i l ( Chave = Vet or [ mei o] ) or ( i ni ci o > f i m) ;
i f ( Chave = Vet or [ mei o] ) t hen
BuscaBi nar i a : = mei o
el se
BuscaBi nar i a : = - 1; {Ret or na o val or encont r ado, ou - 1 se a chave nao f oi encont r ada. }
end;

rvores de pesquisa

Vide rvores Binrias de Busca.

Apostila de Estrutura de Dados C Atualizada

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila de Estrutura de Dados C Atualizada

Enviado por

Direitos autorais:

Formatos disponíveis

1

Apostila de Estrutura de Dados e Algoritmos em C#

Você também pode gostar