FACULTAD: Tecnología Informática

CARRERA: Analista Programador (a distancia)

ALUMNO/A: Luciano Joaquín Nieto
SEDE: LOCALIZACIÓN: Buenos Aires
ASIGNATURA: Programación I
COMISIÓN: 1-D-D TURNO:
PROFESOR: Garcia gustavo FECHA: 9-10-2023
TIEMPO DE EXAMEN PARCIAL 1 (uno)
RESOLUCIÓN: N°:
MODALIDAD DE RESOLUCIÓN: Virtual domiciliario

CALIFICACIÓN:
RESULTADOS DE APRENDIZAJE ESPERADO: Asegurar la comprensión de Circuitos
Lógicos
1) Una función recursiva es una función que se llama a sí misma en su propia definición.
Permitiéndonos resolver problemas mediante la división de un problema en casos más
pequeños y similares, aunque es importante definir casos base que detengan la recursión para
evitar que esta se ejecute infinitamente.

2) Enumerar los tipos de listas que existen son:

Listas enlazadas: Son estructuras de datos que constan de nodos, donde cada nodo contiene
un valor y una referencia al siguiente nodo. Las listas enlazadas pueden ser simples, dobles o
circulares, dependiendo de cómo se conecten los nodos.

Listas dinámicas: Son arreglos de tamaño dinámico que pueden cambiar su tamaño
automáticamente a medida que se agregan o eliminan elementos. Esto permite una gestión
más eficiente de la memoria en comparación con los arreglos estáticos.

Listas de vectores: Son listas implementadas utilizando arreglos (vectores) que pueden
redimensionarse cuando sea necesario.

Listas circulares: Son listas enlazadas en las que el último elemento apunta al primero, creando
un bucle. Pueden ser simples o dobles, según si los nodos tienen uno o dos enlaces.

Listas ligadas a registros: Son listas donde cada elemento contiene un registro o una estructura
de datos compleja en lugar de un solo valor. Son útiles para organizar y acceder a datos más
complejos.

Listas de prioridad: Son listas donde los elementos tienen una prioridad asignada y se
organizan de acuerdo con esta prioridad. Las operaciones principales suelen ser la inserción y
la eliminación del elemento con la mayor (o menor) prioridad.

3) Diferencia entre Pila y Cola:

Pila: Es una estructura de datos lineal en la que el último elemento que se agrega es el primero
en ser eliminado (LIFO, Last-In-First-Out). Las operaciones típicas en una pila son:

push: Agregar un elemento en la parte superior de la pila.

pop: Eliminar y obtener el elemento en la parte superior de la pila.

peek (o top): Obtener el elemento en la parte superior sin eliminarlo.

Las pilas se utilizan en situaciones donde se necesita un acceso rápido al elemento más
reciente, como en la gestión de llamadas de funciones en una pila de ejecución, por otro lado
las colas son:

Cola: Es una estructura de datos lineal en la que el primer elemento que se agrega es el
primero en ser eliminado (FIFO, First-In-First-Out). Las operaciones típicas en una cola son:

enqueue: Agregar un elemento al final de la cola.

dequeue: Eliminar y obtener el elemento en el frente de la cola.

Peek (o front): Obtener el elemento en el frente sin eliminarlo.

Las colas se utilizan en situaciones donde se necesita un manejo de elementos en el orden en

que se reciben, como por ejemplo una cola de supermercado donde el primero en llegar es el
primero en irse.
4. TDA significa Tipo de Dato Abstracto: Un TDA es una abstracción de una estructura de datos
que define una colección de valores y las operaciones que se pueden realizar en esa colección
sin revelar los detalles de su implementación. Es decir, un TDA describe lo que se puede hacer
con una estructura de datos y cómo hacerlo, pero no especifica cómo se implementa
internamente. Los TDAs son esenciales en la programación orientada a objetos y permiten
separar la interfaz de la implementación, lo que facilita el mantenimiento y la reutilización del
código. Ejemplos de TDAs incluyen listas, pilas, colas, árboles y grafos.
Practica: caja.cs:
using System;
using System.Windows.Forms;
using Caja_Supermercado.Clases;

namespace Caja_Supermercado
{
public partial class Caja : Form
{
Cola ColaClientes = new Cola();
double ImporteTotal = 0;
public Caja()
{
InitializeComponent();
}

private void BtnAgregarCliente_Click(object sender, EventArgs e)

{
if (TxtBoxNombre.Text.Length == 0 ||
string.IsNullOrWhiteSpace(importeapagar.Text))

{
MessageBox.Show("Debe completar correctamente todos los campos
antes de ingresar un cliente.");
}
else
{
Nodo UnNuevoNodo = new Nodo();
UnNuevoNodo.Nombre = TxtBoxNombre.Text;
UnNuevoNodo.Importe = Convert.ToDouble(importeapagar.Text);

ColaClientes.Enqueue(UnNuevoNodo);
MostrarCola();
}
}
private void MostrarCola()
{
LstBoxCola.Items.Clear();
MostrarNodoEnPantalla(ColaClientes.Inicio);
}
private void MostrarNodoEnPantalla(Nodo UnNuevoNodo)
{
if (UnNuevoNodo != null)
{
LstBoxCola.Items.Add("Nombre del cliente: " + UnNuevoNodo.Nombre
+ " " + "Importe: " + UnNuevoNodo.Importe);
if (UnNuevoNodo.Siguiente != null)
{
MostrarNodoEnPantalla(UnNuevoNodo.Siguiente);
}
}
}

private void BtnDesencolar_Click(object sender, EventArgs e)

{
if (ColaClientes.Vacia())
{
MessageBox.Show("No hay clientes en la fila");
}
else
{
 Nodo Auxiliar = new Nodo();
Auxiliar = ColaClientes.Inicio;
ImporteTotal = ImporteTotal + Auxiliar.Importe;
TxtBoxCobrado.Text = ImporteTotal.ToString();
LstBoxCobrados.Items.Add("Nombre del cliente: " + Auxiliar.Nombre
+ " " + "Importe: " + Auxiliar.Importe);
ColaClientes.Dequeue();
MostrarCola();
}
}
}
}

Nodo.cs:

namespace Caja_Supermercado.Clases
{
public class Nodo
{
public double Codigo { get; set; }
public string Nombre { get; set; }
public double Importe { get; set; }
public Nodo Siguiente { get; set; }
}
}

MDI.cs:
using System;
using System.Windows.Forms;

namespace Caja_Supermercado
{
public partial class MDI : Form
{
public MDI()
{
InitializeComponent();
}

private void cajaToolStripMenuItem_Click(object sender, EventArgs e)

{
Caja NewMdiChild = new Caja();
NewMdiChild.MdiParent = this;
NewMdiChild.Show();
}
}
}

Cola.cs:
namespace Caja_Supermercado.Clases
{
public class Cola
{
Nodo _Inicio;

public void Enqueue(Nodo UnNodo)

{
if (_Inicio == null)
{
 _Inicio = UnNodo;
}
else
{
Nodo Auxiliar = BuscarUltimo(_Inicio);
Auxiliar.Siguiente = UnNodo;
}
}
public void Dequeue()
{
_Inicio = _Inicio.Siguiente;
}
private Nodo BuscarUltimo(Nodo UnNodo)
{
if (UnNodo.Siguiente == null)
{
return UnNodo;
}
else
{
return BuscarUltimo(UnNodo.Siguiente);
}
}
public Nodo Inicio
{
get
{
return _Inicio;
}
}
public bool Vacia()
{
return (_Inicio == null);
}
}
}

Diseño: cara:

Para acceder a el interfaz de la caja hay que pulsar el apartado “Caja” justo en la parte superior
izquierda.
deseño de interfaz de caja:

Aclaracion: Nodo .cs y Cola.cs son clases creadas y Caja.cs y MDI.cs son los formularios