PROYECTO MODULAR Estructura

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 12

PROYECTO MODULAR

NOMBRE DE INSTITUTO: CNCI

NOMBRE DEL ALUMNO: RUBI


VARGAS HERNANDEZ

NOMBRE DEL TUTOR: ROSARIO


RODRÍGUEZ

MATERIA: M7 ESTRUCTURAS DE DATOS FIN B

LUGAR Y FECHA: SANTO TOMAS ALLENDE,


25/JULIO/2022

Matricula: CTM075605

INTRODUCCIÓN
Los TDA que tienen informaciones simples pero dependientes de un comportamiento estructural
serán llamados políticos y aquellos TDA simples, como son los tipos predefinidos donde la
información no es relacionada mediante ninguna estructura y no admiten más que un valor en cada
momento será denominado TDA monolíticos.
Nótese que cuando hablemos de un TDA no haremos ninguna alusión al tipo de los elementos sino
tan solo a la forma en que están dispuestos estos elementos. Solo nos interesa la estructura que
soporta la información y sus operaciones. Para determinar el comportamiento estructural basta con
observar la conducta que seguirán los datos.
Caractericemos entonces los TDA. Un TDA tendrá una parte que será invisible al usuario la cual hay
que proteger y que se puede decir que es irrelevante para el uso del usuario y está constituida tanto
por la maquinaria algorítmica que implemente la semántica de las operaciones como por los datos
que sirvan de enlace entre los elementos del TDA, es decir, información interna necesaria para la
implementación que se esté haciendo para ese comportamiento del TDA. Resumiendo podemos
decir, que tanto la implementación de las operaciones como los elementos internos del TDA serán
privados al acceso externo y ocultos a cualquier otro nivel.
Un TDA representa una abstracción:

 Se destacan los detalles (normalmente pocos) de la especificación (el qué).


 Se ocultan los detalles (casi siempre numerosos) de la implementación (el cómo).
De modo general podemos decir que la abstracción permite establecer un nivel jerárquico en el
estudio de los fenómenos, el cual se establece por niveles sucesivos de detalles. Generalmente, se
sigue un sentido descendente de detalles, desde los niveles más generales a los niveles más
concretos.
Por ejemplo: los lenguajes de programación de alto nivel permiten al programador abstraerse del sin
fin de detalles de los lenguajes ensambladores. Otro ejemplo, la memoria de la computadora es una
estructura unidimensional formada por celdas y sin embargo trabajamos como si fuera única.
La abstracción nos brinda la posibilidad de ir definiendo una serie de refinamientos sucesivos a
nuestro TDA y entiéndase bien que cuando decimos refinamientos sucesivos nos estamos refiriendo
a la estrategia que se utiliza para descomponer un problema en subproblemas. Conforme evoluciona
el diseño de software a cada nivel de módulos se representa un refinamiento en el nivel de
abstracción. Esto es, incluir detalles que fueron obviados en un nivel superior, en un nivel más bajo
de la jerarquía.
Un TDA está caracterizado por un conjunto de operaciones (funciones) al cual se denomina
usualmente como interfaz pública y representa el comportamiento del TDA; mientras que
la implementación como la parte privada del TDA está oculta al programa cliente que lo usa. Todos
los lenguajes de alto nivel tienen predefinidos TDA; que son los tipos denominados simples y las
estructuras predefinidas, y estos tienen sus interfaces públicas que incluyen las operaciones como la
+, -, *, etc.

2) Elabora un díptico sobre el TDA de pila, donde investigues en dos fuentes confiables
definición, función, características y dos softwares que lo utilizan, deberás
realizarlo en CANVA. Teniendo el díptico deberás descargarlo como formato PNG y anexarlo
a Word.
DOS SOFTWARES QUE LO UTILIZAN

3) Tpila es una lista con la característica de solamente insertar y eliminar datos a través de
un solo extremo, con base a la semana 3 de tu curso realiza los siguientes incisos:
 A) Crea un programa de lenguaje C++ en donde declares una Tpila con el
nombre Tpila_colores en la que se puedan almacenar 10 elementos de tipo carácter
(char).
 B) Muestra cómo se vería el arreglo después de insertar los siguientes datos,
asegúrate de ubicar la variable tope:
 Morado
 Rojo
 Azul
 Verde 
 Amarillo
 Rosa 
 Blanco 
 Naranja 
 Negro
 Café 
cout <<"\nDesea agregar otro color(s/n):
";
cin>>rpt;
}while ((rpt == 's')||(rpt == 'S'));
cout<<"\nElementos de pila: ";
while (pila != NULL){
sacarPila(pila,dato);
if(pila != NULL) {
cout<<dato<<" , ";
}
else{
cout<<dato<<".";
}
}

getch();
return 0;
}
void agregarPila(Nodo *&pila,string n) {
Nodo *nuevo_nodo = new Nodo();
nuevo_nodo -> dato = n;
nuevo_nodo ->siguiente = pila;
pila = nuevo_nodo;
Conclusión
Una pila es una estructura de datos, caracterizada por ser una secuencia de elementos en la que las
operaciones de inserción y extracción se realizan por el mismo extremo. La pilas también se llaman
estructuras LIFO (del inglés Last In First Out), debido a que el último elemento en entrar será el
primero en salir.
Abstracción y tipos abstractos de datos
 La abstracción es un mecanismo para comprender problemas que involucran una gran
cantidad de detalles.
 Aspectos de la abstracción:
 Destacar los detalles relevantes.
 Ocultar los detalles irrelevantes.
 Un tipo abstracto de datos (TAD) es una colección de valores y operaciones* que se
definen mediante una especificación que es independiente de cualquier representación.
 Un TAD es una abstracción:
 Se destacan los detalles (normalmente pocos) de la especificación (el
qué).
 Se ocultan los detalles (normalmente numerosos) de la implementación
(el cómo).
 Analogía con las estructuras algebraicas.
Especificación del TAD de las pilas

Signatura del TAD pilas

Descripción informal de las pilas


 Una pila es una estructura de datos, caracterizada por ser una secuencia de elementos
en la que las operaciones de inserción y extracción se realizan por el mismo extremo.
 Las pilas también se llaman estructuras LIFO (del inglés Last In First Out), debido a que
el último elemento en entrar será el primero en salir.
 Analogía con las pilas de platos.
Signatura del TAD de las pilas
 Signatura:
vacia :: Pila a
apila :: a -> Pila a -> Pila a
cima :: Pila a -> a
desapila :: Pila a -> Pila a
esVacia :: Pila a -> Bool
 Descripción:
 vacia es la pila vacía.
 (apila x p) es la pila obtenida añadiendo x al principio de p.
 (cima p) es la cima de la pila p.
 (desapila p) es la pila obtenida suprimiendo la cima de p.
 (esVacia p) se verifica si p es la pila vacía.

Propiedades del TAD de las pilas

Propiedades de las pilas


 cima (apila x p) == x
 desapila (apila x p) == p
 esVacia vacia
 not (esVacia (apila x p))

Implementaciones del TAD de las pilas

Las pilas como tipos de datos algebraicos

 Cabecera del módulo:


module PilaConTipoDeDatoAlgebraico
(Pila,
vacia, -- Pila a
apila, -- a -> Pila a -> Pila a
cima, -- Pila a -> a
desapila, -- Pila a -> Pila a
esVacia -- Pila a -> Bool
) where
 Tipo de dato algebraico de las pilas.
data Pila a = Vacia | P a (Pila a)
deriving Eq
 Procedimiento de escritura de pilas.
instance (Show a) => Show (Pila a) where
showsPrec p Vacia cad = showChar '-' cad
showsPrec p (P x s) cad =
shows x (showChar '|' (shows s cad))
 Ejemplo de pila:
p1 :: Pila Int
p1 = apila 1 (apila 2 (apila 3 vacia))
ghci> p1
1|2|3|-
 vacia es la pila vacía. Por ejemplo,
ghci> vacia
-
vacia :: Pila a
vacia = Vacia
 (apila x p) es la pila obtenida añadiedo x encima de la pila p. Por ejemplo,
apila 4 p1 => 4|1|2|3|-
apila :: a -> Pila a -> Pila a
apila x p = P x p
 (cima p) es la cima de la pila p. Por ejemplo,
cima p1 == 1
cima :: Pila a -> a
cima Vacia = error "cima: pila vacia"
cima (P x _) = x
 (desapila p) es la pila obtenida suprimiendo la cima de la pila p. Por ejemplo,
desapila p1 => 2|3|-
desapila :: Pila a -> Pila a
desapila Vacia = error "desapila: pila vacia"
desapila (P _ p) = p
 (esVacia p) se verifica si p es la pila vacía. Por ejemplo,
esVacia p1 == False
esVacia vacia == True
esVacia :: Pila a -> Bool
esVacia Vacia = True
esVacia _ = False

Las pilas como listas

 Cabecera del módulo


module PilaConListas
(Pila,
vacia, -- Pila a
apila, -- a -> Pila a -> Pila a
cima, -- Pila a -> a
desapila, -- Pila a -> Pila a
esVacia -- Pila a -> Bool
) where
 Tipo de datos de las pilas:
newtype Pila a = P [a]
deriving Eq
 Procedimiento de escritura de pilas.
instance (Show a) => Show (Pila a) where
showsPrec p (P []) cad = showChar '-' cad
showsPrec p (P (x:xs)) cad
= shows x (showChar '|' (shows (P xs) cad))
 Ejemplo de pila: p1 es la pila obtenida anadiéndole los elementos 3, 2 y 1 a la pila
vacía. Por ejemplo,
ghci> p1
1|2|3|-
p1 = apila 1 (apila 2 (apila 3 vacia))
 vacia es la pila vacía. Por ejemplo,
ghci> vacia
-
vacia :: Pila a
vacia = P []
 (apila x p) es la pila obtenida añadiendo x encima de la pila p. Por ejemplo,
apila 4 p1 => 4|1|2|3|-|
apila :: a -> Pila a -> Pila a
apila x (P xs) = P (x:xs)
 (cima p) es la cima de la pila p. Por ejemplo,
cima p1 == 1
cima :: Pila a -> a
cima (P (x:_)) = x
cima (P []) = error "cima de la pila vacia"
 (desapila p) es la pila obtenida suprimiendo la cima de la pila p. Por ejemplo,
desapila p1 => 2|3|-
desapila :: Pila a -> Pila a
desapila (P []) = error "desapila la pila vacia"
desapila (P (_:xs)) = P xs
 (esVacia p) se verifica si p es la pila vacía. Por ejemplo,
esVacia p1 == False
esVacia vacia == True
esVacia :: Pila a -> Bool
esVacia (P xs) = null xs
Bibliografía
https://tda-i.com. (s.f.). Obtenido de software TDA: https://tda-i.com/software

https://www.cartagena99.com. (s.f.). Obtenido de Implementación y uso de TADs:


https://www.cartagena99.com/recursos/alumnos/apuntes/07_tads.pdf

https://www.desy.de. (s.f.). Obtenido de Tipos de Datos Abstractos:


https://www.desy.de/gna/html/cc/Tutorial/Spanish/node4.html

También podría gustarte