Estrutura de Dados

Parte 4

Material compilado para utilização na disciplina

de Estrutura de Dados, do curso de Tecnologia
em Sistemas Para Internet UAB/IFMT.

Prof. Orlando P. S. Júnior

orlando.junior@cba.ifmt.edu.br
Sumário
1. Tipos Abstratos de Dados ................................................................................................................. 1
1.1. Introdução..................................................................................................................................... 1
1.2. TAD ................................................................................................................................................ 1
1.2.1. Conceito ................................................................................................................................ 1
1.2.2. Especificação e Implementação ............................................................................................ 2
1.2.3. Exemplo de implementado de TAD de uma Lista de Números ............................................ 2
1.2.4. Código-Fonte do TAD de Lista Simples de Números............................................................. 4
1. Tipos Abstratos de Dados

1.1. Introdução
À medida que evoluímos no estudo das estruturas de dados, desde a declaração de variáveis comuns,
passando pelas variáveis indexadas e a utilização dos registros, podemos entender que o tratamento dos
dados vai ficando mais sofisticado, com mais recursos e tratamentos específicos.

Na verdade, toda essa evolução se deu justamente por esse motivo, pela necessidade de tratar os dados
de maneira adequada e personalizada.

O surgimento dos Tipos Abstratos de Dados – TAD, veio ao encontro dessa necessidade de tratamento
mais sofisticado e particular. Um TAD é, portanto, um conjunto de procedimentos que atuam com
exclusividade sobre determinados dados, sejam eles variáveis comuns, variáveis indexadas ou até mesmo
registros.

1.2. TAD
1.2.1. Conceito
Como já visto, um TAD é um conjunto de procedimentos que atuam com exclusividade sobre
determinados dados, sejam eles variáveis comuns, variáveis indexadas ou até mesmo registros. Em linhas
gerais é a junção de dados e de seus tratamentos particulares, que vão desde a forma correta de
alimentar, ler armazenar internamente ao TAD tais dados.

Dessa forma qualquer operação realizada sobre os dados encapsulados por um TAD só poderá ser
executada por intermédio dos procedimentos definidos no TAD e nunca fora de seu controle, sendo esta
restrição a característica operacional mais útil dessa estrutura.

Um TAD deverá conter algoritmos e estruturas de dados adequadas, implementados conforme a

linguagem adotada, com seções bem definidas, sendo para a definição das estruturas de dados que
armazenarão os dados e outra para a definição do conjunto de algoritmos.

Um TAD pode ser utilizado por diversos outros programas que o utilizem para implementar situações
fáticas, voltadas apenas à instrumentalização do TAD, sendo que o mesmo poderá sofrer alterações sem
impactar os demais programas que o utilizem.

Por fim, pode-se dizer que um TAD bem construído pode tornar-se uma porção de código confiável e
genérica, permitindo e aconselhando seu reuso em outros programas. Dessa forma, aumenta-se a
produtividade na construção de programas e, sobretudo, garante-se a qualidade dos produtos gerados.

1
1.2.2. Especificação e Implementação
Com a informação de um Tipo Abstrato de Dados é um conjunto de procedimentos que atuam com
exclusividade sobre determinados dados, podemos, então, entender que podemos conceber e construir
TAD’s para diversos contextos, desde que queiramos representar funcionalidades e encapsular a forma
como os dados são armazenados.

Como estamos utilizando o Visual G, que é uma ferramenta acadêmica que enfrenta inúmeras limitações,
não poderemos exemplificar um dos recursos mais importantes de um TAD, que é o reuso. Dessa forma,
implementaremos TAD’s e os faremos funcionar dentro do mesmo programa.

A título de exemplo, podemos criar um TAD para representar uma Lista de Números, que possui o objetivo
de armazenar números em uma determinada sequência, inserir, retirar, verificar se a lista está vazia ou
verificar se a lista está cheia.

Diversas variações desse TAD podem ser implementadas, como por exemplo, uma Lista de Aluno, sendo
Aluno um tipo registro implementado e encapsulado (escondido) dos usuários do TAD. Métodos
adicionais e personalizados podem ser adicionados ao TAD, como ordenação, validações e etc.

1.2.3. Exemplo de implementado de TAD de uma Lista de Números

Para fins de exemplificação, foi implementada um TAD para abstrair o funcionamento de uma Lista
Simples de Números. De acordo com as limitações do Visual G, foram implementadas as seguintes
operações:

Operação Descrição
inicializaLista Realiza a inicialização dos elementos do vetor, que
é a estrutura de armazenamento interna.
listaVazia : logico Verifica se a lista está vazia, ou seja, se não contém
algum elemento.
listaCheia : logico De modo antagônico à operação anterior, verifica
se a lista está cheia, ou seja, se contém algum
elemento.
insere(numero : real) Insere um elemento no final da lista.
insereNaPosicao(numero : real; posicao : inteiro) Insere um elemento na posição indicada,
necessitando realizar o deslocamento, se for o
caso.
retiraNaPosicao(posicao : inteiro) Retirando um elemento de uma determinada
posição, necessitando realizar o recolhimento, se
for o caso.
deslocar(posicaoAPartir : inteiro) Operação que desloca os elementos da lista,
abrindo uma lacuna para a inserção de um
elemento.

2
 recolher(posicaoAPartir : inteiro) Operação que recolhe os elementos da lista,
preenchendo lacunas geradas pela remoção de
um elemento.
listar Lista os elementos contidos.
imprimirMenu() Imprime um Menu de Opção ao usuário.
lerPosicaoValida : inteiro Lê uma posição válida entre 1 e o tamanho
máximo, controlado pela Qtde. de Elementos.
lerValor : real Lê um determinado valor.

O TAD em questão armazenou a lista em um vetor de inteiros, de acordo com a capacidade da linguagem
do Visual G. Em linguagens mais sofisticadas, pode-se implementar usando recursos de orientação a
objetos mais avançados.

A seguir, será exibido o código-fonte do TAD.

3
1.2.4. Código-Fonte do TAD de Lista Simples de Números

algoritmo "TADListaLinearSimples"
procedimento inicializaLista
inicio
para i de 1 ate 5 faca
vet[i] <- valorPadrao
fimpara
qtdeElementos <- 0
ultimoElemento <- 0
fimprocedimento
funcao listaVazia : logico
inicio
retorne qtdeElementos = 0
fimfuncao
funcao listaCheia : logico
inicio
retorne qtdeElementos >= 5
fimfuncao
procedimento insere(numero : real)
inicio
se nao listaCheia entao
ultimoElemento <- ultimoElemento + 1
vet[ultimoElemento] <- numero
qtdeElementos <- qtdeElementos + 1
fimse
fimprocedimento
procedimento insereNaPosicao(numero : real; posicao : inteiro)
inicio
se listaCheia entao
retorne
senao
se listaVazia entao
insere(numero)
senao
deslocar(posicao)
vet[posicao] <- numero
qtdeElementos <- qtdeElementos + 1
fimse
fimse
fimprocedimento

4
procedimento retiraNaPosicao(posicao : inteiro)
inicio
recolher(posicao)
qtdeElementos <- qtdeElementos - 1
fimprocedimento
procedimento deslocar(posicaoAPartir : inteiro)
var _i : inteiro
inicio
para _i de ultimoElemento + 1 ate posicaoAPartir + 1 passo -1 faca
vet[_i] <- vet[_i - 1]
fimpara
ultimoElemento <- ultimoElemento + 1
fimprocedimento
procedimento recolher(posicaoAPartir : inteiro)
var _i : inteiro
inicio
para _i de posicaoAPartir ate ultimoElemento - 1 faca
vet[_i ] <- vet[_i + 1]
fimpara
vet[ultimoElemento] <- valorPadrao
ultimoElemento <- ultimoElemento - 1
fimprocedimento
procedimento listar
var _i : inteiro
inicio
escreval("Lista: ")
para _i de 1 ate ultimoElemento faca
escreva(vet[_i], " ")
fimpara
fimprocedimento
procedimento imprimirMenu()
inicio
escreval("Menu para operacionar o TAD Lista")
escreval("=================================")
escreval("Opção 1:...................Listar")
escreval("Opção 2:.............Lista Vazia?")
escreval("Opção 3:.....Inserir na posição X")
escreval("Opção 4:..................Inserir")
escreval("Opção 5:.....Retirar na posição X")
escreval("Opção 6:........Qtde de Elementos")
escreval("Opção 7:..........Último Elemento")
escreval("Opção 8:.....................Sair")
escreva("Digite sua opção:..............:")
fimprocedimento

5
funcao lerPosicaoValida : inteiro
var _posicaoLida, _ultimoElemento : inteiro
inicio
se ultimoElemento = 0 entao
_ultimoElemento <- 1
senao
_ultimoElemento <- ultimoElemento
fimse
escreva("Digite uma posição entre 1 e ", _ultimoElemento, ": ")
leia(_posicaoLida)
enquanto (_posicaoLida < 1) ou (_posicaoLida > _ultimoElemento) faca
escreva("Digite uma posição entre 1 e ", _ultimoElemento, ": ")
leia(_posicaoLida)
fimenquanto
retorne _posicaoLida
fimfuncao

funcao lerValor : real

var _valorLido : real
inicio
escreva("Digite um valor: ")
leia(_valorLido)
retorne _valorLido
fimfuncao

var
vet : vetor[1..5] de real
i, qtdeElementos : inteiro
ultimoElemento : inteiro
valorPadrao : inteiro
opcao : inteiro
novaPosicao : inteiro
novoValor : real

6
inicio
valorPadrao <- -999999
inicializaLista
ImprimirMenu
leia(opcao)
enquanto opcao <> 8 faca
se opcao = 1 entao
limpatela
Listar
escreval
escreval
senao
se opcao = 2 entao
limpatela
se listaVazia entao
escreval("Lista Vazia")
senao
escreval("Lista com Elementos")
fimse
escreval
escreval
senao
se opcao = 3 entao
se nao listaCheia entao
limpatela
novaPosicao <- LerPosicaoValida
novoValor <- LerValor
insereNaPosicao(novoValor, novaPosicao)
escreval
escreval
senao
limpatela
escreval("Lista Cheia!")
escreval
escreval
fimse
senao

7
se opcao = 4 entao
se nao listaCheia entao
limpatela
novoValor <- LerValor
insere(novoValor)
escreval
escreval
senao
limpatela
escreval("Lista Cheia!")
escreval
escreval
fimse
senao
se opcao = 5 entao
se nao listaVazia entao
limpatela
novaPosicao <- LerPosicaoValida
retiraNaPosicao(novaPosicao)
escreval
escreval
senao
limpatela
escreval("Lista Vazia!")
escreval
escreval
fimse
senao
se opcao = 6 entao
limpatela
escreval("Qtde de elementos na lista: ",
qtdeElementos)
escreval
escreval
senao
se opcao = 7 entao
limpatela
escreval("Último elemento: ", ultimoElemento)
escreval
escreval
fimse
fimse
fimse

8
 fimse
fimse
fimse
fimse

imprimirMenu
leia(opcao)
fimenquanto
fimalgoritmo