Nome: Laurindo Henriques João Moisés

Nº: 200130

Curso: Ensino da Informática

1- O que é um Tipo Abstrato de Dados (TAD) e qual a característica

fundamental na sua utilização?

R: Um tipo abstrato de dados (TAD) pode ser visto como um modelo matemático
que encapsula um modelo de dados e um conjunto de procedimentos que atuam
com exclusividade sobre os dados encapsulados. Em nível de abstração mais
baixo, associado à implementação, esses procedimentos são implementados por
subprogramas denominados operações, métodos ou serviços.

Característica essencial de TAD:

• A separação entre a definição conceitual par (v, o) e a implementação (ED

específica);
• O programa só acessa o TAD por meio de suas operações, a ED nunca é
acessada diretamente;
• Ocultamento de informação:
• Programador tem acesso a uma descrição dos valores e operações
admitidos pelo TAD;
• Programador não tem acesso à implementação
▪ Idealmente, a implementação é ´invisível´ e inacessível;
▪ Ex. pode criar uma lista de clientes e aplicar operações sobre ela,
mas não sabe como ela é representada internamente;
2- Quais as vantagens de se programar com TADs?
As vantagens de se programar com TADs são:
• Reuso: uma vez definido, implementado e testado, o TAD pode ser
acessado por diferentes programas;
• Manutenção: mudanças na implementação do TAD não afetam o código
fonte dos programas que o utilizam (decorrência do ocultamento de
informação);
▪ módulos do TAD são compilados separadamente;
 ▪ uma alteração força somente a recompilação do arquivo
envolvido e uma nova link-edição do programa que acessa o
TAD;
▪ O programa mesmo não precisa ser recompilado.
• Correção: TAD foi testado e funciona corretamente

3- Defina dado.
São os elementos básicos pertencentes a um conjunto determinado de
informações, ou seja, elemento que possui valor agregado e que pode ser utilizado
para solucionar problemas.
4- Defina estrutura.
Elemento estrutural que responsável por carregar as informações dentro de uma
estrutura de software, ou seja é uma coleção de campos que podem ser
referenciados pelo mesmo nome.
5- Defina Abstração.
É um código que define e implementa um novo tipo de informação ou um novo
tipo de objeto utilizado na linguagem de programação orientado a objeto.
Abstração: “é a habilidade de concentrar nos aspectos essenciais de um contexto
qualquer, ignorando características menos importantes ou acidentais.”
6- O que é a sintaxe de um TDA?
A sintaxe de um TAD é conhecida como um conjunto de assinaturas de operações
que especifica a sua interface
7- Explique o que são especificações algébricas de um TDA.
Especificação Algébrica: consiste na definição de um conjunto de equações que
interrelacionam as operações do TAD.
8- O que um predicado às operações algébricas de TDA?
são pré-condições, pós-condições e invariantes aplicadas às operações do TAD
que são representadas utilizando expressões lógicas.
9- Explique como implementar um TDA em C.
• Em linguagens estruturadas como C a implementação é feita pela definição
de tipos juntamente com a implementação de funções.
– Conceitos de C (typedef e structs).
• Para implementar um Tipo Abstrato de Dados em C, usa-se a definição de
tipos juntamente com a implementação de funções que agem sobre aquele
tipo.
 • Como boa prática de programação, evita-se acessar o dado diretamente,
fazendo o acesso somente através de das funções.
• Uma boa técnica de programação é implementar TADs em arquivos
separados do programa principal.
• Para isso geralmente separa-se a declaração e a implementação do TAD
em dois arquivos:
– nome_tad.hpp: com as declarações.
– nome_tad.cpp: com a implementação das declarações.
• Os programas, ou outros TADs, que utilizam o seu
TAD devem usar:
#include nome_arquivo.h
10- Dentro da motivações ao uso de TDA, explique : Reúso, Manutenção,
Corretude.
• Reúso: abstração de detalhes da implementação específica.
• Manutenção: mudanças na implementação do TAD não afetam o código
fonte dos programas que o utilizam (ocultamento de informação)
• Corretude: código testado em diferentes contextos.

11- Defina Struct().

Uma estrutura (struct) é uma coleção de campos que podem ser referenciados pelo
mesmo nome. A estrutura permite que informações relacionadas mantenham-se
juntas.

Implemente um TAD Matriz, número de linhas e de colunas e uma

coleção de elementos do tipo float. A TAD deve permitir as seguintes
operações:
– Criar Matriz: alocar dinamicamente uma matriz.
– Apagar Matriz: desalocar dinâmica de uma matriz.
– Adicionar Elemento: adição de um elemento a uma posição específica
da matriz.
– Ler Elemento: retornar o elemento pertencente a uma posição
específica da matriz.
– Imprimir: imprimir no Console todos os elementos de uma matriz.
13. Faça um pequeno programa para testar o seu TAD.
Criando aquivo matriz.h

typedef struct celula {

int valor;
int lin, col;
struct celula *prox;
struct celula *ant;

} t_celula;

globais t_celula *primeiro

t_celula *ultimo;

funções t_celula* criar_celula(int lin, int col, int valor);

void inserir(t_celula *novo);
void deletar(int lin, int col);
int vazia();
t_celula* existe_celula(int lin, int col);
void imprimir_elementos();
void imprimir_matriz();

t_celula* criar_celula(int lin, int col, int valor) {

t_celula * novo;
novo = (t_celula*)malloc(sizeof(t_celula));
if(!novo)
{
printf("Erro ao alocar memoria!!\n");
exit(1);
}
ant->prox = novo;
novo->prox = NULL;
novo->ant = ant;
ultimo = novo;
}
} else{
cel->valor = novo->valor; } }
deletar(int lin, int col) {
if(existe_celula(lin, col)) {
if(primeiro->lin == lin && primeiro->col == col){
t_celula *prox = primeiro->prox;
free(primeiro);
if(prox)
prox->ant = NULL;
primeiro = prox;
return; // sai da função }
t_celula *p = primeiro->prox;
while(p){
if(p->lin == lin && p->col == col) {
if(p->prox) {
p->ant->prox = p->prox;
p->prox->ant = p->ant;
} else{
p->ant->prox = NULL;
ultimo = p->ant; }
free(p);
return; }
p = p->prox;
}}}
int vazia() {
if(!ultimo
return 1;
return 0;
}
t_celula* existe_celula(int lin, int col) {
t_celula* p = primeiro;.
while(p{
if(lin == p->lin && col == p->col)
return p
p = p->prox; }
return NULL; }
void imprimir_elementos() {
t_celula* p = primeiro;
while(p
{
printf("(%d,%d)\n", p->lin, p->col);
p = p->prox; } }
void imprimir_matriz() {
if(!vazia())
int total_linhas = ultimo->lin;
int total_colunas = -1;
t_celula* p = primeiro;
while(p)
{
if(p->col > total_colunas)
total_colunas = p->col;
p = p->prox;
}
for(int i = 0; i < total_linhas; i++) {
for(int j = 0; j < total_colunas; j++) {
t_celula* cel = existe_celula(i + 1, j + 1);
if(cel)
printf("%d\t", cel->valor);
else
printf("X\t");
}
printf("\n"); } } else
printf("\nLista vazia!!\n");
}

Criando aquivo matriz.c

#include <stdio.h>
#include <stdlib.h>
#include “matriz.h”
#define MAX 10

int main(int argc, char * argv[]) {

t_celula *vet[MAX
vet[0] = criar_celula(2, 1, 10);
vet[1] = criar_celula(1, 2, 20);
vet[2] = criar_celula(10, 3, 30);
vet[3] = criar_celula(1, 1, 40);
vet[4] = criar_celula(3, 2, 50);
vet[5] = criar_celula(2, 8, 60);
vet[6] =criar_celula(3, 1, 70);
vet[7] = criar_celula(4, 2, 80);
vet[8] = criar_celula(3, 3, 90);
vet[9] = criar_celula(1, 6, 100);
if(vazia())
printf("\nLista vazia!!\n"); else
 printf("\nLista NAO vazia!!\n");
for(int i = 0; i < MAX; i++)
inserir(vet[i]);
if(vazia())
printf("\nLista vazia!!\n");
else printf("\nLista NAO vazia!!\n");
printf("\nImprimindo os elementos da lista:\n");
imprimir_elementos();
printf("\nImprimindo a matriz esparsa (X eh o elemento que se repete):\n");
imprimir_matriz
deletar(10, 3);
printf("\nImprimindo a matriz esparsa (X eh o elemento que se repete):\n");
imprimir_matriz(); // imprime a matriz
return 0; }
Arquivo matriz.c