Programación II – Nivelación y Repaso de Programación I

Temario del curso de Programación 2:

Unidad 0: Nivelación y Repaso de Programación 1
• No es parte formal del programa, se propone a efectos de nivelar
conocimientos previos antes de continuar con los temas propios de
Programación 2.

Unidad 1: Teoría de Grafos

• Motivación (Aplicaciones en matemática y programación)
• Definición matemática de Grafos y conceptos fundamentales
• Representación de Grafos en lenguajes de programación
• Algoritmos sobre grafos

Unidad 2: Análisis de Algoritmos

• Concepto de Eficiencia de algoritmos en términos de tiempo de ejecución
• Eficiencia: análisis exacto versus análisis estimado
• Análisis estimado: Conceptos fundamentales y Noción de Orden de un
algoritmo.
• Análisis de algoritmos sobre estructuras de datos conocidas (arreglos,
listas, árboles, grafos)

Unidad 3: Estructuras de Datos Avanzadas

• Repaso de estructuras de datos conocidas (arreglos, listas, árboles)
• Nuevas variantes de Listas y árboles.
• Mapeo, Hash y MFSet.
• Combinación de distintas estructuras de datos para la resolución eficiente
de problemas

Unidad 4: Tipos Abstractos de Datos

• Motivación y Concepto de tipo abstracto de datos
• Categorización de tipos abstractos de datos
• Estudio de Tipos Abstractos de Datos elementales, intermedios y
colecciones de elementos.
• Metodología de análisis de tipos abstractos de datos para resolución de
problemas.
• Elección de estructuras de datos apropiadas para representación de tipos
abstractos de datos en un lenguaje de programación.

Página 1|6 CeRP del Suroeste – Programación II :: 2015

 Programación II – Nivelación y Repaso de Programación I

Unidad 0 - Nivelación y Repaso de Programación 1 (Parte 1)

En este capítulo se realiza una nivelación de conocimientos en relación a

diversos conceptos fundamentales del curso de Programación 1. Los temas
que aquí se repasen quizás resulten conocidos para muchos estudiantes, en
cuyo caso se debe tomar esta unidad como un repaso. Para otros estudiantes,
quizás algunos de los conceptos aquí tratados resulten nuevos, en cuyo caso
se debe tomar esta unidad como una nivelación de conocimientos. Se espera que
una vez completada, todos los estudiantes estén en equivalentes condiciones
para continuar con el estudio de los temas de Programación 2.

Algoritmo: Es un mecanismo para resolver, en un tiempo finito, un problema

que tiene solución. Todo algoritmo posee datos de entrada, un resultado o salida
y un método (proceso o conjunto de pasos que permiten transformar los datos
de entrada en el resultado o salida).

Ejemplo:

Entrada: Un conjunto no vacío de personas.

Salida: El promedio de edades de las personas
mayores de edad. Método: Para cada persona hacer
Si tiene más de 21 años
entonces
Sumar su edad y contar a la persona
Fin
Fin
Dividir la suma de edades entre el total de personas contadas

Los algoritmos utilizan estructuras de control, las cuales son mecanismos

que controlan el flujo de ejecución de un programa. Existen dos categorías de
estructuras de control.
• Estructuras de selección. (SI, EN CASO DE)
• Estructuras de iteración. (MIENTRAS, REPETIR, PARA CADA)

Las estructuras de selección permiten (como su nombre lo dice) seleccionar

entre dos o más rumbos posibles de ejecución, mientras que las estructuras
de iteración permiten ejecutar una misma secuencia de pasos múltiples
veces. Ante cada problema, el programador debe elegir aquellas estructuras
de control que resulten más adecuadas en función de la problemática que se
desee resolver con el algoritmo.

Programa: Es un conjunto de algoritmos escritos en una computadora, usando

un lenguaje de programación. Por ejemplo, el lenguaje C (lenguaje a utilizar en
el curso). El esqueleto básico de un programa en C es el siguiente:

NombrePrograma.cpp

Inclusión de librerías
Definición de constantes
Definición de tipos de datos
Procedimientos y/o funciones
Programa principal (main)

Página 2|6 CeRP del Suroeste – Programación II :: 2015

 Programación II – Nivelación y Repaso de Programación I

Ejemplo: Veamos el código fuente de un primer programa titulado “Ejemplo.cpp”

#include <stdio.h>
/* incluyo librería para operaciones de entrada y salida */

const int CANT = 5;

/* valor constante */

/* función que calcula el máximo entre dos enteros */

int Max (int a, int b)
{
int maximo;
if (a > b)
maximo = a;
else
maximo = b;
return maximo;
}

/* procedimiento que lee dos valores enteros desde teclado */

void Leer (int &a, int &b)
{
printf (“Ingrese dos valores enteros: ”);
scanf (“%d”, &a);
scanf (“%d”, &b);
}

/* programa principal */
int main()
{
/* declaro variables a usar en el programa */
int x, y, i, m;

/* leo CANT parejas de números y calculo el max en c/u */

for (i=0; i<=CANT; i++)
{
Leer(a,b); /* llamo al procedimiento que lee */
m = Max(a,b) /* llamo a la función que calcula el max */
printf (“\nEl valor maximo es: %d”,m);
}

return 0;
}

En este programa definimos una constante, una función, un

procedimiento y por último el programa principal (main). La función
devuelve un resultado en base a sus datos de entrada (llamados
parámetros), mientras que el procedimiento no devuelve ningún
resultado, sino que simplemente realiza un procesamiento.

Página 3|6 CeRP del Suroeste – Programación II :: 2015

 Programación II – Nivelación y Repaso de Programación I

Observación: Los procedimientos y las funciones también pueden ser

recursivos. Esto significa que tienen la propiedad de que pueden llamarse
(invocarse) a sí mismos. Por ejemplo, podemos definir una función recursiva
que calcule el factorial de un número natural. Veamos esto en el siguiente
fragmento de un programa en C:

typedef unsigned int nat;

/* defino el tipo de datos natural */

/* escribo la función que calcula el factorial de un natural n */

int Factorial (int n)
{
if (n == 0)
return 1; /* paso base de la función */
else
return (n * Factorial(n-1)); /* paso recursivo */
}

Esta función es recursiva porque en el paso recursivo se utiliza a sí misma. Este

proceso se repite tantas veces como sea necesario hasta llegar al paso base, el
cual devuelve un resultado en forma directa (sin tener que volver a llamar
recursivamente a la función). Por ejemplo, para el cálculo del Factorial del
número 4, el comportamiento de la función es el siguiente:

Factorial (4) = 4 * Factorial (3)

Como no conocemos aún el valor de Factorial (3), el programa vuelve a

usar la función para calcularlo. Se plantea entonces el siguiente cálculo:

Factorial (3) = 3 * Factorial (2)

El proceso se repite dos veces más hasta llegar a Factorial (0), cuyo resultado
es directamente 1.

Factorial (2) = 2 * Factorial (1)

Factorial (1) = 1 * Factorial (0)
Factorial (0) = 1

Recién en este punto es que el programa está en condiciones de retomar los

cálculos pendientes hasta llegar al resultado final. Así pues, el programa “vuelve
hacia el principio”, completando las multiplicaciones que fueron quedando
pendientes.

Factorial (1) = 1 * Factorial (0) = 1 * 1 = 1

Factorial (2) = 2 * Factorial (1) = 2 * 1 = 2
Factorial (3) = 3 * Factorial (2) = 3 * 2 = 6
Factorial (4) = 4 * Factorial (3) = 4 * 6 = 24,
siendo éste el resultado final.

Página 4|6 CeRP del Suroeste – Programación II :: 2015

 Programación II – Nivelación y Repaso de Programación I

Estructuras de Datos: Son mecanismos que proveen los lenguajes

de programación para almacenar datos en la memoria del computador
durante la ejecución del programa. Se clasifican en dos categorías:

• Estructuras estáticas: Aquellas en las que la cantidad de memoria

necesaria se determina en forma previa a ejecutarse el programa.
• Estructuras dinámicas: Aquellas en las que la cantidad de
memoria necesaria se determina durante la ejecución del
programa.

En este capítulo nos concentramos solamente en las estructuras de

datos estáticas. Existen múltiples estructuras posibles, de
momento veremos solamente las siguientes: arreglos,
estructurados y arreglos con tope.

Arreglos: Un arreglo es una secuencia de N valores, todos ellos del

mismo tipo, siendo N un valor constante que se define en forma previa
a la ejecución del programa. Veamos un ejemplo en lenguaje C, en el
que las posiciones se identifican mediante índices correlativos
empezando en 0. En este ejemplo los valores a almacenar en cada
posición (en cada celda) son de tipo int.

const int N = 50;

typedef int arreglo[N];
/* defino un tipo que representa un arreglo de N posiciones*/

/* escribo un procedimiento que carga los valores del arreglo */

void Cargar (arreglo arre)
{
int i;
for (i=0; i<N; i++)
{
printf(“Ingrese un valor para la posición i del arreglo:”);
scanf (“%d”,&arre[i]);
}
}

Estructurados: Un estructurado es un objeto que engloba una serie

de características que no necesariamente son del mismo tipo. Es como si
fuera un formulario en el cual hay que completar diferentes datos que no
tienen por qué ser todos del mismo tipo. Cada dato tiene un nombre que
lo identifica. Veamos un ejemplo en el que definimos una pareja forma
por un número entero y un real.

/* defino un tipo que representa una pareja de (int,float)*/

typedef struct { int entero;
float real;
} Pareja;

/* escribo un procedimiento que carga una pareja de valores */

void Cargar (Pareja &par)
{
printf(“Ingrese primero un entero y luego un real: ”);

Página 5|6 CeRP del Suroeste – Programación II :: 2015

 Programación II – Nivelación y Repaso de Programación I

scanf(“%d”,&par.entero);
scanf(“%d”,&par.real);
}

Arreglos con tope: Un arreglo con tope es como un arreglo común, pero con
la diferencia de que no estamos obligados a cargar todas las posiciones, sino
que vamos cargando los valores de a uno, teniendo un tope que nos indica
cuántos elementos llevamos cargados hasta el momento. Veamos un ejemplo en
lenguaje C.

/* defino un tipo que representa un arreglo con tope de enteros */

const int N = 30;
typedef struct { int arre[N];
int tope;
} ArregloConTope;

/* función que me dice si el arreglo ya se llenó */

boolean EstaLLeno (ArregloConTope act)
{
boolean lleno = false;
if (act.tope == N)
lleno = true;
return lleno;
}

/* procedimiento que inserta un valor en el arreglo con tope */

/* precondición: el arreglo no debe estar lleno */
void Insertar (ArregloConTope &act, int valor)
{
/* inserto el valor contra el tope y luego lo incremento, como
forma de indicar que ahora tengo un valor mas */
int posición = act.tope;
act.arreglo[posicion] = valor;
act.tope++;
}

Página 6|6 CeRP del Suroeste – Programación II :: 2015