TRABAJO PRÁCTICO SUSTITUTIVO

Asignatura: Computación II Código: 324

Fecha de devolución: A más tardar el 09/03/2022

Nombre del Estudiante: Aroldy Agüero

Cédula de Identidad: V- 15.934.557

Centro Local / Unidad de Apoyo: Nueva Esparta/ Sede

Correo electrónico: aroldydylana@gmail.com Teléfono: 0412-1118615

Carrera: TSU en Mantenimiento de Sistemas Informáticos (237)

Número de originales: 1

Lapso: 2022-1
 ESPECIFICACIONES DEL TRABAJO SUSTITUTIVO DE PRUEBAS

M: 1, U: 1, O: 1

C/D: 1/1

1. El Supervisor de una fábrica de pinturas consulta con su analista el número de

pedidos y verifican que son 5, pero no se percata de que tres de ellos han sido
anulados. Sabe que por cada pedido se gastan 50 Kg de colorante,
independientemente de la cantidad de unidades a fabricar y por ello encarga 250 Kg
de colorante erróneamente.

Cantidad(1)= 0

Cantidad(2)= 2750

Cantidad(3)= 0

Cantidad(4)= 0

Cantidad(5)= 2950

Basado en el caso presentado responda:

a) Explique y presente un ejemplo que represente el TAD apropiado a aplicar
en el caso presentado.
b) Indique 2 operaciones que se pueden realizar, con sus respectivos ejemplos
asociadas al TAD.

Respuesta: M: 1, U: 1, O: 1

Parte a. El problema planteado es el de controlar el número de pedidos y poder

conocer así la cantidad de colorante necesaria para la elaboración de pinturas. La estructura
de datos debe ser dinámica pues no conocemos de entrada su tamaño, crece o disminuye
según se hagan pedidos o se anulen. Un TAD apropiado a usar aquí sería una lista
enlazada. Un conjunto de niños dispuestos en fila de menor a mayor altura sería un ejemplo
de lista enlazada, cada uno seguiría al otro en la fila, cada elemento k tiene un anterior y un
sucesivo excepto el primero y el último. En nuestro caso el patrón de los elementos podría
ser un dato ordinal como la cantidad del pedido o bien un número de referencia relacionado
a la fecha de ingreso del pedido. Así nuestro TAD sería una lista a 1, a2, a3,…, an-1, an donde
cada ak sería un registro con dos campos: el dato, un array de dos enteros con el número
de referencia del pedido y la cantidad, y un apuntador al siguiente nodo (ak+1). Esto nos
permitiría conocer en todo momento la cantidad actual de pedidos, la cantidad de insumos
requerida y la cantidad a producir.

Parte B. Dos operaciones con este TAD son Ingresar y Eliminar un elemento.

Para Ingresar un elemento (nueva celda o nodo) debemos asignarle un espacio en la

memoria e insertarlo en la lista, la inserción puede ser realizada en una posición intermedia
de la lista, al inicio de la lista o al final.

Ej. Ingresar al inicio:

1) Se señala crea un nodo temporal e inicializar el campo dato al nuevo elemento.

2) Dirigir el apuntador temporal al elemento a1, cabeza de la lista..
3) Se “mueve” el apuntador cabeza del anterior a1 al nuevo elemento inicial.
Para Eliminar un elemento de la lista debemos asignar a su elemento anterior la
dirección apuntada por él y luego liberar la memoria que le fue asignada. De tal forma,
para eliminar al elemento k- ésimo:

1) Se asigna al apuntador del elemento anterior (ak-1) la dirección del apuntador de ak

con lo cual apuntaría a ak+1.
2) Se libera la memoria asignada a ak.
M: 1, U: 2, O: 2

C/D: 1/1

2. A continuación, se da una secuencia de números enteros como se muestra en la Tabla

N°1,

15
30
6
12
9
33
6
21
8
17
Tabla No.1

Realice lo siguiente:
a) Determine cuál es el tipo de lista más apropiada a la situación. Justifique su
respuesta.
b) Codifique en C++ la creación de la lista e implemente un procedimiento llamado
“insertinicio” que cree los valores al principio de la lista dada, y un procedimiento
llamado “reportlista” donde se muestren los resultados de los dos procedimientos.
Especifique las estructuras de datos en C++.

Respuesta: M: 1, U: 2, O: 2

Parte a. La situación es la de leer una secuencia de enteros de un archivo o el

teclado. El tipo de lista más apropiada a la situación es una lista enlazada de enteros, que
crece a medida que los insertamos en la posición inicial.
Parte b. La creación de una lista enlazada requiere, al menos, de dos clases: nodo y
lista. La lista enlazada se compone de celdas o nodos enlazados mediante
apuntadores, cada nodo declara sus dos partes: el dato o contenido y el apuntador,
también el constructor de la clase y la interfaz básica.

// Declaración de la clase nodo archivo de cabecera nodos.h

#include <iostream >
using namespace std;
typedef int tElem ;
class nodo
{
protected:
tElem dato;
nodo* sig;
public:
nodo() // constructor vacío, iniciación de nodo
{
sig = 0; // o NULL
}
nodo (tElem d) // constructor
{
dato = d;
sig = 0;
}
nodo(tElem d, nodo* n) // constructor
{
dato = d;
sig = n;
}
~nodo() {} // destructor por defecto
tElem datoNodo() const // obtener elemento
{
return dato;
}
nodo* sigNodo() const // obtener siguiente
{
return sig;
}
void aptSuc (nodo* suc) // poner siguiente
{
sig = suc;
};

La clase lista contiene el puntero de acceso a la lista enlazada, que apunta al nodo
cabeza; también se puede declarar un puntero al nodo cola. Las funciones de la clase
lista implementan las operaciones de una lista enlazada: inserción, búsqueda, etc. El
constructor inicializa primero a NULL, (lista vacía). Además, insertinicio()
construye iterativamente el primer elemento (primero) y los elementos sucesivos
de la lista enlazada, la función reportlista() recorre la lista y muestra los datos en
pantalla.
Creación de lista y procedimientos insertLista y reportLista

// archivo de cabecera listas.h

#include <iostream >
using namespace std;
typedef int dat;
#include "nodos.h"
class tListas //clase lista simplemente
enlazada
{
protected:
nodo* apt;
public:
tListas(); // constructor
~tListas(); // destructor
nodo* oApt(); // obtener el apuntador
void cApt( nodo* apt1); // colocar el apuntador
void insertInicio(); // inserta nodo al inicio
void reportLista(); // recorre la lista
// otras funciones miembro
};
tListas::tListas()
{
apt = 0; // o NULL
}
tListas::~tListas() {};
nodo* tListas::oApt()
{
return apt;
}
void tListas::cApt(nodo *apt1)
{
apt = apt1;
}
void tListas::insertInicio()
{
int x;
cout << "Insertar nodo. Termina con -1" << endl;
do
{
cout<< "Nuevo dato = ";
cin >> x;
if (x != -1)
{
apt = new nodo(x,apt);
}
}
while (x != -1);

void tListas::reportLista()
{
nodo* n;
int k = 0;
n = apt;
while (n != 0)
{
char c;
k++; c = (k%15 != 0 ? ' ' : '\n');
cout << n → datoNodo() << c;
 n = n → sigNodo();
}
}

Finalmente tenemos el programa con la función principal main() que va a a

implementar las funciones de las clases nodo y tListas.

// Lista_enlazada, implementación de insertInicio y reportLista

#include <iostream >
using namespace std;
typedef int dat;
#include "listas.h"

int main()
{
tElem d;
tListas lista; // crea lista vacía
lista.insertInicio();
cout << "\t Elementos de la lista introducidos" << endl;
lista.reportLista();
return 0;
}

M: 2, U: 3, O: 3

C/D: 1/1

3. Un profesor estableció un período de entrega de los trabajos prácticos de los

estudiantes, realizados en discos compactos (CD). Se sigue un orden estricto de entrega,
de tal manera que el primer trabajo que recibe, es el primero en calificar. El profesor
coloca los discos en una pila, con el efecto de que el primer CD entregado está de
último en la pila. Al recibir todos los discos, los distribuirá en dos pilas, una que
contendrá los discos de los alumnos que pertenecen a la sección ‘A’ y otra los de la
sección ‘B’.
Cada disco está rotulado con la cédula de identidad del estudiante y la sección a la cual
pertenece, ‘A’ o ‘B’.

Sobre la base de la situación planteada realice lo siguiente:

a) Determine la estructura de datos más apropiada para garantizar el estricto orden de

evaluación y la consecuente entrega de la calificación. Utilice variables dinámicas.
Justifique su respuesta.

b) Codifique en el lenguaje C++ una función que simule la operación Distribuir discos
compactos, en dos grupos, de manera que se puedan calificar respetando el orden de
 llegada, con respecto a cada sección. Previamente describa en C++ la estructura de
datos y las variables a emplear. Suponga que los datos de cada disco están correctos.

Respuesta: M: 2, U: 3, O: 3

Parte a. El TAD más adecuado para resolver el problema planteado es una cola, la
cual es un tipo especial de lista en la cual se insertan los datos en un extremo —al final o
fondo— de la lista y se suprimen en el otro —inicio o frente—, el recorrido se hace como
siempre desde a1 a an. Se conocen también como listas FIFO (first-in first-out) o «listas
primero en entrar primero en salir». En nuestro caso el primer trabajo que se recibe es el
primero a calificar.

El dato de las celdas o nodos de nuestro TAD serían fichas (struct) contentivas de la
cedula de identidad (un entero) y la sección «A» o «B» del alumno (un carácter). El
procedimiento debe resultar en dos colas, una por sección, construidas a partir de la cola
original y por tanto manteniendo el mismo orden de llegada.

Con la clase tCola se realizarán las siguientes operaciones:

1. AnularC(c). Convierte la cola ‘c’ en una lista vacía.

2. ObtInicio(c). Devuelve el valor del primer elemento (frente) de la cola ‘c’.
3. InsertaFin(d,c). Inserta el dato (struct) ‘d’ al final de la cola ‘c’.
4. ElimInicio(c). Suprime el elemento inicial de la cola ‘c’.
5. EstaVacia(c). Devuelve verdadero si la cola ‘c’ está vacía.
Nuestro programa lee los datos del teclado y los ordena en dos colas de acuerdo a su
sección.

Parte b. Función DistDCs

Creamos la clase ColaStd que contiene la clase nodo como interna, los nodos están
formados por registros por eso en el archivo de cabecera definimos el dato del nodo
(elemento) como una variable de tipo Alumno que es una estructura formada por un entero
largo sin signo para la cedula y un tipo enumerado para la sección. Esta clase contiene el
TAD a usar a implementar.

// Declaración de clase ColaStd archivo ColaStd.h

#include <iostream >
using namespace std;
struct TP
{
unsigned long cedula;
char seccion;
};
typedef TP elem;
class ColaStd
{
protected:
class nodo
{
public:
nodo* sig;
TP elem;
nodo (Alumno x)
{
elem = x;
sig = 0;
}
};
nodo* frente;
nodo* final;
public:
ColaStd()
{
frente = final = 0;
}
void AnularC();
~ColaStd()
{
AnularC();
}
void InsertaFin(T elem);
T ElimInicio();
T ObtInicio()const;
bool EstaVacia() const;
};

Finalmente desarrollamos nuestra implementación:

int main()

//crear tres colas vacías: colaTP, colaTP0(sección A),

colaTPb (sección B)

ColaStd colaTP, colaTPa, colaTPb;

TP t; // crea el elemento t tipo TP

char car;
do // leer los dos datos
{
cout << "\t Introduzca los datos del TP \n";
cout << "Cedula: \n";
cin >> tp.cedula;
cout << "\t Intruduzca la seccion ('A' o 'B'): ";
cin >> tp.seccion;
 colaTP.InsertaFin(t);
cout << "\t teclee 'S' o 's' para salir: ";
cin >> car;
}
while ((car != 's') and (car != 'S')) ;
// clasificar los TP por sección y ponerlos en colas A y B
while (!colaTP.EstaVacia()) //mientras la cola no esté vacía
{
tp= colaTP.ObtInicio();
if (tp.seccion == 'A' )
//inserta el dato al final de la cola de la sección A
colaTP0.InsertaFin(tp);
else
//inserta el dato al final de la cola de la sección B
colaTP1.InsertaFin(tp);
// quitar el elemento de la cola genérica
colaTP.ElimInicio();
}
endl;
return 0; //Fin
}

M: 2, U: 4, O: 4

C/D: 1/1

4. Sean dos árboles binarios de búsqueda, cuyos elementos son números enteros. Elabore
una función C++ que determine si un número dado está en ambos árboles. (Ver Figura
1)
Respuesta: M: 2, U: 4, O: 4

El procedimiento «repetido» usa la función booleana «esta_presente» para

chequear si el dato del nodo tiene el valor requerido, si es verdad pasa a chequear el otro
árbol siempre si encuentra el valor solicitado emite el mensaje afirmando la repetición en
caso contrario emite el mensaje negativo.

La función necesita de la existencia de las clases NodoArbol <T> y

ArbolBinStd<T>.

bool esta_presente (NodoArbol <T> *t, int num)

{
// utilizar descenso postorden
if (t != 0)
{
esta_presente (t -> Izdo(), num); // descenso izquierdo
esta_presente (t -> Dcho(), num); // descenso derecho
// verificar si el dato es igual al numero dado
// en caso afirmativo, return true
if (num == t -> datos)
return true;
else
return false;
endl;
}
// Función repetido
// la función utiliza recorrido postorden
template class <T>
void repetido(NodoArbol <T> *a, NodoArbol <T> *b )
{
int n;
bool esta_repetido= false;
cout << ("introduzca numero entero n= ");
cin >> n;
if esta_presente( a, n);
{
if esta_presente(b,n);
cout<<"\t El numero n= " << n
<< "esta en los dos arboles"<< endl;
else
cout<<"\t El numero n= " << n
<< "no esta en los dos arboles"<< endl;
}
else
cout <<"\t El numero n= " << n
<< "no esta en los dos arboles"<< endl;
endl;
}