UNIVERSIDAD DE BUENOS AIRES

FACULTAD DE INGENIERIA
INGENIERIA EN SISTEMAS
LICENCIATURA EN ANLISIS DE SISTEMAS

(75.41 / 75.04)
ALGORITMOS Y PROGRAMACION II

Gua de estudio - Teora

UNIVERSIDAD DE BUENOS AIRES

CARRERA: INGENIERIA EN INFORMATICA
MATERIA: ALGORITMOS Y PROGRAMACION II
AO LECTIVO: 2001
CARGA HORARIA 8HS SEMANALES
DURACION CUATRIMESTRAL Lunes 18 a 22 hs- Martes 19 a 23 hs
DOCENTES A CARGO:
Prof. Titular Lic. Gustavo Carolo
Jefe TP: Lic. Marcela Castro Len
Ayudantes:
Lic. M. Gabriela Calabrese
Lic. Natalia Neiburg
Lic. Ruth Ghizzardi
Lic. Mariano Benitez
Lic. Fernando Sanz
FINALIDAD DE LA ASIGNATURA
El objetivo de la materia es capacitar al futuro profesional en el manejo de diferentes paradigmas de programacin, diseo
e implementacin de estructuras de datos, tcnicas de bsqueda y ordenamiento de datos.
OBJETIVOS GENERALES
Conocimientos de diferentes paradigmas de programacin
Diseo e implementacin de estructuras abstractas de datos
Conocer tcnicas de ordenamiento y bsqueda
MODALIDAD DE TRABAJO
La materia se dividir en una parte terica y una parte prctica. El anlisis y resolucin de las diferentes situaciones que se
planteen ser fundamental para la correcta comprensin de los diferentes temas. En clase se analizaran diferentes
problemas que permitirn aplicar los distintos temas estudiados.

PAUTAS GENERALES DE APROBACIN

Para la aprobacin de la asignatura, cada alumno deber:

Tener aprobada la materia correlativa- segn el programa de estudios vigente a la fecha que la ctedra y/o
facultad lo determine
Aprobar el parcial - en alguna de sus 3(tres) instancias y el examen integrador. Cada uno contendr una parte
terica y una parte practica. Los alumnos debern aprobar la parte terica y la parte practica para que el parcial o
el examen integrador se considere aprobado.
Aprobar los 2(dos) trabajos prcticos en fecha y forma segn lo disponga la ctedra.

CONTENIDO
UNIDAD 1: PARADIGMA DE PROGRAMACION: ABSTRACCION
Nocin de tipos de datos abstractos. Encapsulamiento. Niveles de abstraccin. Concepto de Primitivas. Pre y Post
Condiciones. Implementaron de tipos de datos en Pascal: Array, Records, Punteros, Archivos. Funciones y
Procedimientos. Compiladores. Almacenamiento
Bibliografa:
"Pascal para Estudiantes" - Coleccin Ciencia Informtica (Biblioteca FIUBA)
"Data Structures with abstract data types and Pascal" D. Stubbs. Brooks/Cole
"Estructuras de Datos. Algoritmos, Abstraccin, Objetos" J Aguilar. Mc Graw Hill
"Diseo de Compiladores" Aho Hopcroft. Ullman- Cap. 1
UNIDAD 2: ESTRUCTURAS DE DATOS Y TIPO DE DATOS
Diseo e implementaron de estructuras de datos. Cursores. Conocimiento de estructuras dinmicas. Listas . Pilas. Colas.
Arboles. B-tree, AVL. Grafos. Implementacin con punteros y con arreglos. Recursividad. Concepto de prioridad.
Bibliografa:
"Estructuras de datos y Diseo de Programas" R. Kruse. Printice Hall
"Estructuras de datos en C" D. Tenenbaun. Printice Hall
"Estructuras de Datos y Pascal" N. Dale- S. Lilly. Mc Graw Hill
"Data Structures with abstract data types and Pascal" D. Stubbs. Brooks/Cole
"Estructuras de Datos. Algoritmos, Abstraccion, Objetos" J Aguilar. Mc Graw Hill

UNIDAD 3: ORDENAMIENTO Y BUSQUEDA

Tcnicas de Sort interno y externo. Sort por seleccin, insercin,. Quicksort, Mergesort, Radix sort. Ordenamiento y
bsqueda aplicada a estructuras abstractas.
Bibliografa:
"Data Structures with abstract data types and Pascal" D. Stubbs. Brooks/Cole
"Estructuras de Datos y Pascal" N. Dale- S. Lilly. Mc Graw Hill
"Data Structures" Nyhoff.
UNIDAD 4: PARADIGMA DE PROGRAMACION: OBJETOS
Objetos y herencia. Mtodos y encapsulamiento. Mtodos virtuales y polimorfismo. Objetos dinmicos.
Bibliografa:
"Estructuras de Datos. Algoritmos, Abstraccin, Objetos" J Aguilar. Mc Graw Hill
"El C++ Lenguaje de Programacin". Bjarne Stroustrup. Addison Wesley

ii

INDICE
COMPILADORES............................................................................................................................................................................................................................ 1
TIPOS DE DATOS ........................................................................................................................................................................................................................... 2
ARCHIVOS ....................................................................................................................................................................................................................................... 3
RECURSIVIDAD ............................................................................................................................................................................................................................. 5
PUNTEROS....................................................................................................................................................................................................................................... 6
EJERCITACIN - SOLUCIONES ................................................................................................................................................................................................ 8
SORT INTERNO ............................................................................................................................................................................................................................ 13
SORT EXTERNO ........................................................................................................................................................................................................................... 18
MERGE............................................................................................................................................................................................................................................ 21
RBOLES B-TREE........................................................................................................................................................................................................................ 25
EJERCITACIN - SOLUCIONES .............................................................................................................................................................................................. 28
EJERCITACIN ADICIONAL .................................................................................................................................................................................................... 30
PROGRAMACIN ORIENTADA A OBJETOS ....................................................................................................................................................................... 32
EJERCITACION ............................................................................................................................................................................................................................ 36
CASO RESUELTO ......................................................................................................................................................................................................................... 36

iii

A L G O R I T M O S

P R O G R A M A C I N

I I

Captulo 1

T E O R I A

COMPILADORES

Un entorno de programacin es un programa que contiene,

adems del compilador (lenguaje de programacin), utilidades y
Entorno de programacin
herramientas. Estos elementos estn integrados, de modo que
pueden llamarse fcilmente a cualquiera de los mdulos, durante
el proceso de programacin, desde cualquier otro. Un entorno de programacin tpico contiene:
Un editor, que proporciona el medio de introducir el texto y smbolos para crear el
cdigo fuente.
Un intrprete o un compilador, que convierte el cdigo fuente en instrucciones que la
computadora puede comprender y ejecutar.
Un verificador de errores en tiempo de ejecucin, que reconoce todas los errores no
detectados anteriormente en tiempo de compilacin.
Un depurador, que ayuda a analizar y corregir errores de sintaxis, estructura o lgicos.
Una utilidad de referencias cruzadas, que crea tablas de variables, nmeros de lnea u
otros smbolos.
El proceso de diseo, codificacin, depuracin y ejecucin de un programa es mucho ms fcil
y rpido cuando se utiliza un buen entorno de programacin.

El Entorno Integrado de Desarrollo (IDE, Integrated

Development Environment) es un entorno de programacin que
El entorno integrado de desarrollo (EID)
proporciona todas las herramientas que se necesitan para
desarrollar programas de aplicacin, con xito, en Pascal. El
entorno EID posee un conjunto importante de herramientas:
Un editor con caractersticas propias de tratamiento de textos tales como "buscar y
reemplazar" o "pegar y cortar".
Un sistema de gestin (administracin) de archivos ficheros, que le facilita la
grabacin y recuperacin de sus archivos fuente.
Un compilador, que produce programas EXE autnomos que se pueden ejecutar
directamente desde DOS.
Un sistema de ayuda de referencias cruzadas, que proporciona informacin sobre el
lenguaje y el entorno.

La estructura de un programa en pascal

program identificador
uses identificadores
label lista de etiquetas

( cabecera del programa)

const
definiciones de constantes
type
declaracin de tipos de datos definidos por el usuario
var
declaracin de variables
procedure
definiciones de procedimientos
function

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

definiciones de funciones
begin
(cuerpo del programa)
sentencias
end.
Las cinco secciones de declaracin -label, const, type, var y procedure y/o function-, as como
la clusula uses, no tienen que existir en todos los programas. Sin embargo, Turbo Pascal
presenta flexibilidad a la hora de escribirlas -se puede hacer en cualquier orden-, mientras que
Pascal estndar (ISO Pascal) requiere la escritura en el orden de la Figura 3.1 (con la excepcin
de uses que no existe en ISO Pascal). Las secciones de declaraciones estn seguidas por el
cuerpo del programa o programa principal que siempre existir y que constar de un nmero
determinado de sentencias. No obstante, y pese a la facilidad de Turbo Pascal de permitirle
mezclar en cualquier orden las declaraciones, le recomendaremos seguir siempre el orden
establecido, le evitan en el futuro numerosos problemas.

TIPOS DE DATOS
Todos los datos tienen un tipo asociado a ellos, lo cual permite trabajar con los datos. Si el compilador
no conoce el tipo de datos asociado a un dato, es decir si es entero o real, carcter o bolean, no podr
ejecutar correctamente las operaciones realizadas al dato. La asignacin de tipos a los datos tiene dos
objetivos principales: detectar errores de operaciones en programas y determinar como ejecutar las
operaciones. Pascal se conoce como lenguaje fuertemente tipificado que significa que los datos
utilizados deben tener sus tipos declarados explcitamente y el lenguaje limita la mezcla de tipos en
las expresiones. Pascal detecta muchos errores de programacin antes que el programa se ejecute. El
tipo de dato determina la naturaleza del conjunto de valores que puede tomar una variable y el espacio
de memoria ocupado por una variable del tipo dado.
Clasificacin

Datos estticos
o

Tipos simples: byte, integer, longint, shortint, word, real, char, boolean, definidos
por el usuario (enumerado, subrango) .

Tipos estructurados: arrays, registro, conjunto, archivos.

Datos dinmicos
o

Tipos puntero.

Estructuras de Control
Selectivas:
Repetitivas

Sentencia if
Sentencia case

Sentencia while
Sentencia repeat
Sentencia for

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 2
ARCHIVOS
Tipo : FILE
Componentes
Los componentes de un FILE son todos del mismo tipo. Como un ARRAY, un FILE es una
estructura homognea de datos almacenados en memoria secundaria. A diferencia de un
ARRAY, el tamao de un FILE es variable del modo que puede cambiar durante la ejecucin
de un programa y la existencia de un FILE puede ser independiente de cualquier programa.
Los componentes de un FILE pueden ser de cualquier tipo excepto File o un tipo estructurado
que contenga el tipo File. Pascal automticamente reserva un buffer por cada declaracin del
tipo File. Un programa no sabe con exactitud el lugar donde residirn los datos, es decir donde
residir el archivo fsico. El programa enva y recibe informacin desde y hacia el archivo,
apoyndose en el Sistema Operativo. El programa referencia indirectamente al archivo fsico
utilizando para ello un nombre lgico que denominamos archivo lgico
Estructura
Los componentes de un FILE tienen una estructura linear y pueden ser accedidos
secuencialmente (un registro y luego otro) y de forma directa. (se accede a un registro sin
necesidad de acceder a su predecesor)
Declaracin
Type
tipo_de_datos =
archivo = file of tipo_de_datos;
Var
arch : archivo
Operaciones
1. Vincular el archivo fsico (que est en memoria secundaria) con el nombre lgico que se
utilizar dentro del algoritmo.
PROCEDURE ASSIGN (var F : FILE; FF: STRING);
Asigna el nombre de un archivo externo(fsico) FF a una variable F del tipo file(lgico)
2. Apertura y creacin de un archivo para su procesamiento
PROCEDURE RESET (VAR F: FILE);
Abre un archivo existente para lectura y escritura
PROCEDURE REWRITE (VAR F: FILE);
Crea y Abre un nuevo archivo slo para escritura
PROCEDURE APPEND(VAR F: TEXT);
Abre un archivo de texto para escritura
3. Cerrar un archivo luego de operar con el mismo
PROCEDURE CLOSE (VAR F: FILE);
Cierra el archivo F y coloca la marca que indica su finalizacin.
4. Leer los elementos contenidos en un archivo
PROCEDURE READ (F: FILE; V1[,V2,...,VN] );
Lee de un archivo f las variables v1 hasta vn
PROCEDURE READLN (F: TEXT; V1[,V2,...,VN] );
Ejecuta el procedimiento read hasta la marca de fin de lnea

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

5. Escribir nuevos elementos en un archivo o modificar algunos existentes

PROCEDURE WRITE (VAR F: FILE; V1[,V2,...,VN] );
Escribe en un archivo f las variables v1 hasta vn
PROCEDURE WRITELN(VAR F: FILE; V1[,V2,...,VN] );
Ejecuta el procedimiento write hasta la marca de fin de lnea
6. Operaciones adicionales
PROCEDURE RENAME(VAR F: FILE; NOMBRE: STRING);
Renombra un archivo externo con el nombre pasado como parmetro
PROCEDURE ERASE (VAR F: FILE);
Borra fsicamente un archivo externo
FUNCTION FILEPOS (VAR F: FILE): LONGINT;
Retorna la posicin corriente de un archivo (Nro. de registro)
FUNCTION FILESIZE (VAR F: FILE) : LONGINT;
Retorna el tamao (en registros) de un archivo
PROCEDURE TRUNCATE (VAR F: FILE);
Trunca el tamao(cantidad de registros) de un archivo a la posicin corriente. A partir de esa
posicin hasta el fin de archivo lo borra
PROCEDURE SEEK (VAR F: FILE; n: LONGINT);
Mueve la posicin corriente de un archivo a la especificada
FUNCTION EOF ( F: FILE) : BOOLEAN;
Retorna verdadero si la posicin corriente dentro del archivo referencia a la marca de fin, falso
en caso contrario.

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 3

RECURSIVIDAD
Un subprograma (procedimiento o funcin) recursivo es aquel que se llama as mismo. En
Pascal los procedimientos y las funciones pueden ser definidos de modo recursivo. La
recursividad es una alternativa a la iteracin o repeticin. y aunque en tiempo de computadora y
en ocupacin en memoria es la solucin recursiva menos eficiente que la solucin iterativa,
existen numerosas situaciones en las que la recursividad es una solucin simple y natural a un
problema que en caso contrario ser difcil de resolver. Por esta razn se puede decir que la
recursividad es una herramienta potente y til en la resolucin de problemas que tengan
naturaleza recursiva y, por ende, en la programacin.
Existen numerosas definiciones de recursividad, algunas de las ms importantes o sencillas son
stas:
Un objeto es recursivo si figura en su propia definicin.
Una definicin recursiva es aquella en la que el objeto que se define forma parte de la
definicin (recuerde la regla gramatical: lo definido nunca debe formar parte de la definicin)
La caracterstica importante de la recursividad es que siempre existe un medio de salir de la
definicin, mediante la cual se termina el proceso recursivo. En Pascal los procedimientos y
funciones pueden ser definidos de modo recursivo, es decir, pueden llamarse a si mismos.
Un ejemplo sencillo es la definicin de factorial n!
N! = { 1 si n = 0 ; n*(n-1)*(n-2)* ... * 1 si n > 0 }
Para el caso de n= 5
5! = 5*(5-1)*(5-2)*(5-3)*(5-4)*(5-5)= 5*4*3*2*1 = 120
o tambin puede expresarse como
5! = 5 *4!
Generalizando
N! = { 1 si n=0 ; n*(n-1)! Si n > 0 }
As podemos establecer
condicin de salida como n=0
la parte recursiva como n! = n*(n-1)!
function factorial (n : integer) : integer
pre: n est definida y n>=0
post: factorial (n) = n!
begin
if (n= 0 ) then factorial :=1
else factorial := n * factorial (n-1);
end;

Tipos de recursividad

Directa o simple: un subprograma se llama a si mismo una o

mas veces directamente.
Indirecta o mutua: un subprograma A llama a otro
subprograma B y ste a su vez llama al subprograma A.

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 4

PUNTEROS
Todas las variables y estructuras de datos pueden clasificarse en
estticas y dinmicas. Con una variable esttica la cantidad de
memoria ocupada debe ser declarado por anticipado y no puede
ser incrementado durante la ejecucin del programa si se necesitara ms espacio de memoria.
Un array de requisitos es esttico dado que la cantidad exacta de memoria se fija por la
declaracin del tamao del array. Esta falta de flexibilidad puede ser una desventaja notable.
As, por ejemplo, si en un array de registros se declara para un tamao mximo de 1.000
registros, el programa no funcionar si se deben almacenar ms de 1.000 registros en ese array.
Por otra parte, si el tamao mximo declarado para un array es mucho mayor que el total de
espacio de memoria requerido, el programa utilizar ineficientemente la memoria, dado que la
cantidad de memoria especificada en la declaracin se reservar. incluso aunque solo se utilice
una pequea parte.
Los punteros (apuntadores) permiten la creacin de estructuras de datos dinmicas:
estructuras de datos que tienen capacidad de variar en tamao y ocupar tanta memoria como
utilicen realmente. Las variables que se crean y se destruyen durante la ejecucin se llaman
variables dinmicas (tambin annimas). As durante la ejecucin de un programa puede haber
una posicin de memoria especifica asociada con una variable dinmica y posteriormente
puede no existir ninguna posicin de memoria asociada con ella.
Pascal proporciona los mtodos para asignar y liberar espacio de memoria utilizando
punteros y los procedimientos predefinidos new y dispose.
Al contrario que las estructuras de datos estticas, tales como arrays cuyos tamaos y
posiciones de memoria asociados se fijan en tiempo de compilacin, las estructuras dinmicas
de datos se amplan (expanden)o reducen (contraen) a medida que se requiera durante la
ejecucin y cambia sus posiciones de memoria asociada
Una estructura de datos dinmica es una coleccin de elementos llamados nodos de la
estructura - normalmente de tipo registro - que se enlazan o encadenan juntos. Este enlace se
establece asociando con cada nodo un puntero que apunta al nodo siguiente.
Existen diferentes tipos de estructuras dinmicas de datos, siendo las ms notables y
significativas las listas enlazadas, los rboles y los grafos.
Las estructuras de datos dinmicas son tiles especialmente para almacenar y procesar
conjuntos de datos cuyos tamaos cambian durante la ejecucin del programa, por ejemplo el
conjunto de trabajo que se han introducido en una computadora y estn esperando su ejecucin
o el conjunto de nombres de pasajeros y asignacin respectiva de asientos de un vuelo de avin
determinado.

Estructuras de Datos Dinmicas

El tipo puntero es un tipo de dato simple y se utiliza para almacenar direcciones de

memoria de otra variable, o lo que es igual, su valor es una direccin de una posicin de
memoria donde esta almacenada otra variable. Al definir un tipo puntero, se debe indicar el tipo
de valores que se almacenaran en las posiciones designadas por los punteros. La razn es que
los diferentes tipos de datos requieren diferentes cantidades de memoria.
Declaracin
Hay que diferenciar entre la variable puntero quien hace el apuntamiento y la variable
apuntada a quien se apunta. Un tipo de dato puntero se especifica utilizando el smbolo de
circunflejo (^) seguido por un identificador. Se puede declarar puntero que apunten a cualquier
tipo de dato.
Var
Nombre-variable : ^identificador-tipo;
Ejemplo
Var
p: ^integer;
P es una variable puntero que apunta a posiciones que
6

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

contienen enteros. La posicin de memoria designada por el valor de la variable puntero p se

representa por p^.
NEW : crea una nueva variable dinmica y establece que una variable puntero apunte a ella.
Siendo p una variable puntero, New(p). Este procedimiento asigna almacenamiento para el
valor del tipo determinado y sita la direccin de esta celda de memoria en la variable puntero
p.
ASIGNACIN: p^ = 25 Almacena el valor entero 25 en la posicin (celda) de memoria
apuntada por p.
DISPOSE: libera la posicin de memoria ocupada por una variable dinmica. Dispose(p)
destruye la variable de referencia por p y devuelve su zona de memoria a la pila dinmica
(heap).
CONSTASTE NIL: Pascal proporciona una constante predefinida nil o nulo, que se utiliza
para dar un valor a una variable puntero que no apunta a ninguna posicin y puede se asignado
a un puntero de cualquier tipo.

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 5

EJERCITACIN - SOLUCIONES

Archivos

Dado un archivo de entrada de 'alumnos' que contiene padrn,

nombre, cdigo de carrera ordenado ascendentemente por padrn
y otro archivo 'materias' con padrn, cdigo de materia, nota,
ordenado ascendente por padrn y cdigo de materia, generar
otro archivo de salida 'promedio' que contenga padrn, nombre, promedio de notas ordenado
ascendentemente por padrn. Utilizar acceso secuencial y archivos de texto. No utilizar
estructuras auxiliares.
dem punto anterior pero generar un archivo 'altos promedios' que solo contenga aquellos
alumnos cuyo promedio sea superior a 7 ordenado ascendentemente por padrn.
dem punto 1 pero generar un archivo 'promedio por carrera' que contenga cdigo de carrera,
promedio de notas y cantidad de alumnos ordenado ascendentemente por cdigo de carrera y
suponiendo que el archivo 'alumnos' est ordenado por cdigo de carrera y padrn.
program archi1;
uses
crt;
type
alum = record
padrn : string[5];
nombre : string[20];
carrera : char;
end;
mate = record
padrn : string[5];
materia : string[5];
nota : integer;
end;
prom = record
padrn : string[5];
nombre : string[20];
promedio : real;
end;
var
alumnos : text;
materias : text;
promedios : text;
alumno : alum;
materia : mate;
promedio :prom;
p,total,cant :integer;
padronaux : string[5];
begin
clrscr;
assign(alumnos,'c:\turbop\alumnos.txt');
assign(materias,'c:\turbop\materias.txt');
assign(promedios,'c:\turbop\promedio.txt');
reset (alumnos);
reset (materias);
rewrite (promedios);
padronaux:='';materia.padron:='';
while not eof(alumnos) do
8

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

begin
read(alumnos,alumno.padron);
read(alumnos,alumno.nombre);
readln(alumnos,alumno.carrera);
total :=0; cant :=0; p :=0;
if padronaux < alumno.padron then read(materias,padronaux);
while not eof(materias) and (padronaux = alumno.padron) do
begin
read(materias,materia.materia);
read(materias,materia.nota);
readln(materias);
total := total + materia.nota;
cant := cant + 1;
read(materias,materia.padron);
padronaux := materia.padron;
end;
if total <> 0 then p := total div cant;
promedio.padron := alumno.padron;
promedio.nombre := alumno.nombre;
promedio.promedio := p;
write(promedios,promedio.padron);
write(promedios,promedio.nombre);
write(promedios,promedio.promedio);
writeln(promedios);
end;
close(alumnos);
close(materias);
close(promedios);
readln;
end.

Punteros
type
puntero = ^ nodo;
nodo = record
info
: char;
arriba,abajo
: puntero;
end;
var
p,q,r
: puntero;
Mostrar con diagramas lo que escribe el siguiente segmento de cdigo:
new(p); new(q); new(r);
p^.info :='B';
p^.abajo :=q;
q^.abajo := r;
q^.info := 'C';
r^.info := 'A';
r^.abajo := p;
r^.arriba := q;
9

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

q^.arriba := p;
p^.arriba := r;
p^.abajo^.abajo := p;
q^.info := q^.abajo^.info;
p := q ;
p^.arriba^.info := 'D';
writeln (p^.info,q^.info, r^.info);
Resultado: BBA
Tabla de Direcciones:
Estado inicial p = 0; q = 1; r = 2;
Estado final p = 1; q = 1; r = 2; *cambio por la sentencia p := q;
Tabla de informacin
Estado inicial
Dir
Nodo Arriba
0
B
2
1
C
0
2
A
1
Estado final
Dir
Nodo Arriba
0
D
2
1
B
0
2
A
1

Abajo
1
2
0
Abajo
1
0
0

Recursividad
Realizar un procedimiento recursivo para obtener el mximo comn divisor
function mcd(x,y : integer): integer;
begin
if y = 0 then mcd:= x
else mcd := mcd(y,x mod y);
end;
Dado el siguiente procedimiento recursivo, hacer el seguimiento y mostrar la salida.
Procedure IMPRYPERM(X,Y,Z: char; N:integer)
Begin
if N>0 then
begin
write(Z);
IMPRYPERM(Y,Z,X,N-1);
write(X);
IMPRYPERM(Z,X,Y,N-2);
write(Y);
end
End;
Mostrar la salida producida para las siguientes llamadas:
IMPRYPERM('A','B','C',2);
10

A L G O R I T M O S

N
2
1
0
-1
0

X
AP
BP
C
B
A

P R O G R A M A C I N

Y
BP
CP
A
C
B

I I

T E O R I A

Z
CP
AP
B
A
C

Resultado: CABCAB

Dadas las siguientes declaraciones en Pascal

Compiladores

registro = record
A : integer;
B: boolean;
C: real;
case TIPO : char of
X: ( D: array [1..5, 1..15] of char; E: 1..100; F: boolean);
Y: ( G: packed_array[1..20] of char; H : integer);
Z : ( I: array [1..30] of char; J : integer);
end;
var
RE1 , RE2 : registro;
registros : array [1..20] of registro;
y suponiendo que la tabla de variables del programa se carga en la posicin 100 de la memoria,
decir como se resuelve en tiempo de ejecucin la direccin de memoria donde realizar la
asignacin:
RE1.D [2,10] := 'T';
Resolucin
La longitud del integer, char, boolean se considera 1. Del real 4
La longitud de un packet array se la divide por 4 y se toma el entero superior.
El offset de la tabla de registros de coloca en 0 por cada registro nuevo.

Id Interno
E1

Id Pascal
-

Base
Integer

Tabla de enumerados
Limite inferior
1

Id Interno

Id Pascal

Base

Tabla de arrays
Dimensin

A1

Char

A2
A3
A4

Packet char
Char
R1

2(1)
2(2)
1
1
1

11

Limite superior
100

Limite
inferior
1
1
1
1
1

Limite
superior
5
15
20
30
20

Longitud
1

Longitud

1*15*5=75
1*20/4=5
1*30=30
84*20=1680

A L G O R I T M O S

Id Interno
R1

Id Interno
V1
V2
V3

P R O G R A M A C I N

Id Pascal
Registro

Id Pascal
RE1
RE2
REGISTROS

I I

T E O R I A

Tabla de registros
Id Dato
Base
A
Integer
B
Boolean
C
Real
Tipo
Char
D
A1
E
E1
F
Boolean
G
A2
H
Integer
I
A3
J
Integer
Tabla de variables
Base
R1
R1
A4

Off set
0
1
2
6
7
82
83
7
12
7
37

Off set
0
84
168

Clculo de la direccin de memoria RE1.D [2,10]:= 'T'

Posicin tablas + Off-set(RE1) + Off_set(D) + Posicin ([2,10]) =

100 + 0 + 7 + 24 = 131
Posicin ([2,10]) = (i- L1)*(V2-L2 +1)*n+(j-L2)*n=
Siendo [L1...V1,L2....V2] = [1...5,1...15] y i=2, j=10, n=1 por ser char
Entonces
Posicin ([2,10]) =(2-1)*(15-1+1)*1+(10-1)*1=15+9=24

12

Longitud
1
1
4
1
75
1
1 =84
5
1 = 13
30
1 = 38

Longitud
84
84
1680

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 6

SORT INTERNO
Implica ordenar por una clave o varias, en forma ascendente o descendente una secuencia de
datos.
X1,X2,...,Xn
X1 <= X2 <= .... <= Xn
X1 >= X2 >= .... >= Xn
Empezaremos por los mtodos tradicionales. Son fciles de entender pero ineficientes,
especialmente para juegos de datos grandes. Luego prestaremos ms atencin a los ms
eficientes: heapsort y quicksort

Clasificacin de sorts
Seleccin: La idea bsica es hacer un nmero de pases a la lista o a una parte de esta de manera
de seleccionar un elemento que quede correctamente posicionado. En cada paso tomamos una
sublista y el menor elemento es seleccionado y movido a su correcta posicin.
Intercambio: Intercambia pares de elemento contiguos que no estaban en orden hasta que no
hay ms. Luego de cada intercambio avanza un elemento. Esto garantiza que al final de cada
recorrida, el elemento ms grande (o el ms chico), quede bien ubicado, reducindose la lista a
ordenar a una ms chica.
Insercin: similar a algoritmos de insercin en listas ordenadas.

Heap y HeapSort

Un heap es un rbol binario con las siguientes caractersticas:

Es completo. Cada nivel es completo excepto posiblemente el
ltimo, y en ese nivel los nodos estn en las posiciones ms a la
izquierda.
Los tems de cada nodo son mayores e iguales que los items almacenados el los hijos.
Para implementarlo podemos usar estructuras enlazadas o vectores numerando los nodos por
nivel y de derecha a izquierda.
1
2
3
4
5
6 7
Es fcil buscar la direccin del padre o de los hijos de un nodo. El padre de i es
i div 2. Los hijos de i son 2 ** i y 2 ** i + 1
Un algoritmo para convertir un rbol binario completo en un heap es bsico para otras
operaciones de heap. Por ejemplo un rbol en el que ambos subrboles son heap pero el rbol
en si no lo es.
2
9
1 5

4
3

La nica razn por la que no es un heap es porque la raz es menor que uno (o dos como en
este caso subrboles)
El primer paso es intercambiar la raz con el mayor de los dos hijos:
9
13

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

2
4
1 5 3
Esto garantiza que la nueva raz sea mayor que ambos hijos, y que uno de estos siga siendo un
heap (en este caso el derecho) y que el otro pueda ser o no. Si es, el rbol entero lo es, sino
simplemente repetimos el swapdown en este subrbol.

SWAPDOWN
1. Done := false
2. c:= 2 ** r
3. While not Done and c<=n Do
a. if c < n and Heap[c] < Heap[c+1] then c := c+1;
b. if Heap[r] < Heap[c] then
i. Swap Heap[r] y Heap[c]
II. r := c
iii. c := 2 ** c
else Done := true

Heapify
Recibe un rbol binario completo almacenado en un arreglo desde posicin 1 a posicin n.
Convierte el rbol en un heap.
SwapDown (rbol cuya raz esta en r)
Ejemplo : 35,15,77,60,22,41
El arreglo contiene los tem como un ABC.
35
15
77
60 22
41
Usamos Heapify para convertirlo en Heap.
77
60
41
15 22
35
Esto pone al elemento ms grande en la raz, es decir la posicin 1 del vector. Ahora usamos la
estrategia de sort de seleccin y posicionamos correctamente al elemento ms grande y
pasamos a ordenar la sublista compuesta por los otros 5 elementos
35
60
41
15 22
77 -------------------35,60,41,15,22,77
En trminos del rbol estamos cambiando, la raz por la hoja ms a la derecha. Sacamos ese
elemento del rbol. El rbol que queda no es un heap. Como solo cambiamos la raz, los
subrboles son heaps, entonces podemos usar swapdown en lugar del Heapify que consume
ms tiempo.
60
35
15 22

41

Ahora usamos la misma tcnica de intercambiar la raz con la hoja ms a la derecha que
podamos.

14

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

22
35
41
15 60 ------------------------------------------------- 35,22,41,15,60,77
Volvemos a usar SwapDown para convertir en un Heap
41
35
15

22

Y volvemos a hacer el intercambio hoja-raz.

15
35
22
41 ------------------------------------------------------------ 35,15,22,41,60,77

35

15
22

Volvemos a usar SwapDown

35
15
22 Intercambiamos hoja-raz y podamos
22
------------------------------------------------- 22,15,35,41,60,77
Finalmente, el rbol de dos elementos es convertido en un heap, e intercambiado la raz con la
hoja y podado
15
22 ---------------------------------------------------------- 15,22,35,41,60,77
El siguiente algoritmo resume el procedimiento descripto.
Consideramos a X como un rbol binario completo y usamos heapify para convertirlo en un
heap.
For i = n down to 2 do
intercambiar X[1] y X[i], poniendo el mayor elemento de la sublista X[1]...X[i] al final de esta
aplicar SwapDown para convertir en heap el rbol binario correspondiente a la sublista
almacenada en las posiciones 1 a i - 1 de X.

QuickSort

Vimos que en un algoritmo de sort por intercambio, son

necesarios intercambios de elementos en sublistas hasta que no
son posibles ms. En el burbujeo, son comparados tem
correlativos en cada paco de la lista. Por lo tanto para ubicar un tem en su correcta posicin,
pueden ser necesarios varios intercambios.
Veremos el sort de intercambio desarrollado por C.A.R. Hoare conocido como Quicksort.
Es ms eficiente que el burbujeo porque los intercambios involucran elementos que estn ms
apartados, entonces menos intercambios son requeridos para poner un elemento en su posicin
correcta.

15

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

La idea bsica es elegir un elemento llamado pvot, y ejecutar una secuencia de intercambios
tal que todos los elementos menores que el pvot queden a la izquierda y todos los mayores a
la derecha.
Ejemplo
75,70,65,84,98,78,100,93,55,61,81,68
Supongamos que por simplicidad elegimos el primero como pvot, quedarn a la izquierda:
70,65,55,61,68 y a la derecha: 84,98,78,100,93,81
Lo nico que requiere este proceso es que todos los elementos a la izquierda sean menores que
el pvot y que todos los de la derecha sean mayores luego de cada paso, no importando el
orden entre ellos, siendo precisamente esta flexibilidad la que hace eficiente al proceso.
Hacemos dos bsquedas, una desde la izquierda y otra desde la derecha, comparando el pvot
con los elementos que vamos recorriendo, buscando los menores o iguales y los mayores
respectivamente. En el ejemplo el primer elemento seleccionado a izquierda es el 84, y el
primero a derecha el 68.
75,70,65,84,98,78,100,93,55,61,81,68
Los intercambiamos y repetimos la bsqueda
75,70,65,68,98,78,100,93,55,61,81,84
intercambiamos y seguimos
75,70,65,68,61,78,100,93,55,98,81,84
i
d
intercambiamos y seguimos
75,70,65,68,98,55,100,93,78,61,81,84
i
d
si seguimos la bsqueda desde la derecha encontraremos el 55, es decir que los punteros se
encontrarn. Esto seala el fin de la bsqueda. Intercambiamos el pvot con el 55.
55,70,65,68,98,75,100,93,78,61,81,84
Ahora todos los elementos de la izquierda del 75 con menores y los de la derecha mayores.
Por lo tanto esto me determina dos sublistas que si con ordenadas la lista completa queda
ordenada.
Pueden ser ordenadas independientemente utilizando cualquier esquema de sort. Quicksort
usa el mismo esquema, posicionando el pvot en el primer elemento de cada una.
procedure Split (var X:tipo_arreglo; prim, ult : integer; var Pos : integer);
var izquierdo, derecho : integer;
pvot : tipo_elem;
begin
pivot := X[prim];
izquierdo := prim;
derecho := ult;
while izquierdo < derecho do
begin
while x[derecho] > pvot do derecho := derecho 1;
while x[izquierdo] <= pvot and izquierdo < derecho do
izquierdo := izquierdo +1;
if izquierdo < derecho then Swap (x[izquierdo], x[derecho])
16

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

end;
Pos := derecho;
X[primero] := X[Pos];
X[Pos] := pivot
End;
Procedure Quicksort (var X:tipo_arreglo; prim, ult : integer);
var Pos : integer;
begin
if prim < ult then
begin
Split (X,prim,ult,Pos);
Quicksort (X,prim,Pos - 1);
Quicksort (X,Pos + l,ult)
end
(* en else la lista tiene 0 1 elemento, no necesita sort *)
end;
Este procedimiento es llamado : Quicksort(X,l,n);

Radixsort

Dada una lista desordenada se comienza ordenando por el primer

digito a derecha, luego por el segundo, tercero, etc.

Procedure Radixsort (var L:lista; pricol, ultcol: integer);

Var
Bejn
j:= ultcol;
repeat
generar lista por j-simo elemento
concatenar las listas en L
j:=j-1
until
j< pricol;
end;

17

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 7

SORT EXTERNO
La diferencia con el sort interno es que en este la mayora de los datos estn en memoria en
el momento de ejecutar los procesos. En cambio, en el externo por tratarse de volmenes
ms grandes que en general residen en otros dispositivos de almacenamiento, los datos estn en
su mayora en estos dispositivos. Por lo tanto a diferencia del interno los tiempos de
ejecucin estn dominados por la entrada/salida, por lo tanto un objetivo es minimizar las
transferencias desde y hacia la memoria.
Debemos seleccionar entre las alternativas de realizar el ordenamiento in situ, es decir en su
lugar original o usando mtodos que requieren almacenamiento adicional. Una ventaja del
ordenamiento in situ es que esta permite ordenar grandes archivos en el almacenamiento
disponible. Una desventaja es que si el proceso aborta puede dejar el archivo distinto. Esto
puede solucionarse con una copia off-line.
Si elegimos el sort in situ, podemos utilizar los algoritmos de sort interno y tratar nuestros
archivos como arrays de bloques. Esto requiere archivos de acceso directo. Quicksort es uno
de los mejores algoritmos. Six y Wegner describieron Exquisit, un algoritmo basado en
Quicksort, que ordena archivos de acceso directo.
Los algoritmos que veremos son clasificados como sort-merge. Ordenan los archivos por la
tcnica de divide-and-conquer, en la cual pequeas partes del archivo son ordenadas y luego
apareadas en conjunto. Entonces tenemos dos etapas.
1. Sort: Los registros son ledos desde un archivo de entrada (desordenado) y son ordenadas
particiones de registros, como archivos de salida. Los registros de una particin estn en el
mismo orden que los de las otras.
2. Merge. Las particiones con apareadas hasta tener una nica.
El sort-merge puede ser adaptado a la memoria disponible. El merge necesita en memoria solo
el espacio necesario para un registro por cada una de las partes a ser apareadas. Cuanto ms
memoria tengamos para ordenar las particiones, necesitaremos menos de stas. El mtodo
puede funcionar hasta en el caso extremo, de disponer solo de dos registros. Por supuesto que
demandar mucho tiempo.
Generacin de particiones ordenadas
Hay varios mtodos. Veremos 3.
Sort interno
Reemplazo
Seleccin Natural

Para comparar los tres algoritmos veremos como trabajan con el siguiente lote.
109 49 34 68 45 2 60 38 28 47 16 19 34 55 98 78 76 40 35 86 10 27
61 92 99 72 11 2 29 16 80 73 18 12 89 50 46 36 67 93 22 14 83 44
52 59 10 38 76 16 24 85
Suponemos que la memoria principal puede almacenar M registros.

18

A L G O R I T M O S

P R O G R A M A C I N

T E O R I A

Lee M registros por vez para luego ordenarlos en memoria

utilizando algn mtodo de ordenamiento interno. Todas la
particiones contendrn exactamente M registros salvo tal vez la
ltima.

Sort interno

Reemplazo

I I

Sort interno no saca provecho de un ordenamiento previo que

pueda existir en el archivo. El algoritmo de reemplazo explota
dicha ventaja. La estrategia es la siguiente:
Leer M registros del archivo
Sacar el registro con la clave menor
Reemplazar este por el siguiente registro en el archivo de entrada. Si el nuevo registro no
puede ser parte de la particin corriente (esto es si su clave es ms pequea que la del ltimo
registro de salida), se marca como 'congelada'. (Los registros congelados son ignorados en la
bsqueda del registro con la menor clave) Si existen registros no congelados, debe volverse al
paso 2.
Comenzar una nueva particin. Esto es, 'descongelar' los registros 'congelados' y volver al
paso 2.
Para desarrollar el algoritmo se utilizan dos seales por cada registro; una indica que ya fue
escrito en la salida y la otra que el registro est congelado o no, es decir cuando puede ser
utilizado o no para desarrollar la particin corriente. El loop interno produce registros para la
particin corriente, mientras que cada ciclo del externo produce una particin.
Algoritmo
M : nmero de registros del buffer
for I:=l to M do grabados[I] := true;
I:= 0;
repeat I:=I+1
read Buffer[I] from input
grabados[I] := false
until EOF(input) or I = M;
(* generar particiones ordenadas *)
while not EOF(input)
(* generar una partida ordenada *)
(* inicializar congelados *)
for I:= 1 to M
if not grabados[I] then congelado[I] := false;
while existe algn no congelado
(* grabar un registro en la particin ordenada *)
buscar el ms chico (Buffer[S])
agregar Buffer[S] a la particin ordenada
ultimo := Buffer[S]
grabado[S] := congelado[S] := true .3
if not EOF(input)
read Buffer[S] from input
grabado[S] := false
if clave(Buffer[S]) >= ultimo
congelado[S] := false
end while
end while

19

A L G O R I T M O S

Seleccin Natural

P R O G R A M A C I N

I I

T E O R I A

Una de las desventajas de la seleccin de reemplazo es que hacia

el final de la produccin de una partici6n la mayor parte del
espacio en la memoria principal esta ocupada por registros
congelados. Estos registros no pueden contribuir al armado de
la particin corriente. El mtodo seleccin natural desarrollado por Frazer y Wong mejora esto
con una reserva en memoria secundaria en la cual son metidos los registros congelados. La
produccin de una particin termina cuando da overflow esta particin.

F & W observaron que si M = M' (aprox. 30 registros), la longitud esperada de la particin es

M x e, de aqu el nombre del algoritmo.
M : nmero de registros del buffer
M': nmero de registros de la reserva
for I:=l to M do grabados[I] := true;
I:= 0;
repeat I:=I+1
read Buffer[I] from input
grabados[I] := false
until EOF(input) or I = M;
(* leer del archivo y generar particiones *)
repeat
(* generar una partida ordenada *)
cont-res := 0
sin-espacio := false
repeat
(* sacar un registro *)
grabar el ms chico (Buffer[S])
ultimo := Buffer[S]
grabado[S] := true
if not EOF(input)
then hecho := false
repeat
if clave(sig registro en input) >= ultimo
then read Buffer[S] from sig input
hecho := true
else if cont-res < M'
then read reserva from sig input
cont-res := cont-res + 1
else sin-espacio := true
until hecho o sin-espacio
until EOF(input) o sin-espacio
grabar registros no grabados en orden ascendiente, poniendo en true las correspondientes
seales
if cont-res > 0 then
move min(cont-res, M) registros de la reserva al buffer, marcando las correspondientes
seales de grabado en false y decrementando el cont-res
if buffer not full and not EOF(input) then
llenar el buffer tanto como sea posible del input poniendo las correspondientes seales de
grabado en false
until no queden registros no grabados en el buffer

20

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 8

MERGE
Supongamos que en la etapa de Sort hemos generado R particiones. El mtodo optimo de
aparearlos es que cada particin est en un archivo separado y realizar un merge de R vias. Sin
embargo en la prctica tenemos restricciones operacionales. La ms comn es que solo un
nmero mximo de archivos pueden estar abiertos simultneamente. Por lo tanto el proceso
requiere una serie de fases.
Durante cada una los registros con ledos de un set de archivos, generando otro set de salida.
Hay varias estrategias de merge, teniendo algunos distintos requerimientos en la distribucin
de las partidas originales.
F : mximo nmero de archivos que ce pueden tener abiertos
Cuanto ms grande mejor. Muchas veces es restriccin del sistema operativo.
Consideraremos tres estrategias de Merge:

Balanceado de N caminos
Optimal Merging
Polyphas merging

Una medida de la eficiencia de la etapa de merge de un algoritmo de sort externo, es el nmero

de pases sobre los datos requeridos para mezclar las particiones.
Nmero total de registros ledos
Pases = --------------------------------------------------------------------Nmero total de registros en el archivo apareado
Por lo tanto es el promedio de las veces que un registro es ledo durante el merge.

Los archivos disponibles son divididos lo ms equitativamente

posible en dos juegos. Las particiones originales son distribuidas
as evenly as posible en los archivos de un juego. Durante
cada fase los registros de los archivos de entrada con ledos y apareados y distribuidos
cclicamente en los archivos de salida.
Al final de una fase la salida se convirti en la entrada y viceversa. El mtodo es
balanceado en el sentido que cada uno de los archivos de la entrada contiene
aproximadamente el mismo nmero de registros.

Balanceado N caminos

input-set-first : recuerda cual de los grupos (1 a N o N+1 a F) es en algn momento la entrada

N : tamao de uno de los sets. (El otro F - N)
outsetsize : tamao del set de salida
n := F div 2
input-set-first := false
repeat
cambiar input-set-first
if input-set-first
then open files 1 a N para lectura
open files N+1 a F para grabacin
outsetsize := F - N
base := 1
else open files 1 a N para grabacin
open files N+1 a F para lectura
outsetsize := N

21

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

base := 1
(* ejecutar una fase*)
outfilenum := 0;
partitioncount := 0;
repeat merge particin de cada archivo de entrada numerado
(bace + outfilenum) incrementando en i
outfilenum := (outfilenum +1) mod outsetsize
until EOF on all input files
rewind input and output files
until partitioncount = 1
if input-set-first
then sorted file is N + 1
else sorted file is 1

Inicio
Despus fase 1
Despus fase 2
Despus fase 3
Despus fase 4
Despus fase 5

10 x 1

10 x 1

3x4

2x4

5x2
1 x 8,1 x 4
1x4

1 x 16

5x2
1x8
1 x 20

Ntese que si bien el mtodo es simple esta lejos de ser el mejor. Estamos ejecutando solo F/2
caminos de apareos en lugar de F - 1 caminos, que seria lo mejor.
Por otra parte dependiendo de F y de la distribucin inicial de particiones en ciertas fases es
probable que alguna particin sea copiada directamente de un archivo a otro sin ser apareada.
Se mantiene un registro con la longitud de cada particin. No es
absolutamente optimo porque la longitud de los archivos en una
fase puede ser bastante diferente

Optimal Merge

Notacin X:Y archivo nmero:cantidad de registros

Fase
1
2
3
4
5
6
7
8
9
10

Polyphase Merge

A1
1:1
4:1
7:1
10:1
13:1
16:1
19:1
22:3
25:3
28:9

A2
2:1
5:1
8:1
11:1
14:1
17:1
20:1
22:3
26:3
29:11

A3
3:1
6:1
9:1
12:1
15:1
18:1
21:3
23:3
27:5

OUT
21:3
22:3
23:3
24:3
25:3
26:3
27:5
28:9
29:11
30:20

LECTURAS
3
3
3
3
3
3
5
9
11
20
63

No tiene las desventajas del primero ni requiere los registros

adicionales del segundo. Sin embargo requiere una compleja
distribucin de las particiones iniciales.

22

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Ejemplo 31 particiones con Files = 4

Notacin i X j: i particiones conteniendo j registros
Inicio
Despus fase 1
Despus fase 2
Despus fase 3
Despus fase 4
Despus fase 5
Total

13 x 1
6x1
2x1
1 x 17

11 x 1
4x1
2x9
1x9

7x1
7x3
3x3
1x3

4x5
2x5
1x5

1 x 31

=21
=20
=18
= 17
=31
=107

El problema es conocer la distribucin de las particiones originales. El final es una particin en

un archivo. Antes tenemos 3 archivos, cada uno con una particin
111
Antes tenemos
221
En general
a
b
a+b
a+c

c particiones en el paso anterior

a particiones

cuando apareamos producimos a = min(a+b a+c a) particiones

quedando b particiones en un archivo y c en el otro
Trabajando para atrs llegamos a la distribucin
13
11
7
Observamos que el mtodo para F=4 funciona optimo si la distribucin inicial de particiones
est en la Serie de Fibonacci 1 3
5
9
17
31
...
a
b
c
a+b
a+c
a
1
0
0
=1
1
1
1
=3
2
2
1
=5
4
3
2
=9
7
6
4
=17
13
11
7
=31

Mtodo
Dadas 20 particiones y 4 archivos (siendo 3 de entrada y 1 de salida) se realizan los siguientes
pasos:
Paso 1: Clculo de la distribucin de las particiones
Siguiendo la formula de la serie de Fibonacci
A
a+b
1
1(1+0)
2(1+1)
4(2+2)
7(4+3)
13(7+6)

B
a+c
0
1(1+0)
2(1+1)
3(2+1)
6(4+2)
11(7+4)

C
A
0
1
1
2
4
7

total (a+b+c)
(del paso anterior)
=1
=3
=5
=9
=17
=31 (llego hasta que iguale o supere el nro de
particiones(en este caso 20)

23

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Paso 2: Clculo de Dummies (se debe distribuir en forma pareja)

Total
-dummies
(31-20)/3=3.66 =>4 para los que puedo y el resto 3
Particiones

13
4

11
4

7
3

=31
=11

=20

Paso 3: coloco los datos

INICIO
coloco primero los
dummies D y luego
los datos segn el
paso 2

PASO 2
genero el archivo de
salida con los de
entrada hasta que
alguno de entrada
no tenga datos.

A1(ENTRADA)
D
D
D
D
1
4
7
10
13
15
17
19
20

A2(ENTRADA)
D
D
D
D
2
5
8
11
14
16
18

10
13
15
17
19
20

11
14
16
18

PASO 3
repito paso 2 pero 19
ahora el de salida es 20
el archivo vaco del
paso anterior
PASO 4
Idem
PASO 5
Idem

(SALIDA)
1-2-6-7-8-10-11-1215-16-19

A3(ENTRADA)
D
D
D
3
6
9
12

(SALIDA)
D
D
D
3
1-2-6
4-5-9
7-8-12
(SALIDA)
10-11
13-14
15-16
3-17-18

(SALIDA)
1-2-6-10-11-19
4-5-9-13-14-20

15-16
3-17-18

4-5-9-13-14-20

3-17-18

PASO 6
Idem hasta que todo
que en un slo
archivo.

A4(SALIDA)

1-2-6
4-5-9
7-8-12

7-8-12

(SALIDA)
1-2-3-4-5-6-7-89-10-11-12-1314-15-16-17-1819-20

24

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 9

RBOLES BB-TREE
Son tipos especiales de rboles que los hacen adecuados para almacenar y recuperar
informacin. Como en un rbol binario de bsqueda buscar informacin requiere recorrer un
solo camino desde la raz a una hoja. Como en un rbol balanceado el ms largo camino de
la raz a una hoja es O(log n) A diferencia de un rbol binario cada nodo puede contener varios
elementos y tener varios hijos. Debido a esto y a que es balanceado, permite acceder a grandes
conjuntos de datos por caminos cortos.

Cada nodo puede contener entre d y 2d elementos, donde d es

el orden del rbol. La nica excepcin es la raz que puede
contener entre 1 y 2d. El nmero de hijos de un nodo es o 0 o
alguna ms grande que el nmero de elementos del nodo.

Insercin y Eliminacin

Ejemplo orden 2. Tamao nodos 2 a 4. Nmero de hijos 0, 3, 4, 5.

(10 20 40)

Orden 2

1 nodo 3 elementos

Los elementos siempre estan ordenados en los nodos. Si agregamos el 30 queda

20 30 40)
El rbol contiene un nodo lleno. Para agregar un elemento hay que realizar uno de los pasos
ms importantes de la insercin: particin de un nodo.
Supongamos que queremos agregar el 50, entonces debemos:
1. Dividir el nodo en dos
2. Poner los dos elementos ms pequeos a la izquierda
3. Poner los dos ms grandes a la derecha
4. Crear un nuevo nodo raz
5. Poner el elemento del medio (30) en el nodo raz
(30)
(10 20) (40 50)
Si agregamos 25,42,44
(30)
(10 20 25) (40 42 44 50)
Si agregamos un < 30 va a la izquierda. Si queremos agregar uno mayor (41), partimos el
derecho, pasando el elemento del medio a la raz
(30 42)
(10 20 25)
(40 41)
(44 50)
Una bsqueda de algn elemento menor que 30 comienza en la raz y sigue con el puntero a la
izquierda de 30. Una bsqueda de un valor entre 30 y 42 comienza por el puntero entre ambos
valores. Una de algn valor >42 comienza por el puntero a la derecha de 42. Una insercin
comienza en la hoja en la cual el elemento ira. Si hay lugar no hay problema. Ej : 32,38 y 56
(30 42)
(10 20 25)

(32 38 40 41)

(44 50 56)

Ahora si insertamos algn valor entre 30 y 42 (ej. 34) se parte el nodo del medio y el elemento
central pasa para arriba

25

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

(30 38 42)
(10 20 25) (32 34) (40 41) (44 50 56)
Ahora agregamos 58
(30 38 42)
(10 20 25) (32 34) (40 41) (44 50 56 58)
Ahora agregamos 60,52,54
(30 38 42 56)
(10 20 25) (32 34) (40 41) (44 50 52 54) (58 60)
Ahora agregamos 46
(42)
(30 38)
(50 56)
(10 20 25) (32 34) (40 41) (44 46) (52 54) (58 60)

Descripcin de insercin

Vamos a hacer una descripcin general del algoritmo de

insercin. El primer paso es siempre buscar la hoja donde el
elemento estara si estuviese en el rbol. Despus que la hoja es encontrada la secuencia de
insercin comienza. Cada proceso agrega un elemento a un nivel del rbol. Si una particin es
requerida pasa un elemento al nivel superior. Llamamos a esos procesos: INSERT1,
INSERT2, INSERT3. Funcionan de la siguiente manera:
INSERT1: El nodo tiene menos de 2d elemento y puede almacenar el elemento a insertar. El
elemento es agregado en orden y la insercin termina.
INSERT2: El nodo est lleno (2d elementos), por lo que es requerida una particin. Se crea un
nuevo nodo que recibe los dos ms grandes, los dos ms chicos quedan y el del medio pasa al
padre. El proceso contina.
INSERT3 : La raz es partida. Una nueva raz es creada y contiene un solo elemento.
Una insercin en B-Tree siempre comienza por el agregado de un elemento a la hoja
correspondiente. El B-Tree resiste el crecimiento de su altura, examinando cada nodo en el
camino de la hoja a la raz, para ver si en alguno hay lugar para un elemento extra. La altura
se incrementa si todos los nodos estn llenos y debe crearse una nueva raz. El rbol siempre
contina balanceado.
El algoritmo de borrado, como el de insercin comienza con
las hojas. Si el elemento a ser borrado no est en una hoja, es
reemplazado por el elemento ms chico en el nodo ms a la
izquierda del subrbol derecho (o el ms grande en el nodo ms a la derecha del subrbol
izquierdo). Este reemplazo requiere remover un rbol de una hoja. Como en la insercin hay
tres casos a considerar. El proceso comienza con una hoja, pero se aplica a cualquier nodo
de cualquier nivel. Al nodo que contiene el elemento a ser removido lo llamaremos nodo
objeto.

Descripcin de Eliminacin

(30 38 42)
(10 20 25) (32 34) (40 41) (44 50 56 58)

26

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Ahora borramos 32
(25 38 42)
(10 20) (30 34) (40 41) (44 50 56 58)
Ahora borramos 34
(25 42)
(10 20)

(30 38 40 41) (44 50 56 58)

DELETE1 : El nodo objeto contiene ms de d elementos. Se remueve y el proceso termina.

DELETE2 : El nodo objeto contiene exactamente d elementos entonces no se puede remover
ninguno. Si alguno de los nodos de al lado (izquierdo o derecho) del objeto contienen ms de d
elemento, los elementos son compartidos para prevenir el underflow. Esto causa que el
elemento en el padre que separaba los dos hijos cambie. Esto es hecho usualmente para
balancear el nmero de elementos de los nodos. El proceso entonces termina. Si ambos nodos
vecinos, izquierdo y derecho tienen d elementos el nodo objeto es combinado con uno de
ellos, formando uno nuevo de 2d elementos. Uno de los elementos es el elemento del nodo
padre que separaba los nodos que se fusionaron. Si el padre contena ms de d elementos el
proceso termina. Si no se convierte en el nodo objeto y el proceso contina
DELETE 3: El nodo objeto es la raz. Mientras quede un elemento no se modifica.

27

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 10

EJERCITACIN - SOLUCIONES

Dada la siguiente lista de nmeros:

Mtodos de ordenamiento y bsqueda

105,12,79,43,116,348,126,11,81,83,21,36,123,35,56,29,14
Explique como ordena de menor a mayor utilizando
1er PASO:
0
1
2
3
4
011
012
043
014
081
083
021
123
2do Paso:
0
1
105
011
012
014
116
3er Paso:
0
011
012
014
021
029
035
036
043
053
079
081
083

1
105
116
123
126

radixsort
5
105
035

6
116
126
056

8
348

9
079
029

2
021
123
126
029

3
035
036

4
043
348

5
056

7
079

8
081
083

3
348

=>11,12,14,21,29,35,36,43,53,79,81,83,105,116,123,126,348
Utilizando el mtodo de seleccin de reemplazo (sort externo- particiones ordenadas)
describir la generacin de particiones con m=4
P1: 12,43,79,105,116,126,348
P2:11,21,36,81,83,123
P3:14,29,35,56
Considerando la lista 105,12,79,43,116,348,126,11,81,83,21,36,123,35,56,29 como un grupo
de particiones ordenadas de 1 registro cada una, desarrollar el mtodo de merge polifsico con
4 archivos. ( 3 de entrada y 1 Salida). Cantidad de particiones =16
1er. Paso: Clculo de distribucin de particiones segn Fibonacci obtenindose a=7 b=6 c=4
con un total de 17.
2do. Paso: clculo de dumies

28

A L G O R I T M O S

total
7
dumies 1
partic. 6

P R O G R A M A C I N

6
0
6

4
0
4

3er. Paso: proceso

A1
D
105
43
126
83
123
56

A2
12
116
11
21
35
29

83
123
56

I I

T E O R I A

=17
=1
=16

A3
79
348
81
36

35
29

A4

d,12,79
105,116,348
11,43,81
21,36,126

56

12,35,79,83
29,105,116,123,348

11,43,81
21,36,126

11,12,35,43,56,79,81,83 29,105,116,123,348

21,36,126

11,12,21,29,35,36,43,
56,79,81,83,105,116,
123,126,348

Construir el b-tree de orden 2 (nodos hasta 4) que resulta de

ingresar los siguientes nmeros en el orden dado:

rboles B

308,418,422,332,171,437,132,187,514,328,451,277,493,117,97,511,530,504,386,217,407,294,
202
BORRAR 217
BORRAR 294
INSERTAR 500
INSERTAR 400
Solucin:
(308)
(308,418)
(308,418,422)
(308,332,418,422)
(332)
/
\
(171,308)
(418,422)
(332)
/
\
(132,171,187,308) (418,422,437,514)
(187,332)
29

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

/
|
\
(132,171) (308,328) (418,422,437,514)
(187,332,437)
/
|
\
\
(132,171) (308,328) (418,422) (451,514)
(187,332,437)
/
|
\
\
(97,117,132,171) (277,308,328) (418,422) (451,493,511,514)

(187,332,437,511)
/
|
\
\
\
(97,117,132,171) (217,277,308,328) (386,407,418,422) (451,493,504) (514,530)
(332)
/
\
(187,294)
(437,511)
/
|
\
/
\
\
(97,117,132,171) (202,217,277) (308,328) (386,407,418,422) (451,493,504) (514,530)

(187,332,437,511)
/
|
\
\
\
(97,117,132,171) (202,277,308,328) (386,407,418,422) (451,493,504) (514,530)

EJERCITACIN ADICIONAL

Punteros y Recursividad

Dado el siguiente procedimiento recursivo mostrar con diagramas lo

que se genera en memoria si se invoca con p :=nil; Armar(P,3,2)
Sabiendo que
Type

Puntero = ^nodo;
Nodo = record
Coeficiente, exponente : integer;
Sig: puntero;
End;
Var p: puntero;
Procedure Armar(var p:puntero; x,y: integer);
Begin
If p=nil and x>0 then begin
New(p);
p^.sig := nil;
p^.coeficiente := x;
p^.exponente := y;
armar(p^.sig,x-1,x*y);
p^.coeficiente := p^.coeficiente * x;
p^.exponente := p^.exponente + y;

30

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

end;
End;

Dado el siguiente lista de nmeros: 15, 54, 25, 63, 45, 85, 97, 86,
12, 9, 785, 2, 67, 99, 458, 657, 999, 125, 35 y considerando la
lista dada como un grupo de particiones ordenadas de 1 registro

Sort
cada una, desarrollar:

El mtodo merge polifsico con 4 archivos.

El mtodo Radixsort
El mtodo seleccin por reemplazo sabiendo que M=4
Explique como ordena de menor a mayor utilizando Quicksort
El mtodo Heapsort

Construir un rbol B-tree de orden 2(nodos hasta 4) que resulta

de ingresar los siguientes nmeros en el orden dado:
12, 45, 6,78,98,2,35,18,1,82,247,74,54,69,39,80,49,11,27,37,99
Hacer las siguientes operaciones en secuencia: borrar 82,Borrar

rboles B
35, borrar 45.

Construir el b-tree de orden 2 (nodos hasta 4) que resulta de ingresar los siguientes nmeros en
el orden dado: 252-372-376-286-125-391-86-141-468-282-405-231-447-71-16-465-484-458340-171-361-248-156 y borrar 171,248
Construir el b-tree de orden 2 (nodos hasta 4) que resulta de ingresar los siguientes nmeros en
el orden dado: 43-49-48-47-46-45-2-41-7-23-47-49-43-100-8-1-3-4 y borrar 41, insertar 50,75

31

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 11

PROGRAMACIN ORIENTADA A OBJETOS

Grady Booch autor del mtodo de diseo orientado a objetos, define la programacin orientada
a objetos (POO) como:
un mtodo de implementacin en el que los programas se organizan como
colecciones cooperativas de objetos, cada uno de los cuales representan una instancia de alguna
clase, y cuyas clases son todos miembros de una jerarqua de clases unidos mediante relaciones
de herencia.
Existen tres importantes partes en la definicin:
1- utiliza objetos, no algoritmos como bloques de construccin lgicos (jerarquia de
objetos)
2- cada objeto es una instancia de una clase
3- las clases se relacionan unas con otras por medio de relaciones de herencia
Los conceptos fundamentales de programacin son: objetos, clases, herencia, mensajes y
polimorfismo.
Una de las ventajas ineludibles de la orientacin a objetos es la posibilidad de reflejar sucesos
del mundo real mediante tipos abstractos de datos extensibles a objetos.

Objeto

El concepto de objeto al igual que los tipos abstractos de datos o

tipos definidos por el usuario, es una coleccin de elementos de
datos, junto con las funciones asociadas utilizadas para operar
sobre esos datos. Sin embargo, la potencia real de los objetos reside en el modo en que los
objetos pueden definir otros objetos. Es proceso se denomina herencia: es el mecanismo que
ayuda a construir programas que se modifican fcilmente y se adaptan a aplicaciones
diferentes.
La idea fundamental en los lenguajes orientados a objetos es combinar en una sola unidad,
datos y funciones que operan sobre esos datos. Tal unidad se denomina objeto. Las funciones
dentro del objeto son el unico medio de acceder a los datos privados de un objeto. Si se desea
leer un elemento de un objeto se llama a la funcion miembro del objeto. Se lee el elemento y se
devuelve el valor. No se puede acceder a los datos directamente por funciones externas al
objeto. Los datos y las funciones asociados se dicen que estan encapsulados en una unica
entidad o modulo. La encapsulacion de datos y ocultacin de datos son terminos importantes
en la descripcin de lenguajes orientados a objetos.
Un objeto es una entidad que contiene los atributos que describen el estado de un objeto del
mundo real y las acciones que se asocian con el objeto del mundo real. Se designa por un
nombre o identificador del objeto. Un objeto encapsula datos y los procedimientos y funciones
(mtodos) que manejan esos datos.
Los tipos objeto definidos por el usuario contiene datos definidos por el usuario
(caractersticas) y operaciones (comportamiento). Las operaciones definidas por el usuario de
denominan mtodos. Para llamar a uno de estos mtodos, se hace una peticin al objeto: esta
accin se conoce como enviar un mensaje al objeto.
Cada objeto consta de
Estado (atributos)
Operaciones o comportamiento ( mtodos invocados por mensajes)
Desde el punto de vista informtico los objetos son tipos abstractos de datos.
32

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Los objetos ocupan espacio de memoria y en consecuencia existen en el tiempo y debern

crearse o instanciarse. Por la misma razn se debe liberar el espacio ocupado en la memoria
por los objetos cuando ya no son necesarios.
Constructor: operacin que crea un objeto y/o inicia su entrada
Destructor: operacin que libera el espacio de memoria ocupado por un objeto y/o destruye el
propio objeto.

Mtodos y mensajes

Los objetos se comunican entre si llamando a funciones

miembros y se denominan mtodos. Los procedimientos y
funciones residen en el objeto y determinan como actuan los
objetos cuando reciben un mensaje. Un mensaje es la accion que hace un objeto. Un metodo es
el procedimiento o funcin que se invoca para actuar sobre un objeto. Un metodo especifica
como se ejecuta un mensaje. El conjunto de mensajes a los cuales puede responder un objeto se
denomina protocolo.
Cuando se ejecuta un programa orientado a objetos, ocurren tres sucesos. Primero, los objetos
se crean a medida que se necesita. Segundo, los mensajes se mueven de un objeto a otro ( a
desde el usuario a un objeto) a medida que el programa proceso informacin internamente o
responde a la entrada del usuario. Por ello, cuando los objetos ya no son necesarios, se borran y
se libera la memoria.
Un mensaje es una peticin de un objeto a otro objeto al que le solicita ejecutar uno de sus
mtodos. El objeto que enva la peticin se denomina emisor y el objeto que recibe la peticin
se denomina receptor. Un mensaje consta de 3 partes:
Identidad del receptor
El mtodo que se ha de ejecutar
Informacin especial necesaria para realizar el mtodo invocado (argumentos)

Clase

Una clase es la descripcin de un conjunto de objetos; consta de

mtodos y datos que resumen caractersticas comunes de un
conjunto de objetos. Una clase es la declaracin de un tipo
objeto. Las clases equivalen a modelos o plantillas que describen como se construyen ciertos
tipos de objetos. Cada vez que se construye un objeto a partir de una clase, estamos creando lo
que se llama una instancia de esa clase. Por consiguiente, los objetos no son mas que instancias
de una clase. Una instancia es una variable de tipo objeto. En general instancia de una clase y
objeto son trminos intercambiables. Cada vez que se construye un objeto de una clase, se crea
una instancia de esa clase. Los objetos se crean cuando un mensaje de peticin de creacin se
recibe por la clase base.
A diferencia de la clase, un objeto es un simple elemento, no importa lo complejo que pueda
ser. Una clase, por el contrario, describe una familia de elementos similares. En la practica, una
clase es como un esquema o plantilla que se utiliza para definir o crear objetos. A partir de una
clase se puede definir un numero determinado de objetos. Cada uno de estos objetos
generalmente tendr un estado particular propio y otras caractersticas aunque compartan
algunas operaciones comunes. Los objetos tienen las siguientes caractersticas:
Se agrupan en tipos llamados clases
Tienen datos internos que definen su estado actual
Soportan ocultacin de datos
Pueden heredar propiedades de otros objetos
Pueden comunicarse con otros objetos pasando mensajes
Tienen mtodos que definen su comportamiento.

33

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Los objetos y las clases se comparan a variables y tipos en lenguajes de programacin

convencional. Una variable es una instancia de un tipo, al igual que un objeto es una instancia
de una clase; sin embargo, una clase es ms expresiva que un tipo. Expresa la estructura y todos
los procedimientos y funciones que se pueden aplicar a una de sus instancias.

Herencia

Una de las caractersticas ms importantes de la POO, adems de

la encapsulacin y el ocultamiento de la informacin es la
herencia, propiedad que permite a los objetos ser construidos a
partir de otros objetos, capacidad de un objeto para utilizar las estructuras de datos y los
mtodos previstos en antepasados o ascendientes. El objetivo final es la reutilizacin, es decir
reutilizar cdigo anteriormente desarrollado.
Las clases bsicas o fundamentales se dividen en subclases mediante la divisin en jerarqua
compartiendo caractersticas comunes. La herencia supone una clase base y una jerarqua de
clases que contienen las clases derivadas de la clase base. Las clases derivada pueden heredar
cdigo y los datos de su clase base, aadiendo su propio cdigo especial y datos a ellas incluso
cambiar aquellos elementos de la case base que necesita sean diferentes.
Existen dos mecanismos de herencia utilizados comnmente:
Herencia simple (herencia jerrquica): donde un objeto (clase) puede tener solo un
ascendiente; donde una subclase puede heredar datos y mtodos de una nica clase as
como aadir o quietar comportamientos de la clase base. (Tpascal solo admite este
tipo de herencia)
Herencia mltiple (herencia en malla): propiedad un de una clase de poder tener mas
de un ascendiente inmediato, adquirir datos y mtodos de mas de una clase.
Clases abstractas
Clases que no existen en la realidad pero que son construcciones conceptuales tiles.
Normalmente ocupa una posicin adecuada en la jerarqua de clases que le permite actuar como
un deposito de mtodos y atributos compartidos para las subclases de nivel inmediatamente
inferior. No tienen instancias directamente. Se utilizan para agrupar otras clases y capturar
informacin que es comn al grupo.
Anulacin / Sustitucin
Los atributos y mtodos definidos en la superclase se heredan por las subclases. Sin embargo,
si la propiedad se define nuevamente en la subclase, aunque se haya definido anteriormente a
nivel de superclase; entonces la definicin realizada en la subclase es la utilizada en es
subclase. Entonces se dice que anula las correspondientes propiedades de la superclase. Esa
propiedad se denomina anulacin o sustitucin(overriding).
Sobrecarga
La sobrecarga es una propiedad que describe una caracterstica adecuada que utiliza el mismo
nombre de operacin para representar operaciones similares que se comportan de modo
diferente cuando se aplican a clases diferentes. Por consiguiente, los nombres de las
operaciones se pueden sobrecargar, esto es, las operaciones se definen en clases diferentes y
pueden tener nombres idnticos, aunque su cdigo programa puede diferir.
Ligadura dinmica
Los lenguajes OO tienen la caracterstica de poder ejecutar ligadura tarda (dinmica) al
contrario de los lenguajes imperativos, que emplean ligadura temprana (esttica) Por
34

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

consiguiente los tipos de variables, expresiones y funciones se conocen en tiempo de

compilacin para los lenguajes imperativos. En el caso de ligadura tarda el tipo se conecta
directamente al objeto. El enlace entre el mensaje y el mtodo asociado solo se puede conocer
en tiempo de ejecucin. Esto permite definir funciones virtuales En el caso de ligadura
temprana, permite un tiempo de ejecucin ms rpido pero se ha de especificar un tiempo de
compilacin las operaciones exactas a que responder una invocacin del mtodo o funcin
especfica, as como conocer sus tipos.
Funciones o mtodos virtuales: (C++) permiten especificar un mtodo como virtual en la
definicin de una clase particular. La implementacin real del mtodo se realiza en las
subclases. En este caso la seleccin del mtodo se hace en tiempo de compilacin pero el
cdigo real del mtodo utilizado se determina utilizando ligadura dinmica. Esto permite
definir el mtodo de un nmero de formas diferentes para cada una de las diferentes clases.
Polimorfismo: la capacidad de utilizar funciones virtuales y ejecutar sobrecarga conduce a una
caracterstica importante conocida como polimorfismo, que esencialmente permite desarrollar
sistemas en los que objetos diferentes puedan responder de modo diferente al mismo mensaje.
Es el uso de un nombre o smbolo para representar o significar mas de una accin. En un
sentido mas general supones que un mismo mensaje puede producir acciones (resultados)
totalmente diferentes cuando se reciben por objetos diferentes.
Beneficios de la OOP
Los siguientes beneficios son especficos de OOP(object-oriented programming) y que no
pueden ser realizados en SPP (structured procedural programming)
Provee un mejor sistema de modelado del mundo real.
El concepto de tipos de datos abstractos, encapsulacin y ocultamiento de la informacin
incrementa modificabilidad del software.
Polimorfismo y enlace dinmico incrementa la flexibilidad y reusabilidad del cdigo para
permitir la creacin de componentes genricos de software. Sin embargo a veces requieren
mayor tiempo de procesamiento.
La herencia permite que el cdigo sea extensible y reutilizable, as nuevas operaciones y
atributos pueden ser agregados o borrados en la creacin de subclases. Sin embargo largas
jerarquas de clases dificultan y agregan complejidad en la manipulacin del cdigo.

35

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Captulo 12

EJERCITACION
1. Se tienen las clases Humano y Perro. Atributos de Humano: edad, estado civil,
nombre, nmero de documento, sexo. Atributos de Perro: edad, nombre,
raza, sexo.
a. Idear una clase abstracta que permita evitar repetir cdigo.
b.

Escribir la unit de pascal que defina las tres clases. (Interfase e

implementacin). Se debern incluir los atributos nombrados, as como
tambin mtodos que permitan modificar y obtener el valor de dichos
atributos.

c.

Definir conceptos de: Atributo, Mtodo, Clase Abstracta.

2. Se tienen las clases Libro y Revista. Atributos de Libro: Ao, Autor, Cantidad de
pginas, Nombre, Tema. Atributos de Revista: Ao, Cantidad de pginas,
Nombre, Nmero, Tema.
a. Idear una clase abstracta que permita evitar repetir cdigo.
b.

Escribir la unit de pascal que defina las tres clases. (Interfase e

implementacin). Se debern incluir los atributos nombrados, as como
tambin mtodos que permitan modificar y obtener el valor de dichos
atributos.

c.

Definir conceptos de: Constructor, Destructor, Encapsulamiento

CASO RESUELTO

Qu es un objeto?
Definiciones rpidas:
atributos caractersticas, propiedades, valores (marcar analoga con las
variables)
mtodos acciones, cosas que pueden hacer (marcar analoga con los
procedimientos)

Ejemplo - Televisor
Atributos: Canal en el que est, volumen, brillo, boolean que indica si est prendido, etc.
Mtodos: Prender, Apagar, Subir volumen, bajar volumen, subir canal, bajar canal, etc.
Type
Televisor =

Object
Canal:Integer;
End;

Var
Tel1:Televisor;
Begin
Tel1.Canal:=5;
End.
Todos los televisores tienen caractersticas comunes

36

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Analoga: raza, persona

Luego: clase televisor, televisor
Var
Tel1:Televisor;
Tel2:Televisor;
Begin
Tel1.Canal:=5;
Tel2.Canal:=26;
End.

Type
Televisor =

Object
Canal:integer;
Procedure CambiarCanal(NuevoCanal:integer);
End;

Var
Tel1:Televisor;
Tel2:Televisor;
Begin
Tel1.Canal:=5;
Tel2.Canal:=26;
Tel2.CambiarCanal(26);

Esas dos ltimas lineas

hacen exactamente lo mismo

End.
Pero en realidad en un televisor nosotros no tenemos acceso a las variables.
Slo podemos usar los mtodos (los botones)
Entonces las variables que tiene el televisor son PRIVADAS
Y los botones que sirven para cambiar el valor de esas variables son PBLICOS
Pblico = se puede ver desde afuera
Privado = no se puede ver desde afuera

Cuando se le pide a un objeto que ejecute uno de sus mtodos, se le est dando un MENSAJE.

Type
Televisor =

Object
Private
Canal:integer;
Volumen:integer;
Encendido:boolean;
Public
Procedure CambiarCanal(NuevoCanal:integer);
Procedure SubirVolumen;
Procedure BajarVolumen;
Procedure Encender;
Procedure Apagar;
End;

37

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Var
Tel1:Televisor;
Begin
Tel1.Canal:=26;
Tel1.CambiarCanal(26);
Tel1.Volumen:=Tel1.Volumen + 1;
Tel1.SubirVolumen;
Tel1.Encendido:=true;
Tel1.Encender;
End.

mal
bien
mal
bien
mal
bien

No necesariamente SIEMPRE es que los procedimientos son pblicos y los atributos privados,
pero que en este caso si.
Una version mejorada de la implementacin seria asi:
Unit Televisor;
Interface
Type
Televisor =

Object
Private
Canal:integer;
Volumen:integer;
Encendido:boolean;
Public
Procedure CambiarCanal(NuevoCanal:integer);
Procedure SubirVolumen;
Procedure BajarVolumen;
Procedure Encender;
Procedure Apagar;
End;

Implementation
Procedure Televisor.CambiarCanal(NuevoCanal:integer);
begin
Canal:=NuevoCanal;
end;
Procedure Televisor.SubirVolumen;
begin
Volumen:=Volumen + 1;
end;
Procedure Televisor.BajarVolumen;
begin
Volumen:=Volumen - 1;
end;
Procedure Televisor.Encender;

38

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

begin
Encendido:=true;
end;
Procedure Televisor.Apagar;
begin
Encendido:=false;
end;

Ahora modifiquemos el cdigo anterior utilizando el concepto de ENCAPSULAMIENTO:

Type
Televisor =

Object
Private
Canal:integer;
Volumen:integer;
Encendido:boolean;
Procedure CambiarCanal(NuevoCanal:integer);
Public
Procedure SubirCanal;
Procedure BajarCanal;
Procedure SubirVolumen;
Procedure BajarVolumen;
Procedure Encender;
Procedure Apagar;
End;

Y en Implementation pondramos mejorarlo asi:

Procedure Televisor.SubirCanal;
begin
CambiarCanal(Canal+1);
end;
Procedure Televisor.BajarCanal;
begin
CambiarCanal(Canal-1);
end;
Entonces el mtodo CAMBIARCANAL est ENCAPSULADO y las variables encendido, canal,
volumen, estn OCULTAS.Pero si estn ocultas, cmo averiguo su valor desde afuera del
objeto? Para eso estn las funciones GET
Ejemplo:
Function Televisor.GetCanal(integer);
begin
GetCanal:=Canal;
end;
Lo cual luego me permitir hacer
WriteLn(El televisor est en el canal, Tel1.GetCanal);

39

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Con lo cual obtengo el valor que necesito sin violar la abstraccin del objeto.
Anlogamente: GetVolumen, GetEncendido, etc.
Entonces habamos quedado en:
Televisor
Volumen
Canal
Encendido
ahora pensemos en una radio:
Radio
Volumen
Encendido
FM
Pero podemos observar que hay caracteristicas repetidas. Cmo lo podemos evitar?
Podemos crear una clase llamada Aparato y que nos quede as:
Aparato

Televisor

Aparato
Encendido
Volumen

Televisor
Canal

Radio

Radio
FM

Entonces cuando declaremos un objeto como Televisor, vamos a tener disponibles Canal, y
adems Encendido y Volumen que los heredamos de la clase Aparato
Type
Aparato =

Object
Encendido:boolean;
Volumen:integer;
End;

Televisor =

Object(Aparato);
Canal:integer;
End;

Radio =

Object(Aparato);
FM:boolean;
End;

Y si despus hacemos:

40

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

Var
Rad1:Radio;
As, vamos a poder hacer Rad1.Encendido y Rad1.Volumen porque Radio los HEREDA de
Aparato.
Y lo que se hereda no es solamente los atributos. Los mtodos tambin se heredan. Es decir que
si yo declaro el procedimiento SubirVolumen en Aparato, entonces tambin voy a poder hacer
Rad1.SubirVolumen.
Nosotros no vamos a declarar ningn objeto de clase Aparato. Lo podramos hacer, pero no lo
vamos a hacer, porque lo que queremos no es aparatos sino concretamente televisores y radios.
Entonces vamos a tener objetos que van a ser de la clase Televisor, y vamos a tener objetos de
la clase Radio. Pero de la clase Aparato no vamos a tener ningn objeto. Recuerden que la
clase Aparato solo la creamos para no tener que poner dos veces volumen y encendido. La
clase Aparato solo nos sirve para eso. Ese tipo de clase se llama Clase Abstracta.

La implementacin final quedara as:

Unit Cosas;
Interface
Type
Aparato =

Object
Private
Encendido:boolean;
Volumen:integer;
Public
Procedure Encender;
Procedure Apagar;
Procedure SubirVolumen;
Procedure BajarVolumen;
End;

Televisor =

Object(Aparato);
Private
Canal:integer;
Public
Procedure CambiarCanal(NuevoCanal);
End;

Radio =

Object(Aparato);
Private
FM:boolean;
Public
Procedure PonerFM;
Procedure PonerAM;
End;

Implementation
Procedure Aparato.Encender;
Begin
Aparato.Encendido:=true;
41

A L G O R I T M O S

P R O G R A M A C I N

I I

T E O R I A

End;
Procedure Aparato.Apagar;
Begin
Aparato.Encendido:=false;
End;
Procedure Aparato.SubirVolumen;
Begin
Volumen:=Volumen + 1;
End;
Procedure Aparato.BajarVolumen;
Begin
Volumen:=Volumen - 1;
End;
Procedure Televisor.CambiarCanal(NuevoCanal:integer);
Begin
Canal:=NuevoCanal;
End;
Procedure Radio.PonerFM;
Begin
FM:=true;
End;
Procedure Radio.PonerAM;
Begin
FM:=false;
End;

Notar que como todas las dems cosas, los objetos tambin tienen que ser inicializados. (sus
variables, etc.). Para eso se usa un mtodo que se llama CONSTRUCTOR, que se ejecuta cada
vez que se crea un objeto.
Procedure Televisor.Constructor;
Tambin es necesario tener un mtodo que se encargue de destruir al objeto, liberar el espacio
en memoria que ste ocupaba, etc. Para eso se usa el mtodo llamado DESTRUCTOR.
Procedure Televisor.Destructor;

42