Introducción a los conceptos fundamentales de las Estructuras de Datos

UNIDAD No. 01
Introducción a los conceptos fundamentales de las
Estructuras de Datos
Autor
Silverio Del Orbe Abad.
Santo Domingo, D.N.
22-05-2020
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
INDICE DEL CONTENIDO
INTRODUCCION DE LA UNIDAD ......................................................................................................................4
Introducción a los Conceptos Fundamentales de las Estructuras de Datos.......................................................5
1.1
Conceptos básicos y fundamentales. ...........................................................................................5
Software .....................................................................................................................................................5
Ingeniería de software Orientada a Objetos (OO)......................................................................................5
Algoritmos computacionales y crecimiento (Eficiencia). ...........................................................................8
1.2.- Definiciones de las Estructuras de Datos y su Clasificación. ................................................................12
Origen y problemáticas de estudio de las Estructuras de Datos. .............................................................13
Operaciones fundamentales ....................................................................................................................14
1.3.- Clasificación según el uso de memoria ................................................................................................15
Estructura de datos Estáticas: ..................................................................................................................15
Dinámicas: ................................................................................................................................................15
1.4.- Concepto de Tipo Abstracto de Datos (TAD).......................................................................................15
Una plantilla vista en C++, POO, se muestra a continuación....................................................................16
BIBLIOGRAFIA ...............................................................................................................................................18
Bibliografía Consultada: ........................................................................................................................18
Bibliografía Recomendada: ..................................................................................................................18
WEBGRAFÍA ..........................................................................................................................................18
3
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
INTRODUCCION DE LA UNIDAD
Las Estructuras de Datos, eje fundamental de todo Sistema de Información, permiten que los datos se
organicen, almacenen y manipulen con altos estándares de calidad. Por esto en esta unidad estudiaremos
conceptos, tipos, categorías y las operaciones que permitan su manipulación.
En esta unidad haremos un breve recuento de conceptos fundamentales de la programación orientada a
objetos (POO), metodología que permite representar la estructura de datos mediante tipos abstractos de
datos (TAD) de una forma sencilla y dinámica. La POO la cual abstrae objetos o elementos de la naturaleza
(Procesos, personas, acciones, cosas, etc.) con sus características y comportamientos; conectan, por
ejemplo, de manera ideal con las características de las Estructuras de Datos, sus modelos matemáticos o
restrictivos y las operaciones que le permiten manipular.
Las Estructuras de Datos, son conjuntos o colecciones organizados de datos, los cuales guardan reglas de
organización y control. Las mismas se clasifican según manejen las memorias en estáticas y dinámicas,
lineales o no lineales. En esta unidad veremos en detalle en qué consisten dichos tipos y su diferenciación.
Al cierre de esta unidad representaremos Estructuras de datos (TAD) mediante un lenguaje de
programación POO: Diagrama, Código y escenarios de unidad de prueba (unit testing).
4
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
Introducción a los Conceptos Fundamentales de las Estructuras de Datos
1.1 Conceptos básicos y fundamentales.
Software
Según la IEEE1 “software es la suma total de los programas
de ordenador, procedimientos, reglas, la documentación
asociada y los datos que pertenecen a un sistema de
cómputo" y "un producto de software es un producto
diseñado para un usuario”2. De ahí que las Estructuras de
Datos son piezas esenciales para construir software, conocer
sus características, como modelarlas y aplicarlas, es la
primera tarea para que dicho software funciones de manera
eficiente y con altos estándares de calidad.
Al construir software hay que hacer especial énfasis en la calidad y composición de las estructuras de datos.
Igual elegir un paradigma que permita su representación de forma dinámica y eficiente. La ingeniería de
software dedica gran parte de esfuerzo a la calidad de los datos a manipular.
Ingeniería de software Orientada a Objetos (OO).
La ingeniería de Software OO dirige todos los pasos de la
producción del software mediante el paradigma de la
orientación OO, en la cual debe determinar encapsular
objetos
mediantes Clases (Class), Atributos y sus
comportamientos. También determina como estas Clases
interacción con otras del contexto.
Recomendamos que instale un IDE
avanzado en POO y C++. Eclipse,
Netbean, Visual Studio, Etc..
Todos los ejemplos y prácticas de
este curso serán en C++.
En una vista más amplia, la ingeniería de software se
preocupa por metodologías incrementales las cuales abolieron el modelo secuencial histórico3. Dichas
metodologías incrementales hoy día se han solidificado y se fundamentan en métodos Agiles4, los cuales
integran desarrollo, seguimiento (SCRUM5), entrega continua y gestión de la calidad activamente (Unit
Test6). Para los propósitos de este curso nos enfocaremos exclusivamente en las conceptos y características
OO que nos permitan representar TAD.
11
https://www.ieee.org/
https://es.wikipedia.org/wiki/Software#cite_note-7
3
https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/el-modelo-en-cascada/
4
https://www.agilealliance.org/agile101/
5
https://www.scrum.org/resources/what-is-scrum
6
https://es.itpedia.nl/2018/11/21/test-driven-development-tdd-in-een-agile-omgeving/
2
5
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
Principales definiciones de la Orientación a objetos (OO)
1. El Objeto: es el eje o nombre que recibe la unidad mínima de la POO. Se conoce, desde el punto de
vista de la programación, como una instancia (variable) de clase (type) en memoria.
2. Una Clase (Classification/Groupping): Es el Código que se utiliza para representar los objetos en el
lenguaje. Se conoce como plantilla, que encapsula los datos con el código que lo transforma,
ocultando los elementos de información que no son necesario exponer públicamente.
 Está compuesta por método y propiedades (atributos o estado del objeto).
 Las mismas pueden ser concreta o abstracta. Las abstractas no permiten construcción y se
manifiestan mediante hijos.
 Las propiedades: son las características que definen el objeto (atributos) que lo identifican
y diferencian de cualquier otro objeto.
 Los Métodos, Son las funciones u operaciones que regulan el comportamiento el objeto.
Estos aceptan sobrecarga y dan gran estabilidad a su firma (lista de parámetros formales).
Pueden ser Constructores, de Acceso (Getters), de cambios o mutadores (Setters/mutators)
y de operación del objeto (cálculos/cómputos). Estos permiten la so
 En su cuerpo, las clases manejan una serie de modificadores, que hacen los elementos de
dicho código bien dinámicos y estructurales:
1. Modificadores de acceso: private, public, protected. Los cuales contralan el uso de
las variables y funciones, una vez las clases son instanciadas. Solo los public son de
libre acceso y los protected dentros de los hijos. private son exclusivo dentro de la
clase.
2. static se accede (consume) sin la necesidad de instancia y consumen memoria
desde inicio (desde que entran en un contexto).
3. Operadores de herencia o jerarquía e implementación de interface.
4. Delegados y eventos (manejo avanzado de punteros a funciones).
*** Las Clases, desde el punto de vista de la programación, son tipos de datos compuestos,
definido por el programador, que incorporan variables y funciones, los cuales actúan sobre una
misma naturaleza.
3. Abstracción: como analizar y descubrir objetos (sustantivos gramaticales) y pasarlos a un lenguaje
de computación.
4. Encapsulación: función de datos + Código. Provee ocultamiento de información mediante los
modificadores de Acceso.
5. Modularidad: división armónica de los elementos del programa.
6. Complejidad: La POO permite hacer representaciones (solucionar problema) complejas de una
forma simple, mantenible y con estándares de calidad.
7. Identidad: Cada objeto es propio y único. Posee características que lo diferencia de los demás
8. Notificación: Los objetos tienen varias formas de comunicarse. La normal mediante instancia y paso
de mensaje mediante los métodos. Así también existen forma avanzada de comunicación entre los
objetos mediantes eventos y manejo avanzado de delegados.
6
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
9. Operaciones/Method: son el eje algoritmo de la POO. Tienen tipo de retorno, nombre y firma que
acepta sobre-carga.
10. Polimorfismo: es la capacidad que tienen los objetos de adquirir múltiples formas o
comportamiento, mediante herencia y sobrecarga de funciones. Se escenifica a plenitud con las
clases abstractas e interfaces. Gran utilidad para estandarizar los hijos y en puntos estratégicos
representarlos como un padre. Los hijos especializan características del padre mediante la sobreescritura (override).
11. Sobre-Carga (function and Operator): permite que un mismo nombre de función reciba diferente
tipos de parámetros (en Datatype y cantidad). También un operador (mat o de relación) puede
actuar diferente en base al tipo de dato que recibe. Puede ser por Operador incluso.
12. Relación de Clase: Las Clases forman un ambiente natural de la problemática o área que
automatizan. Por ello se relacionan de varias formas:
 Como Padre e hijo: la cual se llama Herencia. También se conoce como jerarquía.
 Como Interface: Una clase adquiere de otra interface, lo cual le obliga tener todas las
características y métodos públicos, planteado por la interface padre.
 Asociación: una clase declara una o varias instancias de otra clase. La clase que declara se
llama cliente y la de referencia server.
 Composición: una clase declara propiedades públicas de otra clase.
13. Herencia o Generalización: Una clase adquiere todas las características de una clase Padre. La idea
es programar en varios niveles y pasar de un ambiente genérico a uno especializado (De lo General
a lo Particular). El término gramatical es-un, debe pronunciarse siempre en la relación: Camión esun Transporte, Triangulo es-un Figura-GEO.
14. Colector de basura: Dentro de los entornos modernos que gestionan los objetos en tiempo de
ejecución, se crea un colector de basura (Garbage Collector), el cual elimina todos los objetos en
desuso para optimizar el consumo de memoria (RAM).
7
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
Grafica 1.1 ilustración de un modelo OO geométrico
Este grafico muestra visión ampliada de un modelo geométrico. En la jerarquía todos los dependientes
(hijos) hablan el idioma (dialogo o interface): Lados, Áreas, Perímetro y tipo, características suficientes para
definir cualquier figura geométrica.
Algoritmos computacionales y crecimiento (Eficiencia).
Los algoritmos computacionales son una secuencia lógica de pasos que permiten solucionar un problema
mediante un computador.
Sus principales características son:
 Determina bien el objetivo u horizonte a seguir.
 Es secuencial y ordenado.
 Define la memoria necesaria para alcanzar el objetivo
a. De entrada o variables independientes.
b. De cómputo o solución del objetivos.
 Hace los movimientos lógico esperados:
a. Asignación de RAM.
b. Demanda de CPU matemática y lógica.
c. Posee la conjunción si (IF) y otras variaciones para la lógica (ALU).
d. Repite procesos de manera finitas (Iteraciones) para lograr el objetivo: for loop, while, do
while.
8
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos

Presenta los resultados o solución del problema.
Cuando enfocamos los algoritmos desde la perspectiva de las Estructuras de Datos, nos centramos en el
procesamiento de iterativos o funciones que se repiten un número determinado de veces. El gran rol de las
estructuras de datos es disponer algoritmos consistentes que manejen grandes volúmenes de datos, de
una manera eficiente y que utilicen la menor cantidad de memoria y CPU posible (sobre todo enfatizando
en optimizar el uso del CPU en los procesos iterativos).
El enfoque algorítmico, dentro del contexto de las estructuras de datos, busca construir algoritmos óptimos
para colocar las ocurrencias de datos en la colecciones y encontrar los métodos de acceso (búsqueda y
ordenamiento) más efectivos. Siempre se enfocan en bajar el tiempo de respuesta y que dichos algoritmos
sean capaces de manejar altos volúmenes de datos en memoria, consumiendo el tiempo mínimo para
realizar cualquieras de las operaciones elementales con estos (Alta, baja, búsquedas y ordenamiento). Se
dice que O(f(n)) define un "orden de complejidad". Escogeremos como representante de este orden a la
función f(n) más sencilla del mismo. Así tendremos:
 O(1): Orden constante
 O(log n): Orden logarítmico
 O(n): Orden lineal
 O(n log n) Orden lineal y logarítmico
 O(n^2): Orden cuadrático
 O(n^a): Orden polinomial (a > 2)
 O(a^n): Orden exponencial (a >= 2 ^ n > 1)
 O(n!): orden factorial
El enfoque matemático más apadrinado dentro de Estructura de datos, es el cambio de modelos
polinomiales (en cualquier grado) a modelos logaritmos. Recordar que si una función polinómica la puedo
cambiar a logarítmica, la misma mientras más grande sea la población o colección de datos, más eficiente
será (Log es una función inversa a la potenciación). En una próxima unidad (unidad 4) se detallara este
tema. Para cerrar:
 Un algoritmo se considera óptimo, cuando el mejor y peor escenario de ejecución tiende al menor
polinomio posible, para su ejecución en cuanto a consumo de CPU y alojamiento de memoria.
 Y su rendimiento no se degrada por el crecimiento de la población o colección de datos.
9
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
Tabla 1.1 Modelo de programación lineal y Estructurada (Caso punto en el plano o el espacio).
POL- Lineal o Secuencial
main()
{
float x,y,z;
cout<<"Entre Los Catectos:";
cout<<"C1="; cin>>x;
cout<<"C2="; cin>>y;
z=x*y;
cout<<"EL PRODUCTO ES:"<<z;
cout<<"EL AREA ES:"<<z/2.0;
}
POE- Orientada a Estructuras y Funciones
//-ESTRUCTURA DE DATOS
struct Punto{
float Abscisa; // X
float Ordenada; // Y
}
/*PROTOTIPO DE FUNCIONES O INTEFACES*/
float getProducto(Punto p_Point);
float getArea(Punto p_Point);
float getDistancia(Punto p_Point1,Punto p_Point2);
main(){
Punto unPoint; /*tipo definido por el programador*/
cout<<"Entre Los Catectos";
cout<<"C1="; cin>> unpoint.Abscisa;
cout<<"C2="; cin>>unpoint.Ordenada;
cout<<"EL PRODUCTO ES:";
cout<< getProducto(unpoint);
cout<<"EL AREA ES:";
cout<<getArea(unpoint);
}/* fin*/
/*implementacion DE FUNCIONES - Cuerpo*/
float getProducto(Punto p1){
return p1.Abscisa*p1.Ordenada;
}
float getArea(Punto p1){
return p1.Abscisa*p1.Ordenada/2.0;
}
float getDistancia(Punto p1, Punto p2){
/*formula de la hipotenusa para hallar la dist.*/
return sqrt(pow((p2.Abscisa - p1.Abscisa),2) + pow((p2.Ordenada p1.Ordenada),2));
}
10
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
Tabla 1.2 Modelo de Orientada a Objetos (POO) “Caso punto en el plano o el espacio”.
POO- Orientada a objetos
Class Consumidor o
Instancia
Class Interface
Class Implementación
//------ header file Punto.h
(1)
//======================
=========
#pragma once
class Punto{
private:
float AbscisaX;
float OrdenadaY;
float TerceraDim;
public:
Punto(void); Punto(float x,
float y, float z);
Punto(float x, float y );
Punto operator*(Punto B);
~Punto(void);
float getHipotenusa();
void MoverTo(float x, float
y);
void Mover(float xplus, float
yplus);
// GETTERS --float getX(); float getY();
float getZ();
};/*fin class interface*/
/* CONSTRUCTORS CPP—implement
Punto.cpp (2) */
#include "StdAfx.h"
#include "Punto.h"
// CONSTRUCTORS
Punto::Punto(void){ AbscisaX=0; OrdenadaY=0;
TerceraDim=0;}
//---> destroy
Punto::~Punto(void){}
Punto::Punto(float x, float y, float z){
AbscisaX=x; OrdenadaY=y; TerceraDim=z;
}
Punto::Punto(float x, float y ){
AbscisaX=x; OrdenadaY=y; TerceraDim=0;
}
// METHODS ....
float Punto::getHipotenusa(){
return
sqrt(pow(AbscisaX,2)+pow(OrdenadaY,2)+pow(Terc
eraDim,2));
}
void Punto::MoverTo(float x, float y){
AbscisaX = x; OrdenadaY = y;
}
void Punto::Mover(float xplus, float yplus){
AbscisaX+=xplus; OrdenadaY+=yplus;
}
Punto Punto::operator*(Punto B){
Punto C = Punto(getX()+B.getX(),
OrdenadaY+B.getY(),TerceraDim+B.getZ());
return C;
}
float Punto::getX(){ return AbscisaX;}
float Punto::getY(){+C11 return OrdenadaY;}
float Punto::getZ(){ return TerceraDim;}//--- Fin
//=================================
=====
//---- CONSUMO
/* oocpp.cpp: define el punto de entrada
de la aplicación de consola.
*/
static void main(){
Punto U;
float x,y; int intInput =0;
do{
cout<<"Entre X:";
cin>>x;
cout<<endl<<"Entre Y:";
cin>>y;
U = Punto(x,y); // consturctor
cout<<"Hipotenusa"<<U.getHipotenusa();
cout<<"Continue?[0=>No,1=>Si]";
cin>>intInput;
}while (intInput > 0);
return ;
}
11
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
1.2.- Definiciones de las Estructuras de Datos y su Clasificación.
Una estructura de datos es una forma de organizar un conjunto de datos elementales con el objetivo de
facilitar su manipulación. Un dato elemental es la mínima unidad que se tiene en un sistema.
Wikipedia narra, “En ciencias de la computación, una estructura de datos es una forma particular de
organizar datos en una computadora para que puedan ser utilizados de manera eficiente. Diferentes tipos
de estructuras de datos son adecuados para diferentes tipos de aplicaciones, y algunos son altamente
especializados para tareas específicas.7”
Datos
Datos: Proviene de atributos u oraciones gramaticales.
Cuando se abstrae en lenguaje de computación se
convierte en Campo, está compuesto por un vector de
factores (ID-RAM-HEX, VALUE, DataType, Length). En fin es
nuestro gran inicio de estructura de datos, donde el
compilador comprueba tipo en tiempo de compilación y
cuida en data-value en tiempo de ejecución run-time. De
este pasamos al concepto de records, los cuales son las
líneas que residen en los archivos o un conjunto de (https://sites.google.com/site/basededatosadsi/time-tracker)
atributos de un mismo tema o propósito.
Los Datos, son un el conjunto básico de hechos referentes a una persona, cosa o transacción. Incluyen cosas
como: tamaño, cantidad, descripción, volumen, tasa, nombre o lugar. (Murdick: pág 157).
Características de las Estructuras de Datos.
Están compuestas por campos, o la unidad que representa el dato. Tienen esquema de ordenamiento que
permite su fácil acceso y organización. Los atributos, son organizados comúnmente en registros, los cuales
a través del tiempo han sido estudiados para mejorar su correlación o enlace.
Operaciones Básicas
Una estructura de datos define la organización e interrelación de estos y un conjunto de
operaciones que se pueden realizar sobre ellos. Las operaciones básicas son:
 Alta, adicionar un nuevo valor a la estructura.
 Baja, borrar un valor de la estructura.
 Búsquedas, encontrar un determinado valor en la estructura y recuperarlo. La forma básica
de hacerlo es secuencial (de extrema deficiencia). Para mejorar este proceso se emplean
7
https://es.wikipedia.org/wiki/Estructura_de_datos
12
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
métodos matemáticos de aproximación o intervalos, siendo el binario o bisección el más
empleado y útil.
Otras operaciones que se pueden realizar son:


Ordenamiento, de los elementos colocados en la estructura de datos, con el estándar
UNICODE (ASCII) O el peso del alfabeto.
Apareo o relación, dadas dos estructuras generar una nueva ordenada y que contenga a las
relacionadas o partes de estas. Muy de la mano de la matemática de conjuntos (Unión,
diferencia, Intercepción, inyección, bisección, conjunto producto, producto natural, Etc. 8).
Origen y problemáticas de estudio de las Estructuras de Datos.
En computación, los primeros sistemas estables de almacenamiento eran los TAPE (Cintas Magnéticas9). De
ahí que acceder a los datos registrado en las mismas era obligatoriamente de forma secuencial y los
records eran alojados con longitud fija. Normalmente para recuperar dichos datos se tardaba mucho
tiempo y en muchos casos los mismo se corrían de lugar (solapaban). Ver este ejemplo:
Registro definido a nivel de programación en los 60s (Cobol o RPG): longitud fija.
id
name
fecha
actividad
categoría
~1-5
~6-25
~26-35
~36-50
~51-70
longitud = 70
caracteres
Posibles dados a almacenar (escenario):
Apolo
6563
05/06/1969 Lanzamiento
11
Creación del Primer sistema
657812 UNIX
16/16/1969
Operativo
Astronautas
Ciencia de la Computación
Análisis de longitudes
4
6
8
4
12
12
11
37
11
25
El primer record entra sin problema en el sistema, pero el segundo violenta varias reglas de tamaño. Esta
problemática provoco la búsqueda de alternativas para que los datos fuesen manipulados sin estas
inconsistencias. Este estudio se basó en los siguientes enunciados:

8
9
Los datos tienen que mantener su calidad e independencia, independiente del programa que acceda a
estos.
https://es.wikipedia.org/wiki/Operaciones_con_conjuntos
https://es.wikipedia.org/wiki/Cinta_magn%C3%A9tica
13
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos




La longitud y el tipo de datos debe estar garantizado en todo momento, durante su manipulación.
Inclusive ser extendido a la complejidad de campos tipos fecha.
Datos repetitivos deben ser almacenado de forma única y con el costo mínimo de almacén. No
redundancia de información.
Se deben crear índices binarios para acelerar la búsqueda.
Dependiendo de uso o aplicación de los datos, se deben crear modelos matemáticos para controlar su
acceso y efectividad.
Los objetivos fundamentales de las Estructuras de Datos son:
1. Identidad del dato (cada datos o record es único frente a sus iguales).
2. Garantizar la integridad de los datos (tipo, longitud y calidad).
3. Acceso con celeridad y consistencia.
4. La concurrencia y gestión de volúmenes.
5. La relación o apareo de los datos.
6. Aplicar modelos matemáticos a esto, dependiendo el campo de aplicación.
Operaciones fundamentales
 Altas: Permiten agregar un record o ocurrencia a la estructura de datos.
Normalmente al pie del arreglo (array). Ej. Sea E[n] el vector de los elementos, E[n-1]
Frutas
= altavalor; // altavalor=”granada”.
Mango
 Bajas: Elimina un elemento de la colección. Normalmente el ultimo. Debe
Guayaba
recomponer el array a la dimensión n-1. Ej: en este caso saldría “granada” y quedan
Aguacate
5 ocurrentes/frutas.
Coco de Agua
 Búsquedas: ubicar un elemento en la lista. Ej: “Coco de Agua” indica encontrado.
Lechoza
”Zapote” no encontrado.

Ordenamiento: Ubicar los elementos en orden entendible o útil para el propósito Granada
aplicado. Lo más común es el alfabético y el numérico. Pero hay algoritmos con otro grado de
inteligencia, que los colocan con oportunidad para dar la mejor respuesta (tipo arboles). Hay modelos
matemáticos cerrados, que impiden la búsqueda abierta como LIFO (Last In First Out) y FIFO (First In
First Out).
Frutas'Alfa
 Reacomodamiento de memoria: Cada vez que la estructuras sufre altas o bajas
orden
(cambios), debe redimensionarse la memoria RAM. Para que esto sea más óptimo,
se requiere de algoritmos basado en estructuras dinámicas y expandible (pasar de lo Aguacate
estático a lo dinámico y de lo dinámico lineal a lo dinámico no-lineal). Esta utilidad la Coco de Agua
obtendremos con los modelos OO y relaciones entre los objetos.
Granada
 Persistencia en disco: el proceso de las Estructuras de Datos es manejado de forma Guayaba
abstracta en la memoria (RAM) y una vez los procesos de altas o bajas son
Lechoza
comprobados en la misma, los mismos deben ser asentados en medios
Mango
permanentes. Todas las operaciones se hacen en RAM, pero es mandatorio que los
mismo sean persistente en el tiempo. Los motores de base datos (DBMS) vigilan y controlan que no se
llegue a los archivos por otras vías. Todas las peticiones se hacen vía el motor, para que este aplique
todos los esquemas de comprobación en memoria.
14
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
1.3.- Clasificación según el uso de memoria
Estructura de datos Estáticas:
Consumen la misma cantidad de RAM alocada
desde tiempo de compilación. En este grupo se
encuentran las variables primitivas, los arreglos con
longitud fija y los registros. Listamos las principales:
Tipos primitivos: enteros, flotantes, booleano,
String, records, Array (1 o n dimensiones).
https://cristinapalacios1309.jimdofree.com/estruct
uras-de-datos-2a-y-2b/
Dinámicas:
Se Alojan en tiempo de ejecución (run-time), la
memoria necesaria. También estas estructuras de
datos tienen un modelo matemático que le acompaña y regula la forma en que se organizaran y
manipularán los datos. Su soporte inicial son los arreglos dinámicos. De forma avanzada los arreglos son
gestionados mediante TAD y punteros de memoria, para mayor eficiencia. Para que una estructura
dinámica funcione debe estar encapsulada dentro de un tipo de datos abstracto (TAD). Citamos las
principales estructuras de datos dinámicas:
 Lineales: los elementos dispuestos uno a continuación del otro. Listas enlazadas, Pilas y Colas. Las listas
enlodadas se subdividen en 3 tipos: simple, doble y circulares. Así también las Colas tiene dos sub-tipos
principales: Cola y Cola de prioridad.
 No Lineales: la forma de colocación depende criterios algorítmicos o cercanía geografía u otras
relaciones. Dentro de estas las principales son Arboles binarios (aplicado a búsqueda) y grafos
(aplicado a transporte o geografía).
 Base de datos y archivos: Son los repositorios finales de los datos manipulados en memoria. En el caso
de un motor de base de datos (DBMS) tiene integrado las estructuras de datos y los algoritmos que
garanticen su integridad y calidad.
1.4.- Concepto de Tipo Abstracto de Datos (TAD).
Un TDA es un modelo matemático con una colección de operaciones definidas sobre el modelo” (Aho,
Hoperoft y Ullman. “Fundamental Structures of Computer Science”,1981).
“Una clase de objetos definida por una especificación independiente de la representación“ (Guttag
“Abstract Data Type and development of data structures “ ACM . Vol 20-6, 1977).
“Es un tipo de dato definido por el usuario a través de una especificación y una implementación de los
objetos abstractos”. (Rowe , “types” ACM sigplan, Vol 16-1, 1980).
15
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
Un TDA es un tipo de dato definido por el programador para representar una entidad (abstracción) a través
de sus características (datos o atributos) y sus operaciones o funciones (algoritmos que manipulan los
datos, Hilda Contreras).
En sentido práctico y de computación, un TAD es un es un tipo objeto,
encapsulado mediante una clase, el cual cumple con la interface TAD (-E*, Dim; +Alta(); +Baja(); +Buscar()). Cualquier TAD debe tomar esta forma:






*E: Es la cantidad de todos los elementos.
Dim: la cantidad de elementos colocados en el array.
Constructor vacío.
Alta(): Agregar un elemento a la estructura E.
Baja(): Retirar un elemento de la estructura E.
Buscar(): Localizar un elemento.
Una plantilla vista en C++, POO, se muestra a continuación. Caso práctico, para ir aplicando los
conceptos de tratados en esta unidad.
/*MS VC++ TAD.h*/
#pragma once
using namespace std;
class TAD{
private:
string *E;
int Dim; /*Cantidad*/
void copyData(string *acpy, int start,
public:
TAD();
~TAD();
void Alta(string x);
string Baja();
//overload 1 de baja
string TAD::Baja(int posicion);
string Buscar(string x);
};
/*IMPLEMENTACION. PREFERIBLE EN UN CPP TAD.cpp*/
#include "stdafx.h"
#include "TAD.h"
TAD::TAD(){
this->Dim = 0;
}
TAD::~TAD(){
delete E;
}
void TAD::Alta(string x){
// por cada alta hay que volver a resim el E
string *acopy = E;
Dim++;
int end, short int paralel);
16
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
this->E = new string[Dim];
copyData(acopy, 0,Dim-1, 0);
this->E[Dim - 1] = x; // nueva alta en posicion n-1
}
void TAD::copyData(string *acpy, int start, int end, short int paralel){
for (int k = start; k < Dim; k++)
this->E[k] = acpy[k+paralel];
}
string TAD::Baja(){
// por cada alta hay que volver a resim el E
string *acopy = E;
string bajado = acopy[Dim - 1]; // retira el ultimo
Dim--;
this->E = new string[Dim];
copyData(acopy, 0, Dim,0);
return bajado;
}
string TAD::Baja(int posicion){
// por cada alta hay que volver a resim el E
if (posicion < 0 || posicion > Dim - 1)
return NULL;
string *acopy = E;
string bajado = acopy[posicion];
Dim--;
this->E = new string[Dim];
copyData(acopy, 0, posicion, 0);
copyData(acopy, posicion+1, Dim+1, 1);
return bajado;
}
string TAD::Buscar(string delta){
// por cada alta hay que volver a resim el E
string buscado = NULL;
for (int k = 0; k < Dim; k++)
if (E[k] == delta)
buscado = E[k];
return buscado;
}
En el ejemplo anterior observamos una típica implementación de un TAD esta dar en C++. Cada vez que
hay un cambio en la estructura se debe recomponer el array E. Según progrese el curso, veremos técnica
para evitar tener que estar redimensionando el array continuamente.
17
Autor/a: Silverio Del Orbe Abad.
Unidad 01: Introducción a los conceptos fundamentales de la Estructura de Datos
BIBLIOGRAFIA
Bibliografía Consultada:
 Applied data structures with C++, Peter Smith, 2004.
 Weiss, M. A. (2000). Estructura de datos en JAVA.
 Joyánes, L. (2007). Estructura de datos en JAVA.
 Villa Z., D. A. & otros. (2008). Introducción a las Estructuras de datos en JAVA.
 Lewis, J. & Chase, J. (2006). Estructura de Datos con Java –Diseño de Estructuras y
Algoritmos.
Bibliografía Recomendada:
 Villa Z., D. A. & otros. (2008). Introducción a las Estructuras de datos en JAVA.
 Lewis, J. & Chase, J. (2006). Estructura de Datos con Java –Diseño de Estructuras y
Algoritmos.
 Applied data structures with C++, Peter Smith, 2004.
WEBGRAFÍA










https://www.educba.com/data-structures-and-algorithms/
https://es.wikipedia.org/wiki/Estructura_de_datos
https://es.wikipedia.org/wiki/Operaciones_con_conjuntos
https://es.wikipedia.org/wiki/Cinta_magn%C3%A9tica
https://www.ieee.org/
https://es.wikipedia.org/wiki/Software#cite_note-7
https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/el-modelo-en-cascada/
https://www.agilealliance.org/agile101/
https://www.scrum.org/resources/what-is-scrum
https://es.itpedia.nl/2018/11/21/test-driven-development-tdd-in-een-agile-omgeving/
18
Autor/a: Silverio Del Orbe Abad.