ESCUELA SUPERIOR POLITÉCNICA DE CHIMBORAZO

SEMESTRE MARZO - JULIO 2019

TAREA No. 1

IDENTIFICACION
Facultad: Informática y Electrónica

Carrera: Software

Materia: Estructura de datos

Semestre: Tercero

Paralelo: B

Docente: Ing. Blanca Hidalgo

Integrantes: Ayrton Fidel Avalos Cuadrado (6616)

Fecha: 18/03/2019

Revisado
Calificación
TEMA: Tipos de datos abstractos (TDA).

1. OBJETIVO GENERAL
 Investigar sobre los tipos de datos abstractos (TDA), de tal manera que se
dominen los conceptos básicos sobre este tema.

2. OBJETIVOS ESPECÍFICOS
● Conocer sobre los tipos de datos abstractos.
● Identificar las ventajas y desventajas de los tipos de datos abstractos (TDA).
● Averiguar las características de los tipos de datos abstractos (TDA).
● Comprender los conceptos básicos que el tema nos proporcionara.
● Aplicar la información del marco teórico mediante ejercicios o problemas.

3. MARCO TEÓRICO

3.1 Tipos de datos abstractos

La abstracción permite ver una percepción como un todo, evitando la distracción en
los detalles, presentando una gran ventaja al momento de analizar y representar
los objetos que intervienen en un problema.

La abstracción de datos nos permite definir el dominio y la estructura de los datos,

el conjunto de propiedades de estos datos y las operaciones que son aplicadas en
los mismos. Es decir, es un proceso por medio del cual se define un concepto
general a partir de un conocimiento previo.

A partir de este concepto se da el origen de lo que se conoce como Tipo de datos

abstractos o Abstract Data Type (ADT), se define como un tipo de dato definido por
el usuario, formado por operaciones que especifican cómo un cliente puede
manipular los datos.

Es independiente de la implementación, lo cual permite al diseñador de la solución

enfocarse en el modelo de datos y en sus operaciones, sin necesidad de considerar
un lenguaje de programación.(Guardati, 2007)

Ejemplo 3.1.1:

Dominio: Tigre de Bengala blanco.

Datos o Atributos:
Nombre: Tigre de Bengala
Color: Blanco
Género: Macho
Peso: 190 kg
Reino: Animal
Edad: 5 años
Operaciones válidas para el ADT: Se representará a aquellas operaciones que
pueden realizarse con o sobre los datos del tigre de Bengala blanco:

 Actualizar Edad del Tigre de Bengala.

 Actualizar el Peso del Tigre de Bengala.
 Si existen mas de una especie de este tipo se puede hacer un ordenamiento
ascendente o descendente utilizando la edad o peso del animal.

Por lo general, todo TDA posee los siguientes elementos: Encabezado, descripción
de los datos y una lista de las operaciones válidas para este TDA.
 Encabezado: nombre del TDA.
 Descripción de los datos: se especifican los datos y las estructuras
correspondientes para representarlos. Los datos constituyen las
características o atributos del objeto definido por el TDA.
 Lista de operaciones: se forma por el grupo de operaciones que se definen
como válidas para el TDA. En cada operación se indicará:
Entrada: Proporcionada por el usuario.
Precondiciones: Se establece la situación en la cual se aplicará la
operación.
Proceso: es el conjunto de acciones que definen la operación.
Salida: valores proporcionados, luego de la operación, al usuario.
Postcondiciones: indica las reglas que deben cumplirse al ejecutar la
operación.

Cabe recalcar que, la mayoría de los TDAs tienen una operación espacial, llamada
inicializador, el cual asigna valores iniciales a los datos, al ser implementado en
un lenguaje de programación viene a ser llamado constructor al momento de
declarar un objeto. (Guardati, 2007)

Ejemplo 3.1.2:

Si consideramos el ejemplo 3.1.1, (el cual se trata sobre el tigre de Bengala), y lo

pasamos al formato ya mencionado, quedaría de la siguiente manera:

ADT Tigre de Bengala Blanco:

Datos:

Un Tigre de Bengala blanco es un animal carnívoro, tiene los ojos azules, la

nariz rosada y la piel de un blanco crema cubierta con rayas de color
chocolate. Mide aproximadamente tres metros de largo y pesa
aproximadamente entre 180 a 285 kg, el macho puede llegar a vivir entre
10 a 12 años y la hembra hasta los 16 años.

Operaciones:
 Operaciones:

Constructor:

Entrada: Cadena de caracteres que represente el nombre, genero, color,

clase alimenticia y números enteros que representen la edad, peso y altura
del animal.

Proceso: Asignar los valores a los atributos del animal.

Cazar:

Entrada: Ingresar la clase alimenticia del Tigre de Bengala

Precondiciones: El estado del animal, la necesidad de alimentarse para

calmar su hambre.

Proceso: Cazar al animal que se encuentre cerca de su perímetro, acecharlo

de manera sigilosa y astuta.

Salida: Una presa la cual devorar, es decir tener alimento.

Postcondiciones: El animal se encontrará satisfecho luego de haber cesado

su hambre.

FIN ADT Tigre de Bengala Blanco

3.2 Abstracción procedural

La abstracción procedural, vendría a ser la contraparte de la abstracción de datos

debido a que se refiere a la definición de funciones abstractas las cuales se
implementan de procedimientos que diferencian y separan el “que” hace la función
del “como” se lo hace. Mientras tanto la abstracción de datos, permite la
descripción de los objetos abstractos, obviando los detalles. (Arraiz, Pasarella, &
Zoltan, 2002)

3.3 Características de un TDA.

 Encapsulación de los datos, la información es guardada y protegida al

momento de la declaración e implementación de las operaciones en un TDA.
Se utiliza una interfase como único mecanismo de acceso a la estructura de
datos.
 Protección de los datos, para acceder a la información en un TDA se lo debe
hacer mediante operaciones (públicas o privadas), las cuales pueden ser
manipuladas por el usuario.
 Representa una abstracción, se seleccionan ciertos datos específicos que
interesan al mundo o al problema a resolver, ignorando lo demás.
 Deben poder compilarse por separado.
(Alonso, n.d.)
3.4 Ventajas de un TDA.

 Recogen mejor la semántica de los tipos. Al agrupar la representación junto a

las operaciones que definen su comportamiento, y forzar a utilizar el TDA a
través de estas operaciones se evitan errores en el manejo del tipo de datos.
 Favorece la extensibilidad del código. Posibilita modificar y mejorar la
implementación del TDA sin afectar a los demás módulos.
 Aumenta la facilidad de uso.
 Aumenta la legibilidad del código que se usa el TDA
 Produce código reutilizable.
 Favorece la ausencia de errores.
 Creación de algoritmos simplificados y más sencillos.

3.5 Desventajas de un TDA.

Los tipos de datos abstractos, al ser una manera eficiente de crear y ejecutar los
procesos para la resolución de problemas, no posee muchas desventajas, por lo que
se pudo deducir una:

 No se utiliza de forma óptima la memoria, hay que reservar espacio en

memoria para toda la estructura durante toda la ejecución.

4. APLICACIÓN PRÁCTICA

4.1.Realice un registro que contenga como datos la clave y el nombre de

una persona. Guardar los datos en un arreglo de dimensión 3.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_ELEMENTOS 3
#define TAMANO_NOMBRE 25

typedef struct{
int clave;
char nombre[TAMANO_NOMBRE];
}Persona;
typedef Persona TipoElemento;

typedef int posicion;

typedef struct{
TipoElemento elementos[MAX_ELEMENTOS];
posicion ult;
}Lista;

int Posicion;
Persona Alumno;
Persona Alumno2;
Persona Alumno3;
Lista MiLista;

void inicializador(){
Alumno.clave=100;
strcpy(Alumno.nombre,"Salva");
Alumno2.clave=200;
strcpy(Alumno2.nombre,"Salvato");
Alumno3.clave=300;
strcpy(Alumno3.nombre,"Salvatore");

MiLista.elementos[0]=Alumno;
MiLista.elementos[1]=Alumno2;
MiLista.elementos[2]=Alumno3;
}

void imprimeMiLista1(){
int i;
for(i=0;i<=MAX_ELEMENTOS-1;i++){
printf("Elementos[%d]:\n",i);
printf("clave=%d\n",MiLista.elementos[i].clave);
printf("nombre=%s\n",MiLista.elementos[i].nombre);
}
}

int main()
{
inicializador();
imprimeMiLista1();

return 0;
}

4.2 Ingresar varios conjuntos de números, y se pueda obtener la unión

y/o la intersección entre ellos.

#include <iostream>
#include <stdio.h>
#include <stdlib.h>

#define EXT1 20
#define EXT2 20

using namespace std;

class cElementos{

private:

int numConjuntos;
int numElementos[EXT1];
int elementos[EXT1];

public:

cElementos(){ setNumConjuntos(0); }
~cElementos(){ setNumConjuntos(0); }

void setNumConjuntos( int val ){ numConjuntos = val; }

void setNumElementos( int val, int i ){ numElementos[i] = val; }
void setElementos( int val, int i ){ elementos[i] = val; }

int getNumConjuntos(){ return numConjuntos; }

int getNumElementos( int i ){ return numElementos[i]; }
 int getElementos( int i ){ return elementos[i]; }

};

class cConjunto: public cElementos{

private:

cElementos conjunto[EXT1];

public:

void setConjunto( cElementos oAux1, int i ){ conjunto[i] = oAux1; }

cElementos getConjunto( int i ){ return conjunto[i]; }

};

main(){

system("color f1");

//DECLARACION DE VARIABLES

cConjunto oConj;

int auxCantCon;
int auxCantEle;
int opc;
 ///////////

//DECLARACION DE FUNCIONES

cElementos leerElementos(int j);

void menu();
void imprUnion( cElementos oAux1, int i );
int auxInter( cElementos oAux1, int i );
void imprInter( int vecAux[], int i, int acum);

/////////////////////

cout << endl << "INGRESE CUANTOS CONJUNTOS DESEA INGRESAR: ";
cin >> auxCantCon;

oConj.setNumConjuntos( auxCantCon );

for( int i = 0; ( i < oConj.getNumConjuntos() ); i++ ){

cout << endl << "Ingrese la cantidad de elementos para el conjunto [" <<
i+1 <<"]: ";
cin >> auxCantEle;

oConj.setNumElementos(auxCantEle, i);
}

system ("cls");

for( int i = 0; (i < oConj.getNumConjuntos()); i++ ){

cout << endl << "INGRESE UN ELEMENTO PARA EL CONJUNTO [" <<
i+1 << "]";

for( int j = 0 ; ( j < oConj.getNumElementos(i)); j++){

oConj.setConjunto( leerElementos(j), i );
}
}

do{

menu();
cin >> opc;

}while( opc > 2 || opc <= 0 );

int vecAux[EXT2];
int acum = 0;
int k=0;
int aux;

switch (opc){

case 1:

cout << endl << "UNION = {";

for( int i = 0; (i < oConj.getNumConjuntos()); i++ ){

for( int j = 0 ; ( j < oConj.getNumElementos(i)); j++){

imprUnion( oConj.getConjunto(i),j );
}
}

cout << "}";

break;

case 2:

cout << endl << "INTERSECCION = ";

for( int i = 0; (i < oConj.getNumConjuntos()); i++ ){

for( int j = 0 ; ( j < oConj.getNumElementos(i)); j++){

k++;

vecAux[k] = auxInter( oConj.getConjunto(i),j);

acum++;
}
}

for( int i = 1 ; i < acum+1 ; i++){

for( int j = i+1 ; j < acum+1 ; j++){

if(vecAux[j] < vecAux[i] ){

aux = vecAux[j];
vecAux[j] = vecAux[i];
vecAux[i] = aux;
}
}
 }

for( int i = 1 ; i < acum ; i++){

for( int j = i+1; j < acum+1 ; j++){

if(vecAux[i] == vecAux[j]){

for(int k = j ; k < acum ; k++){

swap(vecAux[k], vecAux[k+1]);
}

acum--;
j--;
}
}
}

cout << endl << "UNION: {";

for( int i = 1 ; i < acum+1 ; i++){

cout << vecAux[i] << ", ";

}
cout << "}";

break;

case 3:

break;

}
}

cElementos leerElementos(int i){

cElementos oAux1;

int elemento;

cout << endl << "Ingrese un elemento: ";

cin >> elemento;

oAux1.setElementos(elemento, i );

return oAux1;
}
void menu(){

cout << endl << "SELECCIONE UNA OPCION" << endl;

cout << endl << "<1> OPERACION UNION ";
cout << endl << "<2> OPERACION INTERSECCION";
cout << endl << "<3> SALIR";
cout << endl;
}

void imprUnion( cElementos oAux1,int i ){

cout << oAux1.getElementos(i) << ", ";

}

int auxInter( cElementos oAux1, int i ){

return oAux1.getElementos(i);
}

CONCLUSIONES

 Los tipos de datos abstractos son útiles y tienen muchas ventajas, una de las
mas importantes es aumentar el reciclaje de código y la disminución de
errores en un programa, así como la simplificación de la misma.
 En el trabajo de investigación la única desventaja hallada en los TDAs es el
no utilizar de forma óptima la memoria.
 Las estructuras de datos abstractos nos permiten vislumbrar un todo, es
decir nos permite definir el dominio y la estructura de los datos, el conjunto
de propiedades de estos datos y las operaciones que son aplicadas en los
mismos.
 En los ejercicios y ejemplos se puede observar que un tipo de estructura de
datos abstracta nos ayuda a ordenar los datos más específicos y relevantes
de un objeto, para luego poder realizar operaciones con o sobre los datos del
mismo.

RECOMENDACIONES

 Antes de empezar a realizar o resolver un problema es necesario definir los

datos y operaciones que se utilizaran mediante un cuadro, es decir el
encabezado, descripción de los datos y una lista de las operaciones válidas
para este TDA.
 Para poder tener un uso óptimo de la memoria en un programa que utilice
tipos de datos abstractos se deberá realizar una estructura dinámica.
 Para la realización de un TDA ya sean en su implementación o no, siempre
deberá contar con operación espacial, el constructor, debido a que ayuda a
crear el objeto y a inicializar las variables o atributos que componen a dicho
objeto.
BIBLIOGRAFÍA

Alonso, J. S. (n.d.). TEMA 1 ESTRUCTURAS DE DATOS TIPOS ABSTRACTOS DE

DATOS. Retrieved from
http://www6.uniovi.es/usr/cesar/Uned/EDA/Apuntes/ED1TEMA1.pdf
Arraiz, E., Pasarella, E., & Zoltan, C. (2002). Tipos Abstractos de Datos y
Algoritmos, (January).
Guardati, S. (2007). Estructura de datos orientada a objetos.