02 Algoritmos II

ESCUELA DE CIENCIAS BSICAS E INGENIERA
ASIGNATURA: Algoritmos II
CORPORACIN UNIVERSITARIA REMINGTON

DIRECCIN PEDAGGICA
Este material es propiedad de la Corporacin Universitaria Remington (CUR), para los estudiantes de la CUR
en todo el pas.
2011
Corporacin Universitaria Remington Direccin Pedaggica

Algoritmos II
Pg. 5
CRDITOS
El mdulo de estudio de la asignatura Algoritmos II es propiedad de la Corporacin Universitaria Remington. Las

imgenes fueron tomadas de diferentes fuentes que se relacionan en los derechos de autor y las citas en la bibliografa.
El contenido del mdulo est protegido por las leyes de derechos de autor que rigen al pas.
Este material tiene fines educativos y no puede usarse con propsitos econmicos o comerciales.
AUTOR
Jos Antonio Polo.
Ingeniero de sistemas de la Universidad de Antioquia (1997). Especialista en finanzas de la Corporacin Universitaria
Remington (2007, Medelln). Participacin del tercer Congreso Colombiano de Computacin 3CCC de la universidad
EAFIT (2008, Medelln). Participacin del primer simposio en Inteligencia Artificial de la Corporacin Universitaria
Remington (2000, Medelln). Participacin del IV Congreso Internacional de Software Libre GNU/Linux, Universidad de
Manizales (Marzo del 2005). Participacin del 5 Congreso Nacional de Redes y Telemtica, Redes de Servicios Mviles
Integrados, Centro de Construccin de Conocimiento Evenco CCC (Septiembre de 2007). Docente de ctedra del
politcnico Jaime Isaza Cadavid (2004). Docente de ctedra del Tecnolgico de Antioquia (2008). Participacin del
proyecto de la articulacin de la media tcnica del Tecnolgico de Antioquia con el municipio de Medelln. Actualmente
docente de tiempo completo de la Corporacin Universitaria Remington, donde imparte los cursos de Algoritmos I,
Algoritmos II y Estructura de Datos.
barra5111@yahoo.es
Nota: el autor certific (de manera verbal o escrita) No haber incurrido en fraude cientfico, plagio o vicios de autora; en
caso contrario eximi de toda responsabilidad a la Corporacin Universitaria Remington, y se declar como el nico
responsable.
RESPONSABLES
Director Escuela De Ciencias Bsicas e Ingeniera
Dr. Mauricio Seplveda
Director Pedaggico
Octavio Toro Chica
dirpedagogica.director@remington.edu.co
Coordinadora de Medios y Mediaciones
Anglica Ricaurte Avendao
mediaciones.coordinador01@remington.edu.co
GRUPO DE APOYO
Personal de la Unidad de Medios y Mediaciones
EDICIN Y MONTAJE
Primera versin. Febrero de 2011.
Derechos Reservados
Esta obra es publicada bajo la licencia CreativeCommons. Reconocimiento-No Comercial-Compartir Igual 2.5 Colombia.
Corporacin Universitaria Remington - Calle 51 51-27 Conmutador 5111000 Ext. 2701 Fax: 5137892. Edificio Remington
Pgina Web: www.remington.edu.co - Medelln - Colombia

Algoritmos II
Pg. 6
TABLA DE CONTENIDO
1.
MAPA DE LA ASIGNATURA ............................................................................................. 7
2.
SUBPROGRAMAS ........................................................................................................... 8
2.1.
Subprogramas Tipo Funcin .................................................................................................... 9
2.2.
Parmetros y Variables ......................................................................................................... 16
3.
ARREGLOS ................................................................................................................... 21
3.1.
Vectores ................................................................................................................................ 21
3.2.
Matrices................................................................................................................................. 53
3.3.
Arreglos de Registros ............................................................................................................ 77
4.
SISTEMAS NUMRICOS ................................................................................................ 84
4.1.
Sistemas Numricos Pesados y Conversiones....................................................................... 84
4.2.
Representacin de Datos en un Computador ....................................................................... 89
5.
EVALUACIN DE ALGORITMOS .................................................................................... 99
5.1.
Contador de Frecuencias..................................................................................................... 100
5.2.
Orden de Magnitud ............................................................................................................. 104
5.3.
Pistas de Aprendizaje .......................................................................................................... 115
5.4.
Referencias Bibliogrficas ................................................................................................... 118

Algoritmos II
Pg. 7
1. MAPA DE LA ASIGNATURA
ALGORITMOS II
PROPSITO GENERAL DEL MDULO

Que el estudiante pueda identificar las diferentes estructuras de almacenamiento, as como
tambin las diferentes bases de sistemas numricos, y aplicarlas de forma ptima en la
solucin de problemas.
OBJETIVO GENERAL
Dar al estudiante nuevas herramientas para el desarrollo de algoritmos aplicables en
cualquier disciplina, que permitan la generacin de una capacidad analtica y creativa en la
solucin e implementacin de problemas propuestos.
OBJETIVOS ESPECFICOS
Reconocer cundo hacer uso de un subprograma, y qu tipo de subprograma utilizar.
Identificar las diferentes estructuras estticas de almacenamiento de informacin, de una o
ms dimensiones.
Conocer las diferentes bases de sistemas numricos, y la representacin de datos dentro de
un computador.
Medir la eficiencia de los algoritmos en cuanto a tiempo de ejecucin y en cuanto a consumo
de memoria.
UNIDAD 1
UNIDAD 2
UNIDAD 3
UNIDAD 4
SUBPROGRAMAS
ARREGLOS
SISTEMAS NUMRICOS
EVALUACIN DE
ALGORITMOS
Capacidad
para
identificar cundo
utilizar
subprogramas para
realizar algoritmos
ms compactos.
Habilidad
para
manejar variables
compuestas cuando
se tiene un gran
volumen
de
informacin.
Capacidad
para
manejar operaciones
aritmticas
en
diferentes sistemas
numricos pesados.
Habilidad
para
realizar algoritmos
que
consuman
menos recursos en
un computador.

Algoritmos II
Pg. 8
2. SUBPROGRAMAS
OBJETIVO GENERAL
Reconocer cundo hacer uso de un subprograma, y qu tipo de subprograma utilizar.
Identificar los subprogramas tipo funcin, su estructura y en qu momento invocarlos.
Diferenciar los tipos de subprogramas, eligiendo el que mejor se acomode en cada
problema.
Reconocer lo que son parmetros por valor y parmetros por referencia, as como
variables locales y variables globales.
Prueba Inicial
1. Qu es un subprograma?
2. Cmo identifico que hay que elaborar un subprograma?
3. Dnde se invocan los subprogramas?
SUBPROGRAMAS
La solucin de problemas complejos se facilita considerablemente si se divide en problemas ms
pequeos. La solucin de estos problemas pequeos se realiza con pequeos algoritmos que se
denominan subprogramas y cuya ejecucin depende de un programa principal. Los subprogramas
son unidades de programa que estn diseados para ejecutar una tarea especfica. Estos
subprogramas pueden ser de tipo funcin o de tipo void, los cuales se escriben slo una vez, pero
pueden ser referenciados en diferentes partes del programa principal evitando as la duplicidad de
instrucciones en un mismo programa.
Un subprograma puede ser invocado tantas veces como se necesite y, a su vez, los subprogramas
pueden invocar a otros subprogramas, como puede verse en la siguiente figura:

Algoritmos II
Pg. 9
2.1. Subprogramas Tipo Funcin

Los subprogramas son algoritmos que se elaboran de forma independiente y que tienen la
caracterstica de que se pueden invocar desde cualquier programa cuando se necesiten. El
objetivo principal de utilizar subprogramas es elaborar algoritmos ms cortos, menos complejos,
ms legibles y ms eficientes.
La caracterstica principal de un subprograma tipo funcin es que retorna un valor a la variable
desde la cual fue invocada en el programa principal, por eso es necesario definir nuestro
subprograma del mismo tipo que la variable desde la cual se invoc. Su forma general es:
1. tipo nombre subprograma (parmetros)
2.
Definicin Variables:
3.
INICIO
4.
Cuerpo de la funcin
5.
FININICIO
6.
RETORNE (valor)
7. FIN

Algoritmos II
Pg. 10
Ejemplo:
En el tema de anlisis combinatorio (conteo) es importante determinar el nmero de
combinaciones que se pueden construir con n elementos, tomados en grupos de a r elementos.
Por ejemplo, si tenemos tres elementos a, b, y c, y queremos formar combinaciones de dos
elementos, las posibles combinaciones son ab, ac y bc.
El total de combinaciones de tres elementos (n==3) tomando de a dos elementos (r==2) es tres.
Si el nmero de elementos es cuatro (n==4) a, b, c y d, las combinaciones posibles tomando de a
dos elementos (r==2) son ab, ac, ad, bc, bd y cd; es decir, seis posibles combinaciones.
Para determinar el total de combinaciones de n elementos tomados en grupos de a r elementos se
tiene una frmula matemtica que se escribe as:
La cual se lee: el total de combinaciones de n elementos tomados en grupos de a r elementos es el

factorial de n dividido por el producto del factorial de r con el factorial de n r.
Si nuestro objetivo es elaborar un algoritmo en el cual se lean los datos de n y r, y calcular el
nmero de combinaciones que se pueden construir, debemos definir una variable para el factorial
de n, otra para el factorial de r y otra para el factorial de n r. Llamaremos a estas variables fn, fr y
fnr.
Hagamos un algoritmo para ejecutar esta tarea: leer dos datos enteros n y r, y calcular e imprimir
el total de combinaciones que se pueden construir con n elementos tomados en grupos de a r
elementos:

Algoritmos II
Pg. 11
1. ALGORITMO COMBINACIONES(1)
2.
VARIABLES: i, n, r, fn, fr, fnr, tc (ENTEROS)
3.
INICIO
4.
IMPRIMA (Ingrese el nmero de elementos que desea combinar)
5.
LEA (n)
6.
IMPRIMA (Ingrese de cunto desea el grupo de combinaciones)
7.
LEA (r)
8.
fn = 1
9.
PARA ( i = 1, n, 1)
10.
fn = fn * i
11.
FINPARA
12.
fr = 1
13.
PARA ( i = 1, r, 1)
14.
fr = fr * i
15.
FINPARA
16.
fnr = 1
17.
PARA ( i = 1, (n r), 1)
18.
fnr = fnr * i
19.
FINPARA
20.
tc = fn / (fr * fnr)
21.
IMPRIMA (Total de combinaciones:, tc)
22.
FININICIO
23. FIN
En este algoritmo las instrucciones 8 a 11, 12 a 15 y 16 a 19 son exactamente las mismas, la nica
diferencia es que actan sobre diferentes datos.
Las instrucciones 8 a 11 trabajan con las variables fn y n, las instrucciones 12 a 15 con las variables
fr y r, y las instrucciones 16 a 19 con las variables fnr y el resultado de n r.
Esta situacin, en la cual tenemos un grupo de instrucciones que se repiten en diferentes partes
del programa con datos diferentes, amerita una herramienta que nos permita obviar estas
repeticiones.
Veamos cmo pudimos haber escrito nuestro algoritmo si tuviramos un subprograma que
determine el factorial de un nmero entero cualquiera:

Algoritmos II
Pg. 12
2.
VARIABLES: n, r, fn, fr, fnr, tc (ENTEROS)
3.
INICIO
4.
5.
LEA (n)
6.
7.
LEA (r)
8.
fn = FACTORIAL (n)
9.
fr = FACTORIAL (r)
10.
fnr = FACTORIAL (n r)
11.
12.
IMPRIMA (Total de combinaciones:, tc)
13.
FININICIO
14. FIN
En este nuevo algoritmo hemos reemplazado las instrucciones 8 a 11 por una sola instruccin:
fn = FACTORIAL (n)
Las instrucciones 12 a 15 por una sola instruccin:
fr = FACTORIAL (r)
Y las instrucciones 16 a 19 por una sola instruccin:
Como se puede ver, el algoritmo (2) de combinaciones es ms compacto y ms legible que el
algoritmo (1) de combinaciones.
Hemos hecho uso de un subprograma que llamamos FACTORIAL, el cual calcula y retorna el
factorial de un nmero entero que se enva a este subprograma.
Veamos cmo es este subprograma:

Algoritmos II
Pg. 13
1. ENTERO FACTORIAL (m)

2.
DV: i, f (ENTEROS)
3.
INICIO
4.
f=1
5.
PARA ( i = 1, m, 1)
6.
f=f*i
7.
FINPARA
8.
RETORNE (f)
9.
FININICIO
10. FIN
En la instruccin 1 definimos el nombre del subprograma y lo precedemos con la palabra ENTERO,

la cual indica que este subprograma retorna un valor numrico de tipo entero. En esta misma
instruccin 1 definimos una variable m, la cual ser la variable que recibe el dato con el que
trabajar el subprograma.
En la instruccin 2 definimos las variables propias que necesita el subprograma para poder
ejecutar los clculos que se necesitan.
Las instrucciones 4 a 7 son las instrucciones propias para calcular el factorial de un nmero m.
En la instruccin 8 se retorna el valor que fue calculado para el dato m.
EJERCICIOS
Elaborar un subprograma tipo funcin que encuentre Xy por multiplicaciones sucesivas.
Elaborar un subprograma que reciba un nmero y determine si dicho nmero es perfecto o no.
Un nmero N es perfecto si la suma de todos sus divisores, excepto por l mismo, da N.
Elaborar un algoritmo que lea dos nmeros N y M, donde N<M, e invoque dos subprogramas: uno
que sume los nmeros entre N y M, y otro calcule el promedio entre ellos.
Tema 2: SUBPROGRAMAS TIPO VOID

Hemos visto un tipo de subprogramas llamados funciones, que son aquellos que retornan un valor.
Ahora veamos otro tipo de subprogramas que no retornan valores, sino que slo ejecutan tareas.
Este tipo de subprogramas, que slo ejecutan una tarea, se denominan tipo void.
La forma general de nuestros subprogramas tipo void ser:

Algoritmos II
Pg. 14
1. VOID nombre subprograma (parmetros)

2.
Definicin Variables:
3.
INICIO
4.
Cuerpo del subprograma
5.
FININICIO
7. FIN
Ejemplo:
Es muy comn, en muchas actividades, colocar encabezados que siempre tendrn los mismos
ttulos, y cuyos datos son siempre los mismos o la variacin es mnima.
Para no tener que escribir en cada algoritmo las mismas instrucciones de escritura podemos
elaborar un subprograma tipo void que efecte esta tarea.
Por ejemplo, supongamos que los ttulos son:
INGENIERA DE SISTEMAS
ALGORITMOS II
ALGORITMO: nombre del algoritmo
En donde la parte subrayada corresponde a un dato que se enviar como parmetro.
El algoritmo sera:
1. VOID TITULOS (nombre)
2.
INICIO
3.
IMPRIMA (CORPORACIN UNIVERSITARIA REMINGTON)
4.
IMPRIMA (ESCUELA DE CIENCIAS BSICAS E INGENIERA)
5.
IMPRIMA (INGENIERA DE SISTEMAS)
6.
IMPRIMA (ALGORITMOS II)
7.
IMRPIMA (ALGORITMO:, nombre)
8.
FININICIO
9. FIN
Ntese que este subprograma no utiliza variables propias, por ello no hay necesidad de hacer la
definicin de variables.

Algoritmos II
Pg. 15
En la primara instruccin definimos el nombre del subprograma, el cual llamamos TITULOS, y le

definimos un parmetro, llamado nombre, en el que se recibe el nombre del algoritmo cuyo ttulo
desea imprimir.
Ese dato que se recibe como parmetro lo imprimimos en la instruccin 7.
Las instrucciones 3, 4, 5 y 6 simplemente escriben los mensajes correspondientes a los ttulos que
se desean imprimir.
Teniendo estos subprogramas, FACTORIAL (m) y TTULOS (nombre), podremos escribir nuestro
algoritmo combinaciones as:
2.
VARIABLES: n, r, fn, fr, fnr, tc (ENTEROS)
3.
INICIO
4.
5.
LEA (n)
6.
7.
LEA (r)
8.
TITULOS (combinaciones)
9.
fn = FACTORIAL (n)
10.
fr = FACTORIAL (r)
11.
12.
13.
IMPRIMA (n=, n, r=, r, total de combinaciones=, tc)
14.
FININICIO
15. FIN
Al ejecutar este algoritmo con los datos 5 y 3, para n y r respectivamente, el resultado de la
ejecucin sera:
INGENIERA DE SISTEMAS
ALGORITMOS II
ALGORITMO: combinaciones
n=5
r=3
total de combinaciones = 10

Algoritmos II
Pg. 16
EJERCICIOS
Elaborar un subprograma tipo void que reciba como parmetros de entrada 3 valores diferentes y
los ordene en forma descendente.
Elaborar un subprograma tipo void que encuentre los primeros N nmeros perfectos.
Elabore un subprograma tipo void que obtenga el inters generado por X pesos que se invierte a
Y por ciento mensual en un perodo de N meses.
2.2. Parmetros y Variables

Cuando se construyen subprogramas, stos requieren datos para poder ejecutarlos. Estos datos
hay que suministrarlos al subprograma usando otras variables. Estas variables reciben el nombre
de parmetros. Adicionalmente, el subprograma requiere manejar otra serie de datos, bien sea
definidos dentro del subprograma o tomados del programa principal. Todo lo anterior nos lleva a
definir lo que son los conceptos de parmetros por valor, parmetros por referencia, variables
locales y variables globales.
Como vimos anteriormente, en una funcin, el tipo de dato que retorna puede ser entero, real,
alfanumrico, etc.
En el ejemplo de factorial, el tipo que definimos para la funcin fue entero, ya que el dato que
retorna es un nmero entero.
El llamado de la funcin debe estar en una instruccin de asignacin.
El llamado de un subprograma tipo void es simplemente una en la cual se hace referencia al
nombre del subprograma, con sus respectivos parmetros.
VARIABLES LOCALES Y VARIABLES GLOBALES
Dentro de un subprograma se pueden definir nuevas variables. Las variables que se definen dentro
del subprograma se denominan variables locales y slo existirn mientras se est ejecutando el
subprograma; cuando termina la ejecucin del subprograma dichas variables desaparecen.
Si dentro del subprograma se utilizan variables definidas por fuera del subprograma, stas se
llaman variables globales.
Los datos necesarios para la ejecucin de un subprograma se denominan parmetros formales.

Algoritmos II
Pg. 17
PARMETROS DE UN SUBPROGRAMA
Los parmetros, por lo general, son datos de entrada de un subprograma, aunque tambin puede
haber parmetros de entrada y salida, o slo de salida. Los parmetros de entrada se denominan
parmetros por valor. Los parmetros de entrada y salida, o slo de salida, se denominan
parmetros por referencia.
Cuando se define un subprograma hay que especificar cules parmetros son por valor y cules
parmetros son por referencia.
Elaboremos un ejemplo para mostrar la diferencia entre parmetros por valor y parmetros por
referencia:
1. ALGORITMO PARMETROS
2.
VARIABLES: a, b, c (ENTEROS)
3.
INICIO
4.
IMPRIMA (Ingrese tres nmeros)
5.
LEA (a, b, c)
6.
DEMO (a, b, c)
7.
IMPRIMA (a, b, c)
8.
FININICIO
9. FIN
1. VOID DEMO (por valor: x, y; por referencia: z)

2.
INICIO
3.
x=x+3
4.
y=y*x
5.
z=x+y
6.
IMPRIMA (x, y, z)
7.
FININICIO
8. FIN
En el algoritmo que hemos llamado PARMETROS, se definen tres variables enteras a, b y c,

las cuales vamos a suponer que se hallan en las posiciones 5, 6 y 7 de memoria,
respectivamente, como veremos ms adelante.

Algoritmos II
Pg. 18
En el subprograma DEMO se definen tres parmetros x, y, z. Los parmetros x, y se definen

por valor, z por referencia. Supongamos que estos tres parmetros x, y, z se almacenan en
las posiciones de memoria 19, 20 y 21, respectivamente.
Al ejecutar la instruccin 5 del algoritmo PARMETROS, se leen tres datos para a, b y c,
digamos 2, 8 y 9. Estos datos quedan almacenados en las posiciones de memoria 5, 6 y 7.
Al ejecutar la instruccin 6, la cual invoca al subprograma DEMO, sucede lo siguiente: x e y fueron
definidos parmetros por valor, por lo tanto el contenido de las variables a y b se copia hacia las
posiciones de memoria correspondientes a x e y; z fue definido por referencia, lo cual implica que
lo que se copia en la posicin de memoria z es la posicin de memoria en la cual se halla
almacenada la variable c.
MEMORIA
PARMETROS
DEMO
2
a
2
x
19
8
b
8
y
20
7
21
Estado de la memoria cuando se invoca el subprograma

Al ejecutarse el subprograma DEMO, sucede lo siguiente: en la instruccin 3 se le suma 3 a x, y el
resultado se almacena en la misma posicin de memoria x; en la instruccin 4 se multiplica y por x
y el resultado se almacena en la misma posicin de memoria y; y en la instruccin 5 sumamos x
con y, y almacenamos el resultado en z. Pero qu es z?: z es una posicin de memoria: la
direccin de memoria 7; por lo tanto el resultado de sumar el contenido de x con el contenido de y
se almacena en la posicin de memoria 7. Es como si desde dentro del subprograma hubiramos
tenido acceso a la variable c, definida en el programa principal.

Algoritmos II
Pg. 19
El resultado de efectuar estas operaciones se refleja en la siguiente figura:

MEMORIA
PARMETROS
DEMO
2
a
x
8
19
40
6
45
20
7
21
Estado de la memoria despus de ejecutar el subprograma

Al ejecutar la instruccin 6 del subprograma DEMO, imprime 5, 40 y 45.
Al ejecutar la instruccin 7 del algoritmo PARMETROS, imprime 2, 8 y 45.
EJERCICIOS
Elabore las pruebas de escritorio respectivas a cada uno de los ejercicios de subprogramas tipo
funcin e identifique las variables locales y las variables globales.
Elabore las pruebas de escritorio respectivas a cada uno de los ejercicios de subprogramas tipo
void e identifique los parmetros por valor y los parmetros por referencia.

Algoritmos II
Pg. 20
Prueba Final
1. Considere el siguiente subprograma:
1. VOID MISTERIO (m, i, k)
2.
t=m
3.
s = 10
4.
MQ (t > 0)
5.
j=t%s
6.
k=k*s+j
7.
t=t/s
8.
i=i+1
9.
FINMQ
10. FIN
Y el siguiente programa principal:
n = 675
u=0
r=0
MISTERIO (n, u, r)
IMPRIMA (n, u, r)
Haga una prueba de escritorio detallada al programa principal y al subprograma indicando
claramente qu se imprime en el programa principal.

Algoritmos II
Pg. 21
3. ARREGLOS
OBJETIVO GENERAL
Identificar las diferentes estructuras estticas de almacenamiento de informacin, de una o ms
dimensiones.
Construir arreglos de una dimensin, as como las operaciones de insercin, borrado,
bsqueda y ordenamiento.
Manipular arreglos de dos dimensiones e igualmente las diferentes operaciones que se
pueden realizar con ellos.
Definir que son arreglos de registros y cmo utilizarlos para mantener cierta informacin
en un mismo espacio de memoria.
Prueba Inicial
1.
2.
3.
4.
5.
Qu es un vector?
Qu es una matriz?
Qu es un registro?
Qu es un archivo?
Qu es un subndice?
3.1. Vectores
Un vector es una coleccin finita, homognea y ordenada de datos del mismo tipo que se
almacenan en posiciones consecutivas de memoria y que reciben un nombre en comn. Para
referirse a un determinado elemento de un vector se debe utilizar un subndice que especifique su
posicin en el arreglo.
Veamos la representacin de un vector:

Algoritmos II
Pg. 22
ndice o posicin
Nombre del
Vector
........
Datos
Para situarnos en una posicin especfica dentro de un vector; primero nombramos a nuestro
vector, seguido del nmero de la posicin en la cual nos ubicaremos, as: vec[k]; siendo vec el
nombre de nuestro vector, y k la posicin en l.
Por ejemplo un vector con nombres:
vnom
1
Ana
2
Pedro
3
Luis
4
Ral
5
Mara
6
Jos
vnom [1] = Ana

vnom[2] = Pedro
vnom[3] = Luis
vnom[4] = Ral
vnom[5] = Mara
vnom[6] = Jos
Existen 3 casos para almacenar informacin en un vector:
1. Cuando el tamao del vector es constante
2. Cuando el tamao del vector est dado por N
3. Cuando se desconoce el tamao del vector

Algoritmos II
Pg. 23
Tamao constante
1. ALGORITMO VECTOR_CONSTANTE
2.
VARIABLES: vnom[] (ALFANUMRICO)
i (ENTERO)
3.
INICIO
4.
PARA (i= 1, 10, 1)
5.
IMPRIMA (Ingrese nombre)
6.
LEA (vnom[i])
7.
FINPARA
8.
PARA (i= 1, 10, 1)
9.
IMPRIMA (vnom[i])
10.
FINPARA
11.
FININICIO
12. FIN
Tamao N
1. ALGORITMO VECTOR_N
2.
VARIABLES: vnom[] (ALFANUMRICO)
i, n (ENTERO)
3.
INICIO
4.
IMPRIMA (Tamao del vector)
5.
LEA (n)
6.
PARA (i= 1, n, 1)
7.
8.
LEA (vnom[i])
9.
FINPARA
10.
PARA (i= 1, n, 1)
11.
IMPRIMA (vnom[i])
12.
FINPARA
12.
FININICIO
14. FIN

Algoritmos II
Pg. 24
Tamao desconocido
1. ALGORITMO VECTOR_DESCONOCIDO
2.
VARIABLES: vnom[], nom (ALFANUMRICO)
n (ENTERO)
3.
INICIO
4.
n=0
5.
6.
LEA (nom)
7.
MQ (nom != xx)
8.
n=n+1
9.
vnom[n] = nom
10.
11.
LEA (nom)
12.
FINMQ
13.
PARA (i= 1, n, 1)
14.
IMPRIMA (vnom[i])
15.
FINPARA
16.
FININICIO
17. FIN
Ejemplo:
Consideramos la situacin de que se hizo un censo en la ciudad de Medelln y que se grab en
archivo en disco, llamado censo, el cual contiene la siguiente informacin en cada registro:
municipio, direccin y nmero de personas. Cada registro contiene los datos correspondientes a
cada vivienda visitada.
Interesa procesar el archivo y calcular el total de personas que viven en Medelln
Definimos las siguientes variables:
mpio: variable en la cual se almacena el cdigo del municipio.
dir: variable en la cual se almacena la direccin de la vivienda visitada.
np: variable en la cual se almacena el nmero de personas de la vivienda visitada.
acmed: variable en la cual llevaremos el acumulado de las personas que viven en Medelln.
Un algoritmo para procesar el archivo censo es el siguiente:

Algoritmos II
Pg. 25
1. ALGORITMO CENSO_MEDELLIN
2.
VARIABLES: mpio, acmed, np (ENTEROS)
dir: alfanumrica
3.
INICIO
4.
acmed = 0
5.
ABRA (censo)
6.
MQ (NOT EOF(censo))
7.
LEA (censo: mpio, dir, np)
8.
acmed = acmed + np
9.
FINMQ
10.
CIERRE (censo)
11.
IMPRIMA (Personas que viven en Medelln, acmed)
12.
FININICIO
13. FIN
Si el censo se hace en dos municipios (Medelln y bello), y los cdigos asignados a los municipios
son:
Mpio:
1. Medelln (acmed)
2. Bello (acbel)
Un algoritmo para procesar el archivo censo e imprimir el total de habitantes de cada municipio
es:
1. ALGORITMO CENSO_MEDELLIN_BELLO
2.
VARIABLES: mpio, acmed, acbel, np: (ENTEROS)
dir: (ALFANUMRICAS)
3.
INICIO
4.
ABRA(censo)
5.
acmed = 0
6.
acbel = 0
7.
MQ (NOT EOF(censo))
8.
LEA(censo: mpio, dir, np)
9.
SI (mpio = 1)
10.
acmed = acmed + np
11.
SINO
12.
acbel = acbel + np
13.
FINSI
14.
FINMQ
15.
IMPRIMA(habitantes Medelln:, acmed, habitantes Bello:, acbel)

Algoritmos II
Pg. 26
16.
CIERRE(censo)
17.
FININICIO
18. FIN
Observe que en este algoritmo ya necesitamos dos acumuladores: uno para el total de habitantes
en Medelln (cmed) y otro para el total de habitantes de bello (cbel).
Si el censo hubiera sido para Medelln, Bello, Itag y Envigado; se le asigna un cdigo a cada
municipio:
Mpio:
1. Medelln: (acmed)
2. Bello: (acbel)
3. Itag: (acita)
4. Envigado: (acenv)
Nuestro algoritmo es:

1. ALGORITMO CENSO_ANTIOQUIA
2.
VARIABLES: mpio, acmed, acbel, acita, acenv, np (ENTEROS)
dir (ALFANUMRICO)
3.
INICIO
4.
ABRA(censo)
5.
acmed = 0
6.
acbel = 0
7.
acita = 0
8.
acenv = 0
9.
MQ (NOT EOF(censo))
10.
LEA(censo: mpio, dir, np)
11.
CASOS
12.
CASO (mpio == 1)
13.
acmed = acmed + np
14.
SALTE
15.
CASO (mpio == 2)
16.
acbel = acbel + np
17.
SALTE
18.
CASO (mpio == 3)
19.
acita = acita + np
20.
SALTE

Algoritmos II
Pg. 27
21.
CASO (mpio == 4)
22.
acenv = acenv + np
23.
SALTE
24.
FINCASOS
25.
FINMQ
26.
CIERRE(censo)
27.
IMPRIMA (habitantes Medelln:, acmed, habitantes bello:, acbel)
28.
IMPRIMA (habitantes Itag:, acita, habitantes envigado:, acenv)
29.
FININICIO
30. FIN
Observe que en este nuevo algoritmo ya se necesita cuatro acumuladores: uno por cada municipio
que se procese.
Si el censo hubiera sido para los 125 municipios del departamento, se requeriran 125
acumuladores: uno para cada municipio. Tendramos que manejar 125 variables, nuestra
instruccin CASOS sera muy extensa y el algoritmo sera completamente imprctico, ya que cada
vez que vare el nmero de municipios debemos modificar nuestro algoritmo.
SOLUCIN AL PROBLEMA. CONCEPTO DE VECTOR
Presentaremos una solucin alterna utilizando una estructura arreglo en la cual definimos un rea
de memoria con cierto nmero de posiciones, e identificamos cada posicin con un nmero
entero.
Veamos dicha estructura:
Acmpio
1 2 3 4 5 6 7 8 9 10 11 12 13 14
3 1 6 28 9 4 5 7 6 3 2 7 5 8
Nuestra estructura la hemos llamado acmpio y tiene una capacidad de catorce elementos.
Para referirnos a algn elemento lo hacemos con el nombre de la estructura y un subndice que
indique la posicin de dicho elemento.
Si nuestra estructura tiene los datos que se muestran y queremos imprimir el dato que se halla la
posicin 4 escribimos:

Algoritmos II
Pg. 28
IMPRIMA (acmpio [4])

Y el resultado de ejecutar esta instruccin ser mostrar el nmero 28.
Dicha estructura se conoce como un arreglo de una dimensin y en el contexto de algoritmos se
denomina vector.
En general, para referirnos al contenido de una posicin lo hacemos con el nombre del vector y un
entero que se refiere a la posicin. Dicho entero lo escribimos entre corchetes y lo seguimos
llamado subndice.
Para trabajar con un vector, lo primero que se debe hacer es construir el vector. Para ilustrar dicha
construccin consideremos el siguiente algoritmo, que llamaremos censo, el cual es una variacin
del algoritmo desarrollado anteriormente:
1. ALGORITMO CENSO
2.
VARIABLES: mpio, np, sum, acmpio[125] (ENTEROS)
dir (ALFANUMRICA)
3.
INICIO
4.
ABRA(censo)
5.
PARA (i= 1, 125, 1)
6.
acmpio[i] = 0
7.
FINPARA
8.
MQ (NOT EOF(censo))
9.
LEA(censo:mpio, dir, np)
10.
acmpio[mpio] = acmpio[mpio] + np
11.
FINMQ
12.
CIERRE(censo)
13.
IMPRIME_VECTOR (acmpio, 125)
14.
sum = SUMAR_VECTOR (acmpio, 125)
15.
IMPRIMA (sum)
16.
FININICIO
17. FIN
En este nuevo algoritmo ya no utilizamos una variable para cada acumulador que se necesite
manejar sino que definimos una sola variable, la cual llamamos acmpio, que tiene caractersticas
de vector, y tendr 125 posiciones. Este tamao (125 posiciones) se define con base en el
conocimiento que se tiene acerca del problema que se va a resolver. En nuestro ejemplo debemos
manejar el total de habitantes de cada uno de los 125 municipios que tiene el departamento y por

Algoritmos II
Pg. 29
tanto el vector de acumuladores deber tener este tamao. Esta definicin aparece en la
instruccin 2 del algoritmo CENSO.
Definimos la variable acmpio con una capacidad de 125 elementos.
En las instrucciones 5 a 7 inicializamos cada una de esas posiciones en cero.
En la instruccin 10 de dicho algoritmo se configura cada una de las posiciones del vector acmpio,
sumndole a la posicin mpio el nmero de personas que se lee en cada registro.
En la instruccin 13 invocamos un subprograma llamado IMPRIME_VECTOR, con el cual
recorremos e imprimimos los datos del vector que se ha construido.
En la instruccin 15 invocamos un subprograma llamado SUMAR_VECTOR, con el cual se suman
todos los datos que se hallan en las diferentes posiciones del vector.
Ya hemos visto en nuestro algoritmo anterior que cuando se termina la construccin de un vector
interesa conocer cul es el valor almacenado en cada una de las posiciones del vector. Para
efectuar esta tarea invocamos un subprograma denominado IMPRIME_VECTOR; el cual veremos a
continuacin:
1. VOID IMPRIME_VECTOR (V, n)
2.
VARIABLES: i (ENTERO)
3.
INICIO
4.
PARA (i= 1, n, 1)
5.
IMPRIMA (i, V[i])
6.
FINPARA
7.
FININICIO
8. FIN
Este programa es bastante simple: los parmetros son el nombre del vector y el tamao del
vector.
Solo se requiere una variable local para recorrer las diferentes posiciones del vector. A dicha
variable la llamamos i.
En instrucciones 4 a 6 escribimos un ciclo PARA, con el cual nos movemos en el vector desde la
posicin 1 hasta la posicin n, imprimiendo el subndice y el contenido de dicha posicin.

Algoritmos II
Pg. 30
SUMA DE LOS DATOS DE UN VECTOR

Es tambin muy frecuente determinar el total de los datos almacenados en un vector. Para ello
definimos un subprograma funcin, al cual llamamos SUMAR_VECTOR, que efectu esta suma y
retorne el resultado de ella al programa principal:
1. ENTERO SUMAR_VECTOR (V,n)
2.
VARIABLES: i, s( ENTEROS)
3.
INICIO
4.
s=0
5.
PARA (i= 1, n, 1)
6.
s = s + V[i]
7.
FINPARA
8.
RETORNE (s)
9.
FININICIO
10. FIN
Este programa es tambin bastante simple. Tiene como parmetros de entrada el nombre del
vector y el nmero de elementos en l.
Se requieren dos variables locales: una para recorrer el vector y otra en el cual se maneje el
acumulado. A dichas variables las llamamos i y s, respectivamente.
Es la instruccin 4 se inicializa el acumulador s en cero.
En instrucciones 5 a 7 escribimos nuestro ciclo de recorrido, y en vez de imprimir le contenido de
cada posicin, lo acumulamos en la variable llamada s.
En la instruccin 8 se retorna el contenido de s al programa llamante.
OPERACIONES BSICAS: MAYOR DATO Y MENOR DATO EN EL VECTOR
Ya hemos visto que en un vector se almacenan los datos correspondientes a un conjunto de
situaciones o eventos. Es importante conocer la situacin o evento que ms veces se presenta.
Para lograr esto hay que elaborar un algoritmo que determine o identifique la posicin en la cual
se halla la situacin que ms veces ocurre.
A continuacin presentamos un subprograma tipo funcin, que retorna en una variable la posicin
en donde se encuentra el mayor de los datos almacenados en el vector:

Algoritmos II
Pg. 31
1. ENTERO MAYOR_DATO (V, m)

2.
VARIABLES: mayor, i (ENTEROS)
3.
INICIO
4.
mayor = 1
5.
PARA (i= 2, m, 1)
6.
SI (V[i] > V[mayor])
7.
mayor = i
8.
FINSI
9.
FINPARA
10.
RETORNE (mayor)
11.
FININICIO
12. FIN
Para ilustrar como funciona este algoritmo consideremos el siguiente grfico:

m=7
V
1
3
2
1
3
6
4
2
5
8
6
9
7
4
En la instruccin 2 se define dos variables: mayor, para almacenar la posicin en la cual se halla el
dato mayor, e i, para recorrer el vector e ir comparando el dato de la posicin i con el dato de la
posicin mayor.
En la instruccin 4 se inicializa la variable mayor en 1, definiendo que el dato mayor se halla en
dicha posicin.
En la instruccin 5 se plantea el ciclo con el cual se recorre el vector desde la posicin 2 hasta la
posicin m.
En la instruccin 6 se compara el dato de la posicin i con el dato de la posicin mayor. Si el dato
que est en la posicin i es mayor que el dato que est en la posicin mayor se actualiza el
contenido de la variable mayor en la instruccin 7.
Al terminar el ciclo, cuando la i es mayor que la m, en la variable mayor estar almacenada la
posicin en la cual se halla el mayor dato del vector.
Para nuestro ejemplo, mayor se inicializara en 1, lo cual significa que el mayor dato est en la
posicin 1 del vector V, es decir, el mayor dato es V[mayor], o sea 3.

Algoritmos II
Pg. 32
Cuando se ejecuta el ciclo, i comienza valiendo 2, o sea que V[i] es 1. Al comparar v[i] con
V[mayor] en la instruccin 6, el resultado es falso, por consiguiente no ejecuta la instruccin 7 y
contina con la instruccin 9, la cual incrementa el valor de i en 1 y regresa a la instruccin 5 a
comparar i con m.
Como i es menor o igual que m, vuelve a ejecutar las instrucciones del ciclo: compara V[i] con
V[mayor], es decir, compara V[3] con V[1]. El dato de la posicin i es mayor que el dato de la
posicin mayor, por tanto ejecuta la instruccin 7, o sea que modifica el contenido de la variable
mayor, el cual ser 3, indicando que el mayor dato se halla en la posicin 3 del vector.
Se llega de nuevo a la instruccin a la instruccin 9 e incrementa la i en 1 (i queda valiendo 4) y
regresa de nuevo a la instruccin 5 a continuacin ejecutando las instrucciones del ciclo hasta que
la i sea mayor que la m.
Cuando la i sea mayor que la m termina la ejecucin del ciclo y en la variable mayor quedara la
posicin en la cual se halla el mayor dato del vector.
Observe que hemos trabajado con las posiciones del vector, ya que con ellas tenemos acceso
directo a los datos que se hallan en dichas posiciones.
En el ejemplo anterior desarrollamos un subprograma en el cual se determina la posicin en la
cual se halla el mayor dato de un vector. Es tambin necesario, en muchas situaciones, determinar
la posicin en la cual se halla el menor dato. A continuacin se presenta un subprograma que
efecta esta tarea:
1. ENTERO MENOR_DATO (V, m)
2.
VARIABLES: menor, i (ENTEROS)
3.
INICIO
4.
menor = 1
5.
PARA (i= 2, m, 1)
6.
SI (V[i] < V[menor])
7.
menor = i
8.
FINSI
9.
FINPARA
10.
RETORNE (menor)
11.
FININICIO
12. FIN
Este algoritmo es similar al algoritmo de determina la posicin en la cual se halla el mayor dato. La
nica diferencia entre este algoritmo y el anterior es que la variable en la cual se retorna el

Algoritmos II
Pg. 33
resultado de la bsqueda se denomina menor, en vez de mayor, y la comparacin de V[i] con

V[menor] se hace con el smbolo menor que (<), en vez del smbolo mayor que (>).
INTERCAMBIAR DOS DATOS EN UN VECTOR
Intercambiar dos datos en un vector es una operacin frecuente en manipulacin de vectores. Por
ejemplo, cuando se desean ordenar los datos de un vector es necesario cambiar los datos de
posicin, y este cambio se hace por parejas. Un algoritmo que efecta dicha tarea es el siguiente:
1. VOID INTERCAMBIAR (V, i, k)
2.
VARIABLES: aux (ENTERO)
3.
INICIO
4.
aux = V[i]
5.
V[i] = V[k]
6.
V[k] = aux
7.
FININICIO
8. FIN
En la instruccin 1 se define el subprograma con sus parmetros: V, el nombre del vector en el
cual se desea hacer el intercambio, e i y k, las posiciones cuyos datos se desean intercambiar.
En la ilustracin 2 se define una variable, llamada aux, que se utilizara para efectuar el
intercambio.
En la instruccin 4 se guarda el contenido de la posicin i del vector en la variable auxiliar aux con
el fin de que dicho dato no se pierda.
En la instruccin 5 se lleva a la posicin i del vector lo que hay en la posicin k del vector.
En la instruccin 6 se lleva lo que hay en la variable auxiliar, es decir, lo que haba en la posicin i
del vector, a la posicin k del vector.
Como ejemplo, consideremos el vector que veremos a continuacin, y que se desea intercambiar
el dato que se halla en la posicin 2 (i == 2) con el dato que se halla en la posicin 5 (k == 5).
1 2 3 4 5 6 7
V 3 1 6 2 8 9 4
Al ejecutar nuestro subprograma INTERCAMBIAR, el vector quedara como se ve en la siguiente
grfica:

Algoritmos II
Pg. 34
1 2 3 4 5 6 7
V 3 8 6 2 1 9 4
PROCESO DE INSERCIN EN UN VECTOR ORDENADO ASCENDENTEMENTE
Si queremos insertar un dato en un vector ordenado ascendentemente, sin daar su
ordenamiento, primero debemos buscar la posicin en la que debemos insertar. Para buscar la
posicin donde vamos a insertar un nuevo dato en el vector ordenado ascendentemente debemos
recorrer el vector e ir comparando el dato de cada posicin con el dato a insertar. Como los datos
estn ordenados ascendentemente, cuando se encuentre en el vector un dato mayor que el que
se va a insertar esa es la posicin en la cual deber quedar el nuevo dato.
Si el dato a insertar es mayor que todos los datos del vector, entonces el dato a insertar quedara
de ltimo.
El algoritmo siguiente ejecuta esta tarea y retorna en la variable i La posicin en la cual debe
quedar el dato a insertar:
1. ENTERO BUSCAR_DNDE_ INSERTAR (V, m, d)
2.
3.
INICIO
4.
i=1
5.
MQ ((i <= m) ^ (V[i] < d))
6.
i=i+1
7.
FINMQ
8.
RETORNE (i)
9.
FININICIO
10. FIN
En la instruccin 1 se define el nombre del programa con sus parmetros: V, variable que contiene
el nombre del vector en el cual hay que efectuar el proceso de bsqueda; m, variable que contiene
el nmero de posiciones utilizadas en el vector; y d, variable que contiene el dato a insertar.
En la instruccin 2 se define la variable i, que es la variable con la que recorre el vector y se va
comparando el dato de la posicin i del vector (V[i]) con el dato a insertar (d).
En la instruccin 4 se inicializa la variable i en 1, ya que esta es la posicin a partir de la cual se
comienza a almacenar los datos.

Algoritmos II
Pg. 35
En la instruccin 5, la instruccin del ciclo, se controlan dos situaciones: una, que no se haya
terminado de comparar los datos del vector, (i <= m), y dos, que el dato de la posicin i sea mayor
que d (V[i] < d).
Si ambas condiciones son verdaderas se ejecutan las construcciones 6 y 7, es decir, se incrementa
la i en 1 y se regresa a la instruccin 5 a evaluar nuevamente las condiciones.
Cuando una de las condiciones sea falsa (i>m o V[i]>=d), se sale del ciclo y ejecuta la instruccin 8,
es decir, retorna al programa llamante el valor de i: la posicin en la cual hay que insertar el dato
d.
Como ejemplo, consideremos el vector de la siguiente figura, y que se desea insertar el nmero 10
(d==10).
m
n
V
11
18
23
36
10
Al ejecutar el algoritmo BUSCAR_DONDE_INSERTAR, este retorna i valiendo 4, es decir, en la

posicin 4 del vector V debe quedar el dato 10.
Ahora veamos Conocimos que el dato debe quedar en una posicin i, veamos cmo se efecta
este proceso. Si el vector no est lleno (m == n), debemos mover todos los datos desde la posicin
i del vector hacia la derecha.
1. VOID INSERTAR (V, m, n, i, d)
2.
VARIABLES: j (ENTERO)
3.
INICIO
4.
SI (m == n)
5.
IMPRIMA (vector lleno)
6.
SINO
7.
PARA (j= m, i, -1)
8.
V[j+1] = V[j]
9.
FINPARA
10.
V[i] = d
11.
m=m+1
12.
FINSI
13.
FININICIO
14. FIN

Algoritmos II
Pg. 36
Es la instruccin 1 se define el subprograma con sus parmetros: V, variable que contiene el

nombre del vector en el cual hay que efectuar el proceso de insercin; m, variable que contiene el
nmero de posiciones utilizadas en el vector; n, tamao del vector; i, variable que contiene la
posicin en la cual se debe insertar el dato contenido en d; y d, variable que contiene el dato a
insertar. Es bueno resaltar que los parmetros V y m deben ser parmetros por referencia,
mientras que n, i y d son por valor.
En la instruccin 2 se define la variable j, la cual se utilizara para mover los datos del vector en
caso de que sea necesario.
En la instruccin 4 se controla que el vector no est lleno. En caso de que el vector este lleno (m
== n), se ejecuta la instruccin 5, la cual produce el mensaje de que el vector est lleno y finaliza el
subprograma sin realizar ms acciones.
En caso de que el vector no est lleno se ejecuta la instruccin 7, en la cual se plantea la
instruccin PARA, la cual inicializa el valor de j con el contenido de m, compara el valor de j con el
valor de i y define la forma como variara el de j. la variacin de la variable j ser restndole 1 cada
vez que llegue a la instruccin fin del PARA. Cuando el valor de j sea menor que i se sale del ciclo.
En caso de que el valor inicial de j sea menor q i, no ejecutara la instruccin 8 y continuara con la
instruccin 10.
En la instruccin 8 se mueve el dato que est en la posicin j a la posicin siguiente (j + 1).
En la instruccin 9, que es el fin de la instruccin PARA, disminuye el valor de j, ejecutara
nuevamente las instrucciones 8 y 9, hasta que j sea menor que i.
Cuando se sale del ciclo, ejecuta la instruccin 10, en la cual se asigna a la posicin i del vector el
dato d y continua con la instruccin 11 en la cual se incrementa el valor de m en 1, indicando que
el vector ha quedado con un elemento ms.
Veamos cmo queda nuestro vector despus de haber insertado el dato:
i
V
10
11
18
23
36
n
9
10

Algoritmos II
Pg. 37
PROCESO DE BORRADO EN UN VECTOR

Para borrar un dato primero debemos determinar en qu posicin se encuentra dicho dato. El
proceso para determinar en cual posicin del vector se halla un dato es bastante similar al proceso
de buscar en donde insertar. En el siguiente algoritmo presentamos dicho proceso:
i
1
V
m
5
n
8
10
3 1 6 2 8 9 4
1. ENTERO BUSCAR_POSICION_DATO (V, m, d)

2.
3.
INICIO
4.
i=1
5.
MQ (i <= m) ^ (V[i] != d)
6.
i=i+1
7.
FINMQ
8.
RETORNE (i)
9.
FININICIO
10. FIN
La nica diferencia de este algoritmo con el algoritmo para buscar donde insertar es que la
instruccin MIENTRAS la comparacin de V[i] con d se efecta con el operador diferente (!=) y no
Con el operador menor (<).
Nuestro algoritmo de buscar dato funciona independiente de que los datos se encuentren
ordenados o no. En caso de que el dato a buscar no se halle en el vector, nuestro algoritmo
retorna en la variable i el valor de m + 1, lo cual usaremos como condicin para detectar si el dato
se est buscando se halla en el vector o no. En otras palabras, si i es igual a m + 1 el dato no est
en el vector V.
Como ejemplo, consideremos el siguiente vector, y que deseamos borrar el dato 2:
Al ejecutar nuestro algoritmo BUSCAR_POSICIN_DATO, el contenido de la variable i ser 4; es
decir, en la posicin 4 del vector se halla el dato 2:

Algoritmos II
Pg. 38
Conocimos la posicin i en la cual se halla el dato a borrar, el proceso de borrado implica que hay
que mover todos los datos que se encuentran desde la posicin i + 1 hasta la posicin m una
posicin hacia la izquierda y restarle 1 a m.
En el siguiente algoritmo se efecta dicho proceso:
1. VOID BORRAR (V, m, i)
2.
VARIABLES: j (ENTERO)
3.
INICIO
4.
SI (i > m)
5.
IMPRIMA (El dato no existe)
6.
SINO
7.
PARA (j= i, m, 1)
8.
V[j] = V[j+1]
9.
FINPARA
10.
m=m1
11.
FINSI
12.
FININICIO
13. FIN
m
V
n
8
10
En la instruccin 1 se define el subprograma con sus parmetros: V, variable que contiene el

nombre del vector en el cual hay que efectuar el proceso de borrar; m, variable que contiene el
nmero de posiciones utilizadas en el vector; e i, variable que contiene la posicin del dato a
borrar.
En la instruccin 2 se define la variable j, la cual se utilizara para mover los datos del vector en
caso de que sea necesario.
En la instruccin 4 se controla que el dato a borrar exista en el vector, en caso de que el dato no
exista (i > m) se ejecuta la instruccin 5, la cual produce el mensaje de que el dato no est en el
vector y finaliza sin ejecutar ms acciones.
En caso de que el dato este en el vector se ejecuta la instruccin 7.

Algoritmos II
Pg. 39
En la instruccin 7 se plantea la instruccin PARA, la cual inicializa el valor de j con el contenido de

i, compara el valor de j con el valor de m y define la forma como variara el valor de j. La variacin
de la variable j ser sumndole 1 cada vez que llegue a la instruccin FINPARA. Cuando el valor de j
sea mayor que m se sale del ciclo. En caso de que el valor inicial de j sea mayor que m no ejecutara
la instruccin 8 y continuar con la instruccin 10.
En la instruccin 8 se mueve el dato que est en la posicin j+1 hacia la posicin j.
En la instruccin 9, que es el fin de la instruccin PARA, incrementa el valor de j en 1 y regresa a la
instruccin 7 a comparar el valor de j con m. si j es menor que m, ejecutar nuevamente las
instrucciones 8 y 9, hasta que j sea mayor que m.
m
V
n
7
10
Cuando se sale del ciclo, ejecuta la instruccin 10, en la cual se le resta 1 a m, indicando que el
vector ha quedado con un elemento menos.
Para nuestro ejemplo, al terminar de ejecutar el subprograma BORRAR el vector queda as:
NOTA: Es conveniente, en este punto, hacer notar algo que es muy importante: en la figura
anterior, y solo con fines explicativos, hemos dejado el conjunto de la posicin 7 en blanco,
indicando que se ha borrado un dato. En realidad, en la posicin 7 del vector seguir estando en 4
hasta que se reemplace por otro valor, pero el contenido de m se ha disimulado en 1, lo cual
significa que el dato de la posicin 7 ya no pertenece al vector.
BSQUEDA BINARIA
El proceso de bsqueda binaria utiliza el hecho de que los datos se encuentran ordenados en
forma ascendente. La primera comparacin se hace con el dato de la mitad del vector. Si se tiene
suerte, ese es el dato que se est buscando y no hay que hacer ms comparaciones; si no lo es, es
porque el dato que se est buscando es mayor o menor que el dato de la mitad del vector. Si el
dato que se est buscando es mayor que el dato de la mitad del vector, significa que si el dato se
halla en el vector, est a la derecha del dato de la mitad, o sea que no abra necesidad de comparar
el dato que se est buscando con todos los datos que estn a la izquierda del dato de la mitad del

Algoritmos II
Pg. 40
vector. Luego de que hemos descartado la mitad de los datos, la siguiente comparacin se har
con el dato de la mitad, de la mitad en la cual posiblemente este el dato a buscar. As
continuamos con este proceso hasta que se encuentre el dato, o se detecte que el dato no est en
el vector. Si tuviramos un milln de datos, con una sola comparacin estamos ahorrando 500.000
comparaciones, con la segunda comparacin se ahorran 250.000 comparaciones, con la tercera se
ahorran 125.000 comparaciones y as sucesivamente. Como se puede ver, la reduccin del nmero
de comparaciones es notable.
A continuacin se presenta un algoritmo con el cual se efecta este proceso:
1. ENTERO BSQUEDA_BINARIA (V, n, d)
2.
VARIABLES: li, ls, m (ENTEROS)
3.
INICIO
4.
li = 1
5.
ls = n
6.
MQ (li <= ls)
7.
m = (li + ls) / 2
8.
SI (V[m] == d)
9.
RETORNE (m)
10.
SINO
11.
SI (V[m] < d)
12.
li = m + 1
13.
SINO
14.
ls = m 1
15.
FINSI
16.
FINSI
17.
FINMQ
18.
RETORNE (n + 1)
19.
FININICIO
20. FIN
En la instruccin 1 se define el subprograma bsqueda binaria, cuyos parmetros son: V, en el cual
hay que efectuar la bsqueda; n, el tamao del vector; y d, el dato a buscar.
En la instruccin 2 se definen las variables de trabajo: li, para guardar el lmite inferior del rango en
el cual hay que efectuar la bsqueda; ls, para guardar el lmite superior del rango en el que se
efectuar la bsqueda; y m, para guardar la posicin de la mitad del rango entre li y ls.

Algoritmos II
Pg. 41
En las instrucciones 4 y 5 se asignan los valores inciales a las variables li y ls. Estos valores inciales
son 1 y n, respectivamente, ya que la primera vez el rango sobre el cual hay que efectuar la
bsqueda es desde la primera posicin hasta la ltima del vector.
En la instruccin 6 se plantea el ciclo MIENTRAS_QUE (MQ), con la condicin de que li sea menor o
igual que ls. Es decir, si el lmite inferior (li) es mayor o igual que el lmite superior (ls), an existen
posibilidades de que el dato que se est buscando se encuentre en el vector. Cuando li sea mayor
que ls significa que el dato no est en el vector y retornara n+1.
Cuando la condicin de la instruccin 6 sea verdadera se ejecutan las instrucciones del ciclo.
En la instruccin 7 se calcula la posicin de la mitad entre li y ls, llamamos a esta posicin m.
En la instruccin 8 se compara el dato de la posicin m con el dato d. si el dato de la posicin m es
igual al dato d que se est buscando (V[m] == d), ejecuta la instruccin 9: termina el proceso de
bsqueda retornando m, la posicin en la cual se halla el dato d en el vector.
Si el dato que se encuentra en la posicin m no es el que buscamos, pasamos a la instruccin 11.
En caso de que la condicin de la instruccin 11 sea verdadera, significa que si el dato est en el
vector, se halla a la derecha de la posicin m; por consiguiente, el lmite inferior del rango en el
cual se debe efectuar la bsqueda es m+1, y por tanto ejecuta la instruccin 12 en el cual a la
variable li se le asigna m+1.
Si el resultado de la comparacin de la instruccin 11 es falso, significa que si el dato est en el
vector, se halla a la izquierda de la posicin m; por consiguiente, el lmite superior del rango en el
cual se debe efectuar en la bsqueda es m1, y por tanto ejecuta la instruccin 14 en la cual a la
variable ls se le asigna m1.
Habiendo actualizando el lmite inferior o el lmite superior, se llega a la institucin 17, la cual
retorna la ejecucin a la instruccin 6, donde se efecta de nuevo la comparacin entre li y ls.
Cuando la condicin sea falsa se sale del ciclo y ejecuta la instruccin 18, la cual retorna n+1,
indicando que el dato no se halla en el vector.
Fjese que la nica manera de que se ejecute la instruccin 18 es que no haya encontrado el dato
que se est buscando, ya que si lo encuentra ejecuta la instruccin 9, la cual termina el proceso.
Consideremos, como ejemplo, el siguiente vector, y que se desea buscar el nmero 38 en dicho
vector:

Algoritmos II
Pg. 42
n
V
1
3
2
6
3
7
4
10
5
12
6
18
7
22
8
28
9
31
10
37
11
45
12
52
13
60
14
69
15
73
Al ejecutar nuestro algoritmo de bsqueda binaria, cuando se est en la instruccin 7 por primera
vez, li se situar en 1 y ls en n, como vemos en la siguiente figura:
li
1
3
2
6
3
7
4
10
5
12
6
18
7
22
8
28
ls
9
31
10
37
11
45
12
52
13
60
14
69
15
73
Al ejecutar la instruccin 8, la cual compara el dato de la posicin m (28) con d (38), se determina
que el dato d, si est en el vector, se halla a la derecha de la posicin m, por consiguiente el valor
de li deber ser 9. En constancia, al ejecutar la instruccin 12, el lmite inferior del rango sobre el
cual hay que efectuar la bsqueda es 9, por lo tanto, el rango sobre el cual hay que efectuar dicha
bsqueda es entre 9 y 15.
Al ejecutar el ciclo por segunda vez el valor de m ser 12, como muestra la figura:
li
1
3
2
6
3
7
4
10
5
12
6
18
7
22
8
28
9
31
10
37
11
45
12
52
ls
13
60
14
69
15
73
Luego, al comparar d (38) con V[m] (52), se determina que el dato que se est buscando, si est
en el vector, debe hallarse a la izquierda de m, es decir, entre las posiciones 9 y 11, por
consiguiente el valor de j ser 11 (j = m 1).
Al ejecutar el ciclo por tercera vez, las variables quedarn de la siguiente forma:

Algoritmos II
Pg. 43
li
1
3
2
6
3
7
4
10
5
12
6
18
7
22
8
28
9
31
10
37
ls
11
45
12
52
13
60
14
69
n
15
73
En esta pasada se detecta que el dato debe estar a la derecha de m, por consiguiente el valor de li
deber ser 11, y en consecuencia el valor de m tambin. La situacin en el vector queda as:
li
1
3
2
6
3
7
4
10
5
12
6
18
7
22
8
28
9
31
10
37
m
11
45
ls
12
52
13
60
14
69
n
15
73
En este punto la comparacin de d con V[m] indica que si el dato d est en el vector, debe estar a
la izquierda de m, por tanto el valor de ls ser 10, y al regresar a la institucin 6 y evaluar la
condicin del ciclo (li <= ls), esta ser falsa, por consiguiente termina el ciclo y retorna como
posicin el valor de 16 (n+1), indicando que el 38 no se encuentra en dicho vector.
ORDENAMIENTO POR SELECCIN
Como ya hemos visto, el hecho de trabajar los datos ordenados hace que los algoritmos sean ms
eficientes. Para ejecutar el proceso de ordenamientos se han desarrollado mltiples algoritmos,
buscando que este proceso sea lo ms eficiente posible. Ahora veamos un algoritmo que ordena
los datos de un vector. El mtodo utilizado en este algoritmo se denomina ordenamiento por
seleccin. Este mtodo se enuncia as: de los datos que faltan por ordenar determinar el menor de
ellos y ubicarlo de primero en ese conjunto de datos.
Con base en este enunciado hemos escrito el algoritmo que se presenta a continuacin:

Algoritmos II
Pg. 44
1. VOID ORDENAMIENTO_ASCENDENTE_SELECCIN (V, m)

2.
VARIABLES: i, j, k (ENTEROS)
3.
INICIO
4.
PARA (i= 1, m-1, 1)
5.
k=i
6.
PARA (j= i+1, m, 1)
7.
SI (V[j] < V[k])
8.
k=j
9.
FINSI
10.
FINPARA
11.
INTERCAMBIAR (V, k, i)
12.
FINPARA
13.
FININICIO
14. FIN
NOTA: Si deseamos ordenar el vector de forma descendente, simplemente cambiamos el smbolo
menor que (<) por el de mayor que (>) en la instruccin 7.
En la instruccin 1 se define el subprograma con sus parmetros: V, variable en la cual se
almacena el vector que desea ordenar, y m, el nmero de elementos a ordenar. V es un parmetro
por referencia, ya que se modificar al cambiar de posicin los datos dentro del vector.
En la instruccin 2 se define las variables necesarias para efectuar el proceso de ordenamiento. La
variable i se utiliza para identificar a partir de cual posicin es que faltan datos por ordenar.
Inicialmente el valor de i es 1, ya que inicialmente faltan todos los datos por ordenar y los datos
comienzan en la posicin 1. Cuando el contenido de la variable i sea 2, significa que faltan por
ordenar los datos que hay a partir de la posicin 2 del vector; cuando el contenido de la variable i
sea 4, significa que faltan por ordenar los datos que hay a partir de la posicin 4; cuando el
contenido de la variable i sea m, significa que estamos en el ltimo elemento del vector, el cual
obviamente estar en su sitio, pues no hay ms datos con los cuales se puede comparar. Esta es la
razn por la cual en la instruccin 4 se pone a variar la i desde 1 hasta m1.
En la instruccin 4 se plantea el ciclo de la variable i, que varan desde 1 hasta m1, tal como
explicamos en el prrafo anterior.
En la instruccin 5 se le asigna a k el contenido de la variable i. la variable k se utiliza para
identificar la posicin en la que se halla el menor dato. Inicialmente suponemos que el menor dato
se encuentra en la posicin i del vector, es decir, suponemos que el primero del conjunto de datos
que faltan por ordenar.

Algoritmos II
Pg. 45
En la instruccin 6 se plantea el ciclo con el cual se determina la posicin en la cual se halla el dato
menor del conjunto de datos que faltan por ordenar. En este ciclo se utiliza la variable j, que tiene
un valor inicial de i + 1 y varia hasta m.
En la instruccin 7 se compara el dato que se halla en la posicin j del vector con el dato que se
halla en la posicin k. si el contenido de la posicin j es menor que el contenido de la posicin k, se
actualiza el contenido de la variable k con el contenido de j, de esta manera en la variable k
siempre estar la posicin en la cual encuentra el menor dato.
Al terminar la ejecucin 11 se intercambia el dato que se halla en la posicin k con el dato que se
halla en la posicin i, logrando de esta manera ubicar el menor dato al principio del conjunto de
datos que faltan por ordenar.
Al llegar a la instruccin 12 contina con el ciclo externo incrementado a i, que es a partir de esa
posicin que faltan los por ordenar.
Como ejemplo, consideramos el siguiente vector:
1 2 3 4 5 6
V 3 1 6 2 8 4
Al ejecutar por primera vez las instrucciones 4, 5 y 6 los valores de i, k y j son 1, 1 y 2,
respectivamente, lo cual indica que faltan por ordenar los datos a partir de la posicin 1, en donde
se halla el menor dato de los que faltan por ordenar y se va a comenzar a comparar los datos del
vector, a partir de la siguiente posicin, es decir, 2. Grficamente se presenta esta situacin en la
siguiente figura.
i
1 2 3 4 5 6
V 3 1 6 2 8 4
Al ejecutar la instruccin 7, por primera vez, comparar el dato de la posicin 2 (j == 2) con el dato
de la posicin 1 (k == 1), obteniendo como resultado que la condicin es verdadera; por tanto,
ejecuta la instruccin 8, la cual asigna a k el valor de j, indicando que el menor dato se halla en la
posicin 2 del vector.
Al ejecutar la instruccin 10, incrementa el contenido de j en 1, quedando j con el valor de 3. Esta
nueva situacin se presenta a continuacin.

Algoritmos II
Pg. 46
k j
1 2 3 4
3 1 6 2
5 6
8 4
Se ejecuta de nuevo la instruccin 7 y compara el dato de la posicin 3 con el dato de la posicin 2,

obteniendo como resultado que la condicin es falsa; por tanto, no ejecuta la instruccin 8, y
contina en la instruccin 10, es decir, incrementa nuevamente el contenido de j en 1, la cual
queda valiendo 4.
Se continan ejecutando las instrucciones del ciclo interno (instrucciones 7 a 10), comparando el
contenido de la posicin j del vector con el contenido de la posicin k, obteniendo siempre falso
como resultado, hasta que el contenido de la variable j es 7. Cuando esto sucede, pasa ejecutar la
instruccin 11, en la cual se intercambia el dato que se halla en la posicin i con el dato que se
halla en la posicin k. En este momento el vector se encuentra as:
i
1 2
V 1 3
3 4 5 6
6 2 8 4
El contenido de la posicin 1 lo resaltamos indicando que el dato de esa posicin ya est ubicado
en la posicin que le corresponde.
Contina con la ejecucin de la instruccin 12, en la cual incrementa el contenido de i en 1, y
regresa a continuacin con el ciclo externo. Se asigna nuevamente a k el contenido de i y se
comienza de nuevo la ejecucin del ciclo interno, con valor inicial de j en 3, as
i
1 2 3 4 5 6
V 1 3 6 2 8 4
Al terminar la ejecucin del ciclo interno, por segunda vez, el contenido de la variable k ser 4,
indicando que en esta posicin se encuentra el menor de los datos que faltan por ordenar, es
decir, de los datos que hay a partir de la posicin 2 del vector.

Algoritmos II
Pg. 47
1 2 3 4 5 6
V 1 3 6 2 8 4
Terminando la ejecucin del ciclo interno contina con la instruccin 11 en la cual intercambia el
dato que est en la posicin i (2) con el dato que est en la posicin k (4) del vector. Ahora nuestro
vector se ve as:
i
k
j
1 2 3 4 5
V 1 2 6 3 8
6
4
Aqu resaltamos el contenido de las dos primeras posiciones indicando que esos dos datos ya
estn ordenados y en el sitio que les corresponde.
Al ejecutar la instruccin 12 incrementa la i en 1, indicando que ya faltan por ordenar slo los
datos que se encuentran a partir de la posicin 3, y regresa a ejecutar nuevamente las
instrucciones 5 y 6, en las cuales al valor de k le asigna el contenido de i, y a j la inicializamos en 4.
Vemoslo grficamente:
i
1
V 1
2 3 4 5 6
3 6 2 8 4
El proceso de ordenamiento continuara de esta manera hasta que el valor i sea 6. Cuando el valor
de i es 6 el proceso termina y los datos del vector estn ordenados en forma ascendente.
Finalmente el vector se ver as:
1 2 3 4 5 6
V 1 2 3 4 6 8

Algoritmos II
Pg. 48
ORDENAMIENTO ASCENDENTE POR MTODO BURBUJA

El mtodo de ordenamiento por burbuja consiste en comparar dos datos consecutivos y
ordenarlos ascendentemente, es decir, si el primer dato es mayor que el segundo se intercambia
dichos datos, de lo contrario se dejan tal cual estn. Cualquiera de las dos situaciones que se
hubiera presentado se avanza en el vector para comparar los siguientes dos datos consecutivos.
En general, el proceso de comparaciones es: el primer dato con el segundo, el segundo dato con el
tercero, el tercer dato con el cuarto, el cuarto con el dato quinto, y as sucesivamente, hasta
comparar el penltimo dato con el ltimo. Como resultado de estas comparaciones, y los
intercambios que se hagan, el resultado es que en la ltima posicin quedara el mayor dato en el
vector. La segunda vez se compara nuevamente los datos consecutivos, desde el primero con el
segundo, hasta que se comparan el antepenltimo dato con el penltimo, obteniendo como
resultado que el segundo dato mayor queda de penltimo. Es decir, en cada pasada de
comparaciones, de los datos que faltan por ordenar, se ubica el mayor dato en la posicin que le
corresponde, o sea de ultimo en el conjunto de datos que faltan por ordenar. Veamos el algoritmo
que efecta dicha tarea:
1. VOID ORDENAMIENTO_ASCENDENTE_BURBUJA (V, n)
2.
VARIABLES: i, j (ENTEROS)
3.
INICIO
4.
PARA (i= 1, n-1, 1)
5.
PARA (j= 1, n-i, 1)
6.
SI (V[j] > V[j+1])
7.
INTERCAMBIAR (V, j, j+1)
8.
FINSI
9.
FINPARA
10.
FINPARA
11.
FININICIO
12. FIN
Como ejemplo vamos a considerar el siguiente vector:
1 2 3 4 5 6
V 3 1 6 2 8 4
Nuestro inters es ordenar los datos de dicho vector en forma ascendente, utilizando el mtodo
que llamamos burbuja.

Algoritmos II
Pg. 49
1 2 3 4 5 6
Parte 1 3 1 6 2 8 4
Parte 2 1 3 6 2 8 4
Parte 3 1 3 6 2 8 4
Primera pasada: cinco comparaciones
Parte 4 1 3 2 6 8 4
Parte 5 1 3 2 6 8 4
En la figura anterior se presentan las cincos comparaciones que se efectan en la primera pasada.
La comparacin correspondiente a cada pasada se ve resaltada en cada vector. A cada
comparacin la llamaremos parte con el fin de evitar redundancias.
En la primera parte se compara el dato de la posicin 1 con el dato de la posicin 2. Como el dato
de la posicin 1 es mayor que el dato de la posicin 2, se intercambian dichos datos, quedando el
vector como se ve en la parte 2.
En la parte 2 se compara el dato de la posicin 2 con el dato de la posicin 3. Como el dato de la
posicin 3 es mayor que el dato de la posicin 2, los datos se dejan intactos.
posicin 3 es mayor que el dato de la posicin 4, se intercambian dichos datos, quedando el vector
como se ve en la parte 4.
posicin 4 es menor que el dato de la posicin 5, los datos permanecen intactos.
posicin 5 es mayor que el dato de la posicin 6, se intercambian dichos datos.
Luego de realizar estas comparaciones y estos intercambios, el vector queda de la siguiente forma:
1 2 3 4 5 6
1 3 2 6 4 8
En esta figura se ha resaltado el dato de la posicin 6, puesto que este ha quedado en el sitio que
le corresponde.

Algoritmos II
Pg. 50
En la segunda pasada se harn nuevamente comparaciones de datos consecutivos desde la

posicin 1 hasta la posicin 5, ya que la posicin 6 ya est en orden.
Las comparaciones e intercambios correspondientes a esta segunda pasada se presenta en a figura
31.4
1 2 3 4 5 6
Parte 1 1 3 2 6 4 8
Parte 2 1 3 2 6 4 8
Segunda pasada: cuatro comparaciones
Parte 3 1 2 3 6 4 8
Parte 4 1 2 3 6 4 8
Como resultado final de esta segunda pasada el vector quedar de la siguiente forma:
1 2 3 4 5 6
1 2 3 4 6 8
En esta figura se resaltan las dos ltimas posiciones, indicando que esta parte del vector ya est
ordenada.
En la siguiente figura se muestra como es el proceso de comparaciones e intercambios
correspondientes a la tercera pasada. Fjese que las comparaciones solo se efectan hasta la
posicin 4, ya que los datos de las posiciones 5 y 6 ya estn ordenados y ubicados en sus
correspondientes lugares.
1 2 3 4 5 6
1 2 3 4 6 8
1 2 3 4 6 8
Tercera pasada: tres comparaciones
1 2 3 4 6 8
Ahora veamos el estado actual de nuestro vector despus de la tercera pasada:

Algoritmos II
Pg. 51
1 2 3 4 5 6
1 2 3 4 6 8
En la siguiente figura se muestra las dos comparaciones correspondientes a la cuarta pasada:
1 2 3 4 5 6
1 2 3 4 6 8
1 2 3 4 6 8
Cuarta pasada: dos comparaciones
Luego de la cuarta pasada el vector quedar de la siguiente forma:

1 2 3 4 5 6
1 2 3 4 6 8
En la siguiente figura se muestra la comparacin que se har en la quinta pasada:
1 2 3 4 5 6
1 2 3 4 6 8
Quinta pasada: una comparacin
Despus de la quinta pasada nuestro vector quedar as:

1 2 3 4 5 6
1 2 3 4 6 8
Observe que al concluir la tercera pasada los datos del vector ya estaban ordenados; es decir, las
comparaciones correspondientes a las pasadas cuarta y quinta no eran necesarias. Esta situacin
se puede detectar en el algoritmo si utilizamos una variable auxiliar y le asignamos un valor antes
de comenzar el ciclo interno. Si ocurri algn intercambio, modificamos el valor inicial de dicha
variable auxiliar. Al terminar el ciclo interno averiguamos cual es el contenido de dicha variable
auxiliar. Si es el mismo que se le asigno inicialmente, significa que no hubo intercambios en el ciclo
interno, por consiguiente los datos del vector ya estn ordenados y no hay necesidad de hacer
ms comparaciones. Para nuestro ejemplo llamaremos a esa variable auxiliar sw.

Algoritmos II
Pg. 52
Nuestro algoritmo queda:

1. VOID ORDENAMIENTO_ASCENDENTE_BURBUJA_SW (V,n)
2.
VARIABLES: i, j, sw (ENTEROS)
3.
INICIO
4.
PARA (i= 1, n-1, 1)
5.
Sw = 0
6.
PARA (j= 1, n-i, 1)
7.
SI (V[j] > V[j+1])
8.
INTERCAMBIAR (V, j, j+1)
9.
sw = 1
10.
FINSI
11.
FINPARA
12.
SI (sw == 0)
13.
i=n
14.
FINSI
15.
FINPARA
16.
FININICIO
17. FIN
El algoritmo anterior es similar al primero que hicimos de ordenamiento ascendente con el
mtodo de burbuja, la diferencia est en que agregamos una variable llamada sw con la cual
sabremos si el vector est completamente ordenado sin haber hecho todos los recorridos. Cuando
la variable sw no cambie de valor significa que el vector ya est ordenado y asignaremos a la
variable i el valor de n para salir del ciclo externo.
EJERCICIOS
1. Elabore un algoritmo que imprima los datos que se hallan en las posiciones impares de un
vector de n elementos.
2. Elabore un subprograma que calcule y retorne cuntas veces se halla un dato d, entrado
como parmetro, en un vector de n elementos.
3. Elabore un subprograma que intercambie los datos de un vector as: el primero con el
segundo, el tercero con el cuarto, el quinto con el sexto, y as sucesivamente.
4. Elabore un subprograma que intercambie los datos de un vector as: el primero con el
tercero, el segundo con el cuarto, el quinto con el sptimo, el sexto con el octavo, y as
sucesivamente.
5. Se tiene un vector cuyos datos se hallan ordenados en forma descendente. Elabore un
subprograma que procese dicho vector, de tal manera que no quede con datos repetidos,

Algoritmos II
Pg. 53
es decir, si hay algn dato repetido, slo debe quedar uno de ellos.
6. Elabore un subprograma que sustituya un valor x por un valor y en un vector cuyos datos
se hallan ordenados ascendentemente, de tal manera que el vector siga conservando su
orden creciente. La funcin debe regresar como resultado 1 si se hizo la sustitucin, 0 si x
no se encontraba en el arreglo y -1 si el arreglo estaba vaco.
3.2. Matrices
Se llama matriz de orden m*n a todo conjunto rectangular de elementos aij dispuestos en m lneas
horizontales (filas) y n verticales (columnas) de la forma:
A=
a11
a12
a1j
a1n
a21
a22
a2j
a2n
ai1
ai2
aij
ain
amj
am2
amj
amn
Abreviadamente suele expresarse de la forma A = (aij) con i = 1, 2, 3, , m y j = 1, 2, 3, , n.;

donde los subndices indican la posicin del elemento dentro de la matriz: el primero (i) denota la
fila y el segundo (j) la columna. Por ejemplo, elemento a46 ser el elemento de la fila 4, columna 6.
Para situarnos en una posicin especfica dentro de una matriz; primero nombramos a nuestra
matriz, seguido del nmero de la fila y la columna en la cual nos ubicaremos, as: mat[i][j], siendo
mat el nombre de nuestra matriz, e i y j el nmero de la fila y la columna, respectivamente, en la
cual nos ubicamos.
IDENTIFICACIN Y CONSTRUCCIN DE UNA MATRIZ
Con el fin de mostrar la necesidad de utilizar matrices vamos a considerar, de nuevo, un archivo
con los datos correspondientes a un censo. En este archivo cada registro contiene la informacin
correspondiente al departamento, municipio, direccin de residencia y nmero de personas en
dicha residencia. Nuestro archivo es el que vemos a continuacin:

Algoritmos II
Pg. 54
Departamento
1
1
1
2
2
2
1
EOF
Municipio
3
2
1
1
4
3
3
Direccin
-
N personas
3
1
6
2
8
9
4
Si deseamos procesar este archivo y determinar el nmero de habitantes en cada departamento,

debemos definir un vector para cada uno de los m departamentos que tenga el pas. Veamos
cmo sera:
Municipio N
1 2 3 4 5 6 7 8 9
Vector Departamento 1
Vector Departamento 2
Vector Departamento m
Manejar m vectores tiene los mismos inconvenientes que cuando se manejaban n variables para
representar el nmero de habitantes de cada municipio de un departamento. Vamos a adoptar
ahora una solucin anloga: en vez de definir m vectores vamos a considerar una nueva
estructura, la cual est conformada con filas y columnas. Cada fila es como si fuera un vector y la
identificaremos con un subndice.
En nuestro ejemplo cada fila representa un departamento, y las columnas, los municipios
correspondientes a cada departamento. Al procesar completamente el archivo censo, la matriz
que nos proporciona la informacin acerca de los habitantes de cada municipio, de cada
departamento, queda de la siguiente forma.

Algoritmos II
Pg. 55
mat
n
1
Ahora veamos el programa con el cual hemos construido esta matriz:

1. VOID CONSTRUIR_MATRIZ (mat, m, n)
2.
VARIABLES: depto, mpio, np (ENTEROS)
direc (ALFANUMRICO)
3.
INICIO
4.
INICIALICE (mat, m, n)
5.
ABRA (censo)
6.
MQ (NOT EOF(censo))
7.
LEA (depto, mpio, direc, np)
8.
mat[depto][mpio]= mat[depto][mpio] + np
9.
FINMQ
10.
CIERRE (censo)
11.
IMPRIMA_POR_FILAS (mat, m, n)
12.
FININICIO
13. FIN
En la instruccin 1 se define el ttulo del subprograma con sus parmetros: la matriz mat y sus
dimensiones m y n, siendo m el nmero de filas y n el nmero de columnas.
En la instruccin 2 se definen las variables con las cuales trabajar nuestro algoritmo: depto, para
el cdigo del departamento; mpio, para el cdigo del municipio; np, para el nmero de personas
en cada vivienda; y direc, para la direccin de cada residencia.
En la instruccin 4 inicializamos la matriz, como veremos en un momento.
En la instruccin 5 abrimos nuestro archivo, al que llamamos censo.
En la instruccin 6 planteamos el ciclo, que se ejecutar mientras que no se llegue a la marca de
fin de archivo (EOF) de censo.
En la instruccin 7 leemos los datos correspondientes a cada registro.

Algoritmos II
Pg. 56
En la instruccin 8 actualizamos el acumulado correspondiente al departamento y municipio cuyos

cdigos se leyeron; es decir, a la celda identificada con la fila (depto) y columna (mpio) se le suma
el nmero de personas que hay en esa direccin.
La instruccin 9 simplemente delimita las instrucciones pertenecientes al ciclo; y en la instruccin
10 cerramos el archivo censo.
En la instruccin 11 invocamos el subprograma IMPRIMA_POR_FILAS, el cual produce el informe
correspondiente al total de habitaciones de cada departamento.
INICIALIZACIN DE LOS DATOS DE UNA MATRIZ
En muchas de las situaciones en las cuales se trabaja con una matriz, esta se usa como un grupo
de contadores o un grupo de acumuladores. En el ejemplo que vimos anteriormente, la matriz que
se utilizo es realmente un conjunto de acumuladores: cada celda tendr el total de habitantes de
cada municipio de cada departamento. Cuando se trabajan acumuladores, estos se deben
inicializar en cero para poder obtener resultados confiables.
Como en nuestra matriz del censo cada celda es un acumulador, cada celda se debe inicializar en
cero. A continuacin presentamos un algoritmo con el cual se ejecuta esta tarea:
1. VOID INICIALICE (mat, m, n)
2.
3.
INICIO
4.
PARA (i= 1, m, 1)
5.
PARA (j= 1, n, 1)
6.
mat[i][j] = 0
7.
FINPARA
8.
FINPARA
9.
FININICIO
10. FIN
En la instruccin 1 se define el subprograma con sus parmetros: mat es la matriz a la cual se le
asignaran los valores inciales a cada una de sus celdas, m es el nmero de filas y n es el nmero
de columnas.
En la instruccin 2 se definimos las variables de trabajo de nuestro algoritmo. Llamamos a estas
variables i y j.

Algoritmos II
Pg. 57
En la instruccin 4 planteamos un ciclo con la variable i. Con este ciclo vamos a recorrer las filas de
la matriz: cuando el contenido de i sea 1, significa que vamos a recorrer la fila 1; cuando el
contenido de i sea 2 significa que vamos a recorrer la fila 2, cuando el contenido de i sea 3
significa que vamos a recorrer la fila 3, y as sucesivamente.
En la instruccin 5 planteamos un ciclo interno, el cual vamos a controlar con la variable j. Con
este ciclo vamos a recorrer los datos correspondientes a cada columna, es decir, cuando i
contenga el valor correspondiente a una fila, j variara desde 1 hasta n, que ser el nmero de
columnas de la matriz.
Y, finalmente, en la instruccin 6 le asignaremos cero (0) a cada celda dentro de la matriz.
RECORRIDO E IMPRESIN POR FILAS
Cuando se trabaja con matrices una de las tareas ms importantes es imprimir el contenido de
cada una de las celdas. Para imprimir el contenido de cada una de las celdas de la matriz existen
dos formas de hacerlo. Una de ellas es imprimiendo primero el contenido de la fila 1, luego el
contenido de la fila 2, luego el de la fila 3 y as sucesivamente. Esta forma de recorrer e imprimir la
matriz se hace por filas. El algoritmo que sigue ejecuta esta tarea:
1. VOID IMPRIMA_POR_FILAS (mat, m, n)
2.
3.
INICIO
4.
PARA (i= 1, m, 1)
5.
IMPRIMA (fila:, i)
6.
PARA (j= 1, n, 1)
7.
IMPRIMA (columna:, j, contenido de la celda:, mat[i][j])
8.
FINPARA
9.
FINPARA
10.
FININICIO
11. FIN
En la instruccin 1 se define el subprograma con sus parmetros: mat es la matriz que desea
recorrer e imprimir por filas; m es el nmero de filas de mat; es el nmero de columnas de mat.
En la instruccin 2 se define las variables de trabajo para efectuar el recorrido.
Las instrucciones de ciclo son completamente similares a las desarrolladas en el algoritmo
INICIALICE, con el cual inicializamos cada celda de la matriz en cero, y realmente la inicializacin
del contenido de cada celda de la matriz, se hizo por filas. Es decir, primero asigna ceros a todas
las celdas de la fila 1, luego a todas las celdas de la fila 2 y as sucesivamente.

Algoritmos II
Pg. 58
En nuestro algoritmo de impresin incluimos una nueva instruccin, la instruccin 5, en la cual

colocamos el ttulo que indique que se van a imprimir los datos de la fila i.
La instruccin 7, que es la instruccin correspondiente al ciclo interno, es la instruccin en la cual
se imprime el contenido de cada celda de una fila i. En dicha instruccin imprimimos el mensaje
correspondiente a cada columna y el contenido de la celda descrita por mat[i][j].
RECORRIDO E IMPRESIONES POR COLUMNAS
Cuando se desea recorrer e imprimir la matriz por columnas hay que hacer una pequea gran
variacin a nuestro algoritmo de recorrido por filas. En el algoritmo que sigue presentamos dicha
variacin:
1. VOID IMPRIMA_POR_COLUMNAS (mat, m, n)
2.
3.
INICIO
4.
PARA (i= 1, n, 1)
5.
IMPRIMA(columna:, i)
6.
PARA (j= 1, m, 1)
7.
IMPRIMA (fila:, j, contenido de la celda:, mat[j][i])
8.
FINPARA
9.
FINPARA
10.
FININICIO
11. FIN
En la instruccin 4, que es la instruccin correspondiente al ciclo externo, a la variable
controladora del ciclo i la ponemos a variar hasta n, y no hasta m, ya que con esta variable i
vamos a recorrer las columnas: primero los datos de la columna 1, luego los datos de la columna 2,
luego de la columna 3 y as sucesivamente.
La instruccin 5 produce el mensaje correspondiente a la columna cuyos datos se van a imprimir
junto con el nmero de dicha columna: el contenido de la variable i.
En la instruccin 6, que es la instruccin correspondiente al ciclo interno, a la variable
controladora j la ponemos a variar hasta m, y no hasta n, ya que con esta variable j vamos a
recorrer los datos correspondientes a cada columna, y el total de elementos de cada columna es
m, el nmero de filas de la matriz.

Algoritmos II
Pg. 59
En la instruccin 7 escribimos cada uno de los datos correspondientes a la columna i, es decir, el

dato de cada fila j: mat[j][i]. Observe que en el algoritmo de recorrido por filas se imprime
mat[i][j] y en el algoritmo de recorrido por columnas se escribe mat[j][i].
SUMA DE LOS DATOS DE CADA FILA DE UNA MATRIZ
Sumar los datos de cada fila es una operacin que se requiere con frecuencia. Si consideramos la
matriz del ejemplo del censo: cada celda contiene el nmero de habitantes de cada municipio
dentro de cada uno de los departamentos. Aqu nos interesa conocer el total de habitantes de
cada departamento: la suma de los datos de las celdas de la fila 1 da el total de habitantes del
departamento 1; la suma de los datos de las celdas de la fila 2 da el total de habitantes del
departamento 2; la suma de los datos de las celdas de la fila 3 da el total de habitantes del
departamento 3, y as sucesivamente.
Para efectuar esta operacin se necesita recorrer la matriz por filas, es decir, usaremos las
instrucciones de recorrido de la matriz por filas, las cuales fueron explicadas en el algoritmo
IMPRIMA_POR_FILAS que vimos anteriormente.
A continuacin presentamos un algoritmo que suma e imprime el total de los datos de las celdas
de cada fila de una matriz:
1. VOID SUMA_POR_FILAS (mat, m, n)
2.
VARIABLES: i, j, tf (ENTEROS)
3.
INICIO
4.
PARA (i= 1, m, 1)
5.
sf = 0
6.
PARA (j= 1, n, 1)
7.
sf = sf + mat[i][j]
8.
FINPARA
9.
IMPRIMA (suma de la fila:, i, es:, sf)
10.
FINPARA
11.
FININICIO
12. FIN
La instruccin 1 define el subprograma con sus parmetros: mat, la matriz en la cual hay que
efectuar el proceso de suma de los datos de cada fila; m, el nmero de filas de mat; y n, el nmero
de columnas de mat.

Algoritmos II
Pg. 60
En la instruccin 2 definimos las variables de trabajo para efectuar la tarea de sumar e imprimir el
total de los datos de las celdas de cada fila: i, para recorrer las filas; j, para recorrer las celdas de
cada fila, es decir las columnas; sf, para llevar el acumulado de los datos de las celdas de la fila i.
En la instruccin 4 planteamos el ciclo de variacin de i, para recorrer la matriz por filas.
En la instruccin 5 se inicializa el acumulador de los datos de cada fila en cero. Este acumulador
(sf) se debe inicializar en cero cada vez que se cambie de fila, ya que si no hacemos esto, cuando
se cambie la variable seguir incrementando su valor con los datos de la nueva fila.
En la instruccin 6 se plantea el ciclo para recorrer las celdas de cada fila.
En la instruccin 7 se acumula el contenido de la celda mat[i][j] (fila i, columna j) en la variable sf.
En la instruccin 9 se imprime el total de la suma de los datos de las celdas de la fila i, con su
correspondiente mansaje.
Veamos un ejemplo. Consideremos la siguiente matriz:
1
3
2
1
3
6
4
2
5
8
6
4
7
5
Al ejecutar por primera vez la instruccin 4, la variable i toma el valor de 1, significa que vamos a
recorrer la fila 1.
En la instruccin 5 se inicializa el contenido de sf en cero.
Al ejecutar por primera vez la instruccin 6, la variable j toma el valor de 1. En este instante, el
contenido de las variables i y j es 1; es decir, estamos en la posicin a11.
Al ejecutar la instruccin 7 le suma a sf el contenido de la celda de la fila 1 columna 1, es decir, 3.
El contenido de sf ser 3.

Algoritmos II
Pg. 61
Al ejecutar la instruccin 8, el fin de PARA interno, incrementa el contenido de j en 1. La j queda

valiendo 2, mientras que la i sigue en 1; ahora nos encontramos en a12.
Ejecuta de nuevo la instruccin 7, en la cual le suma el contenido de la celda fila 1 columna 2, cuyo
valor es 1, a la variable sf. El contenido de sf ser 4.
De esta forma continua ejecutando el ciclo interno hasta que el contenido de la variable j sea
mayor que 7. Cuando esto sucede, continuo con la instruccin 9, en la cual imprime el contenido
de sf, que para la primera fila de nuestro ejemplo es 29.
Luego de escribir el resultado de la suma de la primera fila, llegamos a la instruccin 10, que es el
fin del PARA externo. En esta instruccin incrementa automticamente el contenido de la i en 1 y
luego regresa a la instruccin 4 a comparar el contenido de la i con el contenido de la n. Como el
contenido de i an no ha alcanzado el valor de n ejecuta nuevamente las instrucciones 5 a 10.
A la variable sf le asignan nuevamente cero y recorre la fila i sumando el contenido de cada una de
las celdas con el ciclo interno y luego imprimiendo el contenido de sf.
Al terminar de ejecutar el ciclo externo finaliza la ejecucin del subprograma habiendo escrito la
suma de los datos de las celdas de cada fila.
SUMA DE LOS DATOS DE CADA COLUMNA DE UNA MATRIZ
As como en muchas situaciones es necesario sumar los datos de las celdas de cada fila, hay otras
situaciones en las cuales lo que se requiere es sumar los datos de las celdas de cada columna. Para
ello haremos uso del algoritmo IMPRIMA_POR_COLUMAS que habamos visto anteriormente.
Para totalizar los datos de las celdas de cada columna de una matriz, basta con plantear los ciclos
de recorrido por columnas e insertar las instrucciones propias para manejar el acumulador y
producir el informe de total de cada columna. Veamos cmo se plantea dicho algoritmo:

Algoritmos II
Pg. 62
1. VOID SUMA_POR_COLUMNAS (mat, m, n)

2.
VARIABLES: i, j, sc (ENTEROS)
3.
INICIO
4.
PARA (i= 1, n, 1)
5.
tc = 0
6.
PARA (j= 1, m, 1)
7.
sc = sc + mat[j][i]
8.
FINPARA
9.
IMPRIMA (suma de la columna:, i, es:, tc)
10.
FINPARA
11.
FININICIO
12. FIN
La instruccin 1 define el subprograma con sus para metros: mat, la matriz en la cual hay que
efectuar el proceso de suma de los datos de cada columna; m, el nmero de filas de mat; y n, el
nmero de columnas de mat.
En la instruccin 2 definimos las variables de trabajo para ejecutar la tarea de sumar e imprimir el
total de los datos de las celdas de cada columna: i, para recorrer las columnas; j, para recorrer las
celdas de cada columna; y sf, para llevar el acumulado de los datos de las celdas de la columna i.
En la instruccin 4 planteamos el ciclo de variacin de la i, para recorrer la matriz por columnas.
En la instruccin 5 se inicializa el acumulador de los datos de cada columna en cero. Este
acumulador, sc, se debe inicializar en cero cada vez que se cambie de columna, ya que si no
hacemos esto, cuando se cambie de columna arrastrar el acumulado de la columna anterior al de
la nueva columna.
En la instruccin 6 se plantea el ciclo para recorrer las celdas de cada columna.
En la instruccin 7 se acumula el contenido de la celda mat[j][i] (fila j, columna i) en la variable sc.
E la instruccin 9 se imprime el total de la suma de los datos de las celdas de la columna i, con su
correspondiente mensaje.

Algoritmos II
Pg. 63
CLASIFICACIN DE MATRICES
Las matrices se clasifican segn la forma y segn algunas caractersticas con respecto a la
distribucin de sus datos.
Segn la forma, las matrices pueden ser rectangulares o cuadradas. Matrices rectangulares son
aquellas en las que el nmero de filas es diferente del nmero de columnas, y matrices cuadradas
son aquellas en las que el nmero de filas es igual al nmero de columnas.
Segn la distribucin de sus datos, existen muchas clases de matrices. Entre ellas podemos
destacar las siguientes:
Matriz simtrica: es una matriz cuadrada en la que el dato de una celda de la fila i,
columna j, es igual al dato de la celda de la fila j, columna i; es decir, por ejemplo, que el
dato ubicado en la posicin a13 es igual al dato de la posicin a31.
Matriz identidad: es una matriz cuadrada en la que todos los elementos son 0, excepto los
de la diagonal principal, que son 1. Los elementos de la diagonal principal son aquellos en
los cuales la fila es igual a la columna; es decir, las posiciones a11, a22, a33,, ann.
Matriz triangular inferior: es una matriz cuadrada en la cual los elementos que se hallan
por encima de la diagonal principal son todos ceros.
Matriz triangular superior: es una matriz cuadrada en la cual los elementos que se hallan
por debajo de la diagonal principal son todos ceros.
Matriz diagonal: es matriz una cuadrada en la que todos los elementos que se encuentran
por fuera de la diagonal principal son ceros.
Segn la clase de matriz que se est trabajando, las operaciones sobre ellas varan. Por ejemplo,
para calcular el determinante de una matriz, esta debe ser cuadrada. As aij = 0, donde i es
diferente de j.
SUMA DE LOS ELEMENTOS DE LA DIAGONAL PRINCIPAL DE UNA MATRIZ CUADRADA
Como un ejemplo de trabajo con matrices cuadradas presentamos un algoritmo con el que se
suman los elementos de la diagonal principal de una matriz. El siguiente es un subprograma que
efecta dicha tarea:

Algoritmos II
Pg. 64
1. ENTERO SUMA_DIAG_PPAL (mat, n)

2.
VARIABLES: i, s (ENTEROS)
3.
INICIO
4.
s=0
5.
PARA (i= 1, n, 1)
6.
s = s + mat[i][i]
7.
FINPARA
8.
RETORNE (s)
9.
FININICIO
10. FIN
En la instruccin 1 se define el subprograma, el cual retornara un dato entero, con sus parmetros:
mat, la matriz a la cual le vamos a sumar los elementos de la diagonal principal, y n el nmero de
filas y columnas de la matriz mat.
En la instruccin 2 definimos nuestras variables de trabajo; i, variable con la cual recorremos los
elementos de la diagonal principal, y s, la variable en al cual almacenamos la suma de dichos
elementos.
En la instruccin 5 planteamos el ciclo con el cual se recorren los elementos de la diagonal
principal. Como ya habamos dicho, los elementos de la diagonal principal son aquellos en los
cuales la fila es igual a la columna; por tanto, solo requerimos una variable para recorrerlos.
En la instruccin 6 acumulamos en la variable s dichos elementos, y en la instruccin 8 retornamos
el valor de s.
Tomemos como ejemplo la siguiente matriz:
n
Al ejecutar nuestro subprograma SUMA_DIAG_PPAL, el subprograma sumar los valores que

aparecen resaltados en la matriz y, retornar en s un valor de 29.

Algoritmos II
Pg. 65
SUMA DE LOS ELEMENTOS DE LA DIAGONAL SECUNDARIA DE UNA MATRIZ CUADRADA

Como un segundo ejemplo, vamos a construir un algoritmo con el que se sumen los elementos de
la diagonal secundaria de una matriz cuadrada. Una celda pertenece a la diagonal secundaria si la
suma de la fila y la columna que identifican la celda, da como resultado n+1, siendo n el nmero
de filas y columnas de la matriz. El siguiente algoritmo ejecuta dicha terea:
1. ENTERO SUMA_DIAG_SEC (mat, n,)
2.
VARIABLES: i, j, s (ENTEROS)
3.
INICIO
4.
s=0
5.
j=n
6.
PARA (i= 1, n, 1)
7.
s = s + mat[i][j]
8.
j=j1
9.
FINPARA
10.
RETORNE (s)
11.
FININICIO
12. FIN
En la instruccin 1 definimos el subprograma, el cual retornara un valor entero, con sus
parmetros: mat, la matriz sobre la cual se va a trabajar, y n, el orden de la matriz.
En la instruccin 2 se define las variables de trabajo: i, para identificar la fila de una celda de la
diagonal secundaria; j, para identificar la columna de una celda de la diagonal secundaria; y s, la
variable en la cual llevaremos la suma de los elementos de la diagonal secundaria.
En la instruccin 4 inicializamos el acumulador en cero y en la instruccin 5 le asignamos a j el
valor de n, es decir, la ltima columna. La variable j la utilizaremos para identificar la columna de
un elemento perteneciente a la diagonal secundaria.
En la instruccin 6 planteamos el ciclo con el cual recorremos la matriz. La variable controladora
del ciclo, es decir la i, la utilizaremos para identificar la fila de un elemento de la diagonal
secundaria.
En la instruccin 7 acumulamos en la variable s el dato de una celda perteneciente a la diagonal
secundaria. Dicha celda la identificamos con la fila i y la columna j.

Algoritmos II
Pg. 66
En la instruccin 8 le restamos 1 a j, la variable con la cual se identifica la columna de un elemento

de la diagonal secundaria.
En la instruccin 10 se retorna el contenido de la variable s, la cual contiene la suma de los
elementos de la diagonal secundaria.
Veamos el ejemplo:
n
1
n 7
Al ejecutar nuestro algoritmo SUMA _DIAG_SEC se retorna un valor de 26.

INTERCAMBIO DE DOS FILAS
Otra de las operaciones que se requieren con frecuencia cuando se manipulan matrices es
intercambiar los datos correspondientes a dos filas dadas. Veamos el algoritmo que efecta dicha
tarea:
1. VOID INTERCAMBIAR_FILAS (mat, m, n, i, j)
2.
VARIABLES: k, aux (ENTEROS)
3.
INICIO
4.
PARA (k= 1, n, 1)
5.
aux = mat[i][k]
6.
mat[i][k] = mat[j][k]
7.
mat[j][k] = aux
8.
FINPARA
9.
FININICIO
10. FIN
En la instruccin 1 definimos el subprograma con sus parmetros: mat, la matriz en la cual se
efecta el intercambio; m, el nmero de filas de la matriz mat; n, el nmero de columnas de la

Algoritmos II
Pg. 67
matriz mat; i, y j, las filas cuyos datos hay que intercambiar. El parmetro mat es el nico
parmetro por referencia de este algoritmo.
En la instruccin 2 definimos las variables de trabajo: k, para recorrer las filas cuyos datos se
desean intercambiar, y aux, una variable auxiliar para poder efectuar el intercambio.
En la instruccin 4 se plantea el ciclo con el cual se recorren simultneamente las filas i y j.
Las instrucciones 5 a 7 son las instrucciones con las cuales se intercambia el dato de la celda de la
fila i columna k, con el dato de la celda de la fila j columna k. en la instruccin 5 se aguarda en la
variable auxiliar aux el contenido de la celda fila i columna k; en instruccin 6 trasladamos el dato
de la celda de la fila j columna k hacia la celda fila i columna k, y en la instruccin 7 llevamos lo que
tenemos en la variable auxiliar aux (lo que haba en la celda fila i columna k) hacia la celda de la
fila j columna k.
Las instrucciones del ciclo se ejecutan hasta que el contenido de la variable k sea mayor que n.
Cuando esto suceda se habrn intercambiado los datos de la fila i con los datos de la fila j.
Veamos el siguiente ejemplo:
n
1
m 6
(a)
n
1
m 6
(b)
La matriz a es la matriz original; antes del intercambio de filas. La matriz b es la matriz resultante
de intercambiar la fila 2 con la 5.

Algoritmos II
Pg. 68
INTERCAMBIO DE DOS COLUMNAS

As como intercambiar filas es una opcin que se requiere con cierta frecuencia en la manipulacin
de matrices, intercambiar columnas tambin. El proceso de intercambiar columnas es similar al
proceso de intercambiar filas, la diferencia bsica es que en vez de recorrer las filas se recorre las
columnas que debemos intercambiar. Veamos como efectuar este proceso:
1. VOID INTERCAMBIAR_COLUMNAS (mat, m, n, i, j)
2.
VARIABLES: k, aux (ENTEROS)
3.
INICIO
4.
PARA (k= 1, m, 1)
5.
aux = mat[k][i]
6.
mat[k][i] = mat[k][j]
7.
mat[k][j] = aux
8.
FINPARA
9.
FININICIO
10. FIN
Como ejemplo veamos la siguiente matriz, en la cual se intercambian los datos de la columna 2
con los datos de la columna 5:
n
1
m 6
(a)
n
1
(b)
La matriz a es la matriz original; antes del intercambio de columnas. La matriz b es la matriz

resultante de intercambiar la columna 2 con la 5.

Algoritmos II
Pg. 69
ORDENAR LOS DATOS DE UNA MATRIZ CON BASE EN LOS DATOS DE UNA COLUMNA
Sucede con frecuencia que cuando se manejan datos es una matriz, en una columna se maneja,
digamos, un cdigo, y en el resto de la fila se manejan datos correspondientes a ese cdigo.
Supongamos que en cada fila se maneja los siguientes datos: el cdigo de un artculo y los datos
correspondientes a las ventas de ese artculo en cada uno de los almacenes que maneja la
compaa; como lo vemos en el siguiente ejemplo:
n
1
m 5
Si miramos la matriz anterior, el dato de la columna 1 fila 1 es el cdigo de un artculo (artculo con
cdigo 3) y los dems datos de la fila 1 son las ventas del artculo 3 en los diferentes almacenes, es
decir: 1, 4, 9, 7, 7, 5, 6.
El dato de la fila 2 columna 1 es el cdigo de un artculo (artculo con cdigo 1) y los dems datos
de la fila 2 son las ventas del artculo 1, es decir: 2, 5, 7, 3, 4, 8, 6.
Si se desean conocer las ventas de un artculo, hay que buscar el cdigo del artculo recorriendo la
columna 1. Si los datos de la columna 1 no estn ordenados, el proceso de bsqueda del cdigo
del artculo es bastante dispenso. Si los datos de la columna 1 estn ordenados, el proceso de
bsqueda ser bastante fcil y eficiente.
Ahora veamos el algoritmo que ordena los datos de la matriz teniendo como base los datos de una
columna previamente seleccionada:

Algoritmos II
Pg. 70
1. VOID ORDENAR_POR_COLUMNA (mat, m, n, c)

2.
3.
INICIO
4.
PARA (i= 1, m-1, 1)
5.
k=1
6.
PARA (j= i+1, m, 1)
7.
SI (mat[j][c] < mat[k][c])
8.
k=j
9.
FINSI
10.
FINPARA
11.
INTERCAMBIAR_FILAS (mat, m, n, i, k)
12.
FINPARA
13.
FININICIO
14. FIN
El mtodo que utilizamos para efectuar el ordenamiento es el mtodo de seleccin que vimos en
vectores.
En la instruccin 1 definimos el subprograma con sus parmetros: mat, la matriz cuyos datos se
desean ordenar; m, el nmero de filas de la matriz mat; n, el nmero de columnas de mat; y c, la
columna que se toma como base para ordenar los datos de la matriz. Recuerde que el parmetro
mat debe ser por referencia.
En la instruccin 2 definimos las variables de trabajo para ejecutar el proceso de ordenamiento: i,
para identificar a partir de cual fila faltan datos por ordenar; j, para determinar en cual fila se halla
el menor dato, de los datos de la columna c; y k, la variable en la cual almacenamos la fila que
tiene el menor dato de la columna c.
Las instrucciones 4 a 10 de este algoritmo son similares a las instrucciones 4 a 10 del subprograma
ORDENAMIENTO_ASCENDENTE_SELECCION, con el cual ordenamos un vector. La nica diferencia
es que en la instruccin 7 comparamos el dato de la fila j columna c, con el dato de la fila k
columna c, para determinar en cual fila se halla el menor dato de la columna c. Al terminar el ciclo
interno se ejecuta la instruccin 11, en la que se invoca el subprograma para intercambiar los
datos de la fila i con los datos de la columna k, el cual fue desarrollado previamente.
En la instruccin 12 se finaliza la instruccin PARA y se incrementa la i en 1 y contina con el
proceso de ordenamiento hasta que el contenido de la variable i sea igual al contenido de la
variable m.

Algoritmos II
Pg. 71
En la siguiente figura se muestra como quedan los datos de la matriz despus de ejecutar el
proceso de ordenamiento con base a la columna 1.
n
1
m 5
n
1
1
3
2
1
3
4
4
9
5
7
6
7
7
5
8
6
m 5
(b)
(a)
La matriz a es la matriz original, mientras que la matriz b es la misma matriz, pero ordenada por la
primera columna.
TRANSPUESTA DE UNA MATRIZ
Dada una matriz A se define la matriz transpuesta de A, y la expresaremos como At, a la matriz que
resulta de intercambiar las filas por las columnas de A, de tal forma que si A es una matriz de m
filas y n columnas, su transpuesta resulta de n filas y m columnas.
Consideremos la siguiente figura, en la cual se presenta una matriz con su correspondiente
transpuesta. Como se puede observar la matriz original A tiene 5 filas y 7 columnas. La matriz At
tiene 7 filas y 5 columnas.
n
A
=
m
1 3
2 7
3 4
4 6
5 4
At=
1
2
3
4
5
6
7
1
3
1
6
2
8
4
9
2
7
7
2
5
7
5
4
3
4
1
3
8
1
2
8
4
6
3
2
1
5
5
3
m
5
4
1
2
2
1
3
7
Cada elemento de la fila i columna j de la matriz A queda ubicado en la fila j columna i de la matriz
At. El dato que en la matriz A se hallaba en la fila 2 columna 5 queda en la fila 5 columna 2, y as
sucesivamente.

Algoritmos II
Pg. 72
Ahora veamos el algoritmo con el cual se construye la transpuesta de una matriz:
1. VOID TRANSPUESTA (A, m, n, At)

2.
3.
INICIO
4.
PARA (i= 1, m, 1)
5.
PARA (j= 1, n, 1)
6.
At[j][i] = A[i][j]
7.
FINPARA
8.
FINPARA
9.
FININICIO
10. FIN
En la instruccin 1 definimos el subprograma con sus parmetros: A, la matriz a la cual le
calcularemos la transpuesta; m, el nmero de filas de A; n, el nmero de columna de A; At, la
variable en la cual quedara almacenada la transpuesta de A. El parmetro At debe ser por
referencia.
En la instruccin 2 se definen las variables de trabajo i y j, con las cuales se recorre la matriz A y se
construye At.
En la instruccin 4 y 5 se plantean los ciclos para recorrer la matriz A por filas.
En la instruccin 6 se construye la transpuesta de A; asignando a At fila j columna i el contenido de
A fila i columna j.
Al terminar de ejecutar los ciclos de recorrido de A, por filas, en At queda la transpuesta de A.
SUMA DE DOS MATRICES
La suma de dos matrices A y B consiste en crear una nueva matriz C en la cual cada elemento de C
es la suma de los correspondientes elementos de las matrices A y B. Por tanto, para poder sumar
dos matrices, estas tienen que tener las mismas dimensiones, es decir, igual nmero de filas y
columnas. Simblicamente la suma de dos matrices es expresa as:
C[i][j] = A[i][j] + B[i][j]
El siguiente es un algoritmo con el cual se suman dos matrices:

Algoritmos II
Pg. 73
1. VOID SUMAR_MATRICES (A, m, n, B, p, q, C)

2.
3.
INICIO
4.
SI ((m != p) v (n != q))
5.
IMPRIMA (las matrices no se pueden sumar)
6.
SINO
7.
PARA (i= 1, m, 1)
8.
PARA (i= 1, n, 1)
9.
C[i][j] = A[i][j] + B[i][j]
10.
FINPARA
11.
FINPARA
12.
FINSI
13.
FININICIO
14. FIN
En la instruccin 1 se define el subprograma con sus parmetros: A y B, las matrices que se van a
sumar; m y n, las dimensiones de la matriz A; p y q, las dimensiones de la matriz B; y C, la matriz
resultante. El parmetro C es un parmetro por referencia.
En la instruccin 2 definimos las variables de trabajo: i y j, para recorrer las matrices A y B por filas.
En la instruccin 4 se controla que las matrices A y B se pueden sumar. Para que dos matrices se
puedan sumar deben obtener las mismas dimensiones (m==p y n==q). Por tanto, si el nmero de
filas de A, que es m, es diferente del nmero de filas de B, que es p, o el nmero de columnas de
A, que es n, es diferente del nmero de columnas de B, que es q, las matrices no se podrn sumar
y se ejecutar las instruccin 5, en la cual produce el mensaje apropiado y finalizara sin ejecutar
otra accin.
Si la condicin de la instruccin 4 es falsa significa que las dos matrices A y B tienen las mismas
dimensiones y por consiguiente continuar ejecutando la instruccin 7.
En las instrucciones 7 y 8 planteamos los ciclos para recorrer las matrices por filas.
En la instruccin 9 se le asigna a la celda ij de C el resultado de sumar el contenido de la celda ij de
A con el contenido de la celda ij de B.
Al termina de ejecutar los ciclos en la matriz C queda el resultado de sumar los datos de la matriz A
con los datos de la matriz B.

Algoritmos II
Pg. 74
Veamos un ejemplo de suma de matrices:

n
1
m4
Matriz A
Matriz B
1
1
4
2 15
3 10
m 4 12
4
12
13
6
11
12
7
6
9
17
7
6
17
6
5
7
13
5
5
5
Matriz C
Observe que cada celda de la matriz C contiene la suma de sus correspondientes posiciones de las
matrices A y B.
MULTIPLICACIN DE MATRICES
Sea A una matriz de dimensiones m*n, siendo m el nmero de filas y n el nmero de columnas.
Sea B una matriz de dimensiones p*q, siendo p el nmero de filas y q el nmero de columnas.
Para poder efectuar el producto de A y B, en estas dos matrices se debe cumplir que n==p; es
decir, el nmero de columnas de A (n) debe ser igual al nmero de filas de B (p). Si n es diferente
de p no se podr efectuar el producto A y B.
La matriz resultante C tendr dimensiones m*q, siendo m el nmero de filas de la matriz A y q el
nmero de columnas de la matriz B.
Cada elemento C[i][j] de la matriz resultante es la sumatoria de productos de los elementos A[i][k]
* B[k][j], con k desde 1 hasta n.
Consideramos como ejemplo las matrices A y B de la siguiente figura. El producto de A*B es la
matriz C, que tambin se presenta en la misma figura:

Algoritmos II
Pg. 75
n
1
m 3 3 1 6 2
Matriz A
q
1
p 4 5 3 8
Matriz B
9
6
1
0
7
6
3
5
4
7
4
8
1
7
4
2
8
3
9
Matriz C
En nuestro ejemplo, la matriz A tiene dimensin 3*4, es decir, m vale 3 y n vale 4; y la matriz B
tiene dimensin 4*3, es decir, p vale 4 y q vale 3. Por consiguiente, el producto A*B se puede
efectuar ya que n==p, y la dimensin de la matriz resultante son 3*3, es decir, 3 filas y 3 columnas.
Simblicamente, cada elemento de la matriz resultante (C) se describe as:
Cij K 1 Ai ,k * Bk . j
n
Es decir, para multiplicar la matriz A por la matriz B de nuestro ejemplo, y obtener como resultado
la matriz C, lo hacemos de la siguiente forma:
C11 = A11*B11 + A12*B21 + A13*B31 + A14*B41
C12 = A11*B12 + A12*B22 + A13*B32 + A14*B42
C13 = A11*B13 + A12*B23 + A13*B33 + A14*B43
C21 = A21*B11 + A22*B21 + A23*B31 + A24*B41
C22 = A21*B12 + A22*B22 + A23*B32 + A24*B42
C23 = A21*B13 + A22*B23 + A23*B33 + A24*B43
C31 = A31*B11 + A32*B21 + A33*B31 + A34*B41
C32 = A31*B12 + A32*B22 + A33*B32 + A34*B42
C33 = A31*B13 + A32*B23 + A33*B33 + A34*B43
Veamos el algoritmo que se encarga de realizar la multiplicacin entre matrices:

Algoritmos II
Pg. 76
1. VOID MULTIPLICAR_MATRICES (A, m, n, B, p, q, C)

2.
3.
INICIO
4.
SI (n != p)
5.
IMPRIMA (las matrices no se pueden multiplicar)
6.
SINO
7.
PARA (i= 1, m, 1)
8.
PARA (j= 1, q, 1)
9.
C[i][j] = 0
10.
PARA (k= 1, n, 1)
11.
C[i][j] = C[i][j] + A[i][k] * B[k][j]
12.
FINPARA
13.
FINPARA
14.
FINPARA
15.
FINSI
16.
FININICIO
17. FIN
En la instruccin 1 se define el subprograma con sus parmetros: A y B, las matrices a multiplicar;
m y n, las dimensiones de la matriz A; p y q, las dimensiones de la matriz B; y C, la matriz
resultante del producto, recuerde que C debe ser un parmetro por referencia.
En la instruccin 2 definimos las variables de trabajo: i, para recorrer las filas de la matriz A; j, para
recorrer las columnas de la matriz B; y k, para recorrer simultneamente las columnas de A y las
filas de B.
En la instruccin 4 se controla que se pueda efectuar el producto entre A y B. Si el nmero de
columnas de A, que es n, es diferente del nmero de filas de B, que es p, el producto no se podr
efectuar y, por tanto, ejecuta las instruccin 5, con la cual se produce el mensaje apropiado y
finalizar sin ejecutar ms acciones.
Si la condicin de la instruccin 4 es falsa, significa que el producto si se puede ejecutar y, por
tanto, contina ejecutando la instruccin 7.
En la instruccin 7 se plantea el ciclo con el cual se recorre la matriz A por filas.
En la instruccin 8 se plantea el ciclo con el cual se recobra la matriz B por columnas.

Algoritmos II
Pg. 77
En la instruccin 9 se inicializa en cero el contenido de la celda fila i columna j de la matriz C. Esta

inicializacin es necesaria ya que dicha posicin funciona como un acumulador.
En la instruccin 10 se plantea el ciclo con el cual se recorren las celdas de la fila i de A y las celdas
de la columna j de B. Para un valor cualquiera de k (variable controladora del ciclo de la
instruccin 10), se efecta el producto del contenido de la celda ik de A, con el contenido de la
celda kj de B y se acumula este producto en la celda ij de C.
Al terminar el ciclo ms interno (el ciclo de la instruccin 10), se pasar a otra celda de la matriz C;
que en ese ejemplo se hace por filas.
En las matrices se utilizan las mismas acciones que en los vectores (borrar, insertar, buscar, etc.),
la diferencia radica en que, para realizar alguna de estas acciones en una matriz, se necesitar un
ciclo adicional para podernos desplazar en las filas y columnas.
EJERCICIOS
1. Un tablero de damas es un arreglo de 8 filas por 8 columnas. Uno (1) representa la
presencia de una ficha blanca en el tablero, dos (2) representa la presencia de una ficha
negra en el tablero, y cero (0) representa la ausencia de ficha. Elabore un algoritmo que
determine e imprima: el nmero de fichas blancas en el tablero, el nmero de fichas
negras y el nmero de espacios vacos.
2. Elabore un subprograma que calcule y retorne en el programa principal la suma de los
elementos que estn por encima de la diagonal principal en una matriz cuadrada de
orden n.
3. Elabore un subprograma que calcule y retorne en el programa principal la suma de los
elementos que estn por debajo de la diagonal secundaria en una matriz cuadrada de
orden n.
4. Elabore un algoritmo que lea una matriz de n*m elementos y un valor d. Luego modifique
la matriz multiplicando cada elemento por el valor d.
3.3. Arreglos de Registros

Un registro es una estructura de datos compuesta. Se puede decir que un registro es un conjunto
de campos variables relacionados que, en general, puede pertenecer a tipos de datos diferentes,
llamados componentes del tipo registro, donde todas las componentes pueden manipularse bajo
un solo nombre de variable. Por ejemplo, si se tiene un registro de datos compuestos por los
campos: cdula, nombre, deduccin y salario, podemos representarlo de la siguiente forma:

Algoritmos II
Pg. 78
32506321
SANDRA FONEGRA
40000
630000
Como puede notarse, dentro del registro solo hay datos (informacin); es el programa quien
coloca nombres a cada dato para poderlos almacenar en la memoria de la computadora.
Si la informacin del empleado se fuera a tratar en forma individual y los nombres de variables
seleccionados para cada campo fuera: CC, NOM, DEDUC y SAL; al ejecutar la instruccin:
LEA: CC, NOM, DEDUC, SAL
Ocurrir en memoria lo siguiente:
CC
32506321
DEDUC
40000
SAL
630000
NOM
SANDRA
FONEGRA
MEMORIA
La informacin de la empleada est dispersa en la memoria. La idea de usar registro es agrupar
toda la informacin en una misma rea de memoria bajo un solo nombre. Si se toma la
determinacin de que EMP1 es una variable de tipo registro, o sea, almacenar en el rea asignada
toda la informacin de un empleado, grficamente se puede mirar de la siguiente manera:
EMP1
<Cdula>
<Nombre>
<Deduccin>
<Salario>
MEMORIA
Para que EMP1 sea tomada como una variable tipo registro, se debe definir como tal; es decir, se
define a la variable como registro y se definen los dems campos que habr en dicho registro. Para
nuestro ejemplo, la variable registro quedara as:

Algoritmos II
Pg. 79
ALGORITMO EJEMPLO_REG
EMPLEADO (REGISTRO):
CC, NOM (ALFANUMRICOS)
DEDUC, SAL (REALES)
VARIABLES: EMP1, EMP2 (EMPLEADO)
INICIO
LLENAR_REGISTRO (EMP1)
FININICIO
FIN
En el anterior ejemplo se ha definido un dato de tipo registro llamado empleado y adems se
define una variable que es de tipo empleado; esto quiere decir que cualquier variable que sea de
tipo empleado puede almacenar los valores de las componentes del registro, es decir, que en
EMP1 se almacenan: CC, NOM, DEDUC y SAL.
En la estructura anterior se define a EMP1 y EMP2 como variables tipo registro, por lo tanto,
pueden almacenar todos los valores de los campos que conforman al tipo de dato empleado, y su
representacin interna seria:
EMP1
<Cdula>
<Nombre>
<Deduccin>
<Salario>
EMP2
<Cdula>
<Nombre>
<Deduccin>
<Salario>
MEMORIA
Las variables tipo registro EMP1 y EMP2 son variables compuestas; para referenciar a cada una de
sus componentes hay que clasificarlas, o sea, decir en forma explcita a cul de las componentes
del registro nos vamos a referir. Dicha clasificacin se hace as:
variable_tipo_regristro.componente.
Veamos un subprograma de cmo llenaramos la informacin de un empleado, despus de haber
definido la variable de tipo registro empleado y a la variable de tipo empleado:

Algoritmos II
Pg. 80
1. VOID LLENAR_REGISTRO (REG)

2.
INICIO
3.
IMPRIMA (Ingrese la cdula)
4.
LEA (REG.CC)
5.
IMPRIMA (Ingrese el nombre)
6.
LEA (REG.NOM)
7.
IMPRIMA (Ingrese la deduccin)
8.
LEA (REG.DEDUC)
9.
IMPRIMA (Ingrese el salario)
10.
LEA (REG.SAL)
11.
FININICIO
12. FIN
El parmetro EMP1 es un parmetro por referencia.
En la instruccin 4 se lee la cdula que se almacenar en el registro. Igualmente en las
instrucciones 6, 8 y 10 donde se almacenar el nombre, deduccin y salario del empleado,
respectivamente.
Despus de ejecutar el subprograma anterior y llenarlo con los datos que tenamos anteriormente,
nuestra memoria estara de la siguiente forma:
EMP1
32506321
SANDRA FONEGRA
40000
630000
EMP2
<Cdula>
<Nombre>
<Deduccin>
<Salario>
MEMORIA
Si hay necesidad de mover la informacin de una variable tipo registro a otra, se puede hacer
componente a componente, o moviendo toda la informacin al mismo tiempo. Por ejemplo:
EMP2.CC = EMP1.CC
EMP2.NOM = EMP1.NOM
EMP2.DEDUC = EMP1.DEDUC
EMP2.SAL = EMP1.SAL
Lo cual sera lo mismo que tener: EMP2 = EMP1.

Algoritmos II
Pg. 81
Un arreglo de registro es una estructura de datos de gran utilidad e importancia en la

programacin de aplicaciones, ya que muchas veces es deseable, desde el punto de vista de la
lgica del programa en particular, mantener disponible en memoria principal una serie de registro
con informacin del mismo tipo para su proceso; dichos registros no estarn dispersos; harn
parte de un arreglo, lo que facilita su manejo. Un arreglo de registros es muy parecido a un archivo
de datos, se diferencian en que los arreglos de registros residen en memoria principal y los
archivos en memoria auxiliar, por lo tanto, estos ltimos tienen existencia permanente.
Para obtener ms informacin sobre los archivos de datos, visite el siguiente enlace:
http://www.monografias.com/trabajos7/arch/arch.shtml
Otra importancia que tienen los arreglos de registros es que cada uno de sus elementos est
formado por varios campos pertenecientes a diferentes tipos de datos, a diferencia de los otros
tipos de arreglos en los que sus elementos son de un solo tipo; aunque cabe anotar que, por
ejemplo, un vector puede ser de tipo registro. Veamos un ejemplo en donde almacenamos los
datos de un registro en un vector y luego imprimimos dicho vector:
1. ALGORITMO REG_VECTOR
2.
R (REGISTRO):
CC, NOM (ALFANUMRICOS)
DEDUC, SAL (REALES)
3.
VARIABLES: VEC[], EMP (R)
i, n (ENTERO)
4.
INICIO
5.
IMPRIMA (Ingrese el nmero de registros)
6.
LEA (n)
7.
PARA (i=1, n, 1)
8.
LLENAR_REGISTRO (EMP)
9.
VEC[i] = EMP
10.
FINPARA
11.
PARA (i= 1, n, 1)
12.
IMPRIMA (VEC[i].CC)
13.
IMPRIMA (VEC[i].NOM)
14.
IMPRIMA (VEC[i].DEDUC)
15.
IMPRIMA (VEC[i].SAL)
16.
FINPARA
17.
FININICIO
18. FIN

Algoritmos II
Pg. 82
En la instruccin 2 definimos a R de tipo registro con los campos: CC, NOM, DEDUC y SAL; y en la
instruccin 3 definimos nuestras variables, en donde utilizamos 2 variables de tipo R: VEC[] y EMP.
En la instruccin 6 leemos a n, para conocer la cantidad de registros que almacenaremos y, en la
instruccin 7, definimos nuestro ciclo desde 1 hasta n para llenar el vector con los registros.
En la instruccin 8 llamamos al subprograma LLENAR_REGISTRO para leer los datos que
guardaremos en el vector. Enviamos como parmetro a la variable EMP.
En la instruccin 9 llevamos al vector en posicin i lo que se guard en EMP.
En las instrucciones 10 a 16 imprimimos el contenido de los vectores, es decir, imprimimos los
registros que hemos almacenado.
EJERCICIOS
1. Una compaa distribuye N productos a distintos comercios de la ciudad. Para ello
almacena en un arreglo toda la informacin relacionada a su mercanca: Clave,
descripcin, existencia, mnimo a mantener de existencia y precio unitario. Elabore un
algoritmo que pueda llevar a cabo las siguientes operaciones:
2. Venta de un producto: se deben actualizar los datos que correspondan, y verificar que la
nueva existencia no est por debajo del mnimo.
3. Reabastecimiento de un producto: se deben actualizar los campos que correspondan.
4. Actualizar el precio de un producto.
5. Informar sobre un producto: se deben proporcionar todos los datos relacionados a un
producto.
Prueba Final
1. Se tienen dos vectores A y B, ambos con los datos ordenados ascendentemente. Elabore
un subprograma que construya un tercer vector C que sea la intercalacin de los datos de
los vectores A y B. En C no deben quedar datos repetidos. Los datos del vector C deben
quedar ordenados ascendentemente a medida que se va construyendo el vector.
2. Elabore un subprograma que reciba como parmetros dos vectores A y B, y que construya
un tercer vector que sea la interseccin de los datos que hay en A con los datos que hay
en B.

Algoritmos II
Pg. 83
3. Se tiene una matriz de m filas por n columnas en la cual, en cada posicin, se halla un dato
numrico. Elabore un algoritmo que construya dos vectores as: uno con la sumatoria de
los elementos de cada fila y otro con la sumatoria de los elementos de cada columna.
Elabore subprogramas tipo funcin para construir dichos vectores, los cuales debe invocar
en su algoritmo principal. En el primer vector construido determine la fila cuya sumatoria
es mayor. En el segundo vector determine la columna cuya sumatoria es menor. Para
determinar la sumatoria mayor y la menor elabore subprogramas, los cuales debe invocar
en su algoritmo principal.
4. Una inmobiliaria tiene informacin sobre departamentos en renta. De cada departamento
se conoce: clave, extensin (en metros cuadrados), ubicacin (excelente, buena, regular,
mala), precio y estado (disponible, rentado). Diariamente acuden muchos clientes a la
inmobiliaria solicitando informacin. Elabore un algoritmo capaz de realizar las siguientes
operaciones sobre la informacin disponible:
a. Liste los datos de todos los departamentos disponibles que tengan un precio inferior o
igual a un cierto valor P.
b. Liste los datos de los departamentos disponibles que tengan una extensin mayor o igual a
un cierto valor E y una ubicacin excelente.
c. Liste el monto de la renta de todos los departamentos alquilados.
d. Llega un cliente solicitando rentar un departamento. Si existe un departamento con una
extensin mayor o igual a la deseada, con un precio y una ubicacin que se ajustan a las
necesidades del cliente, el departamento se renta. Actualizar los datos que correspondan.
e. Se vence un contrato, si no se renueva, actualizar los datos que correspondan.
f. Se ha decidido aumentar las rentas en un X%. Actualizar los precios de las rentas de los
departamentos.

Algoritmos II
Pg. 84
4. SISTEMAS NUMRICOS
OBJETIVO GENERAL
Conocer en las diferentes bases los sistemas numricos, y la representacin de datos dentro de un
computador.
Convertir un nmero de una base b a una base 10 y viceversa, as como tambin la suma
de nmeros binarios.
Representar nmeros enteros y reales en las diferentes estructuras de 8 y 32 bits.
Prueba Inicial
1.
2.
3.
4.
5.
Qu es un nmero en base 2?
Qu es un nmero en base 10?
Qu es un bit?
Qu es un nmero entero?
Qu es un nmero real?
4.1. Sistemas Numricos Pesados y Conversiones

Los sistemas numricos pesados son sistemas numricos en los cuales cada digito con los que se
presentan cantidades tienen dos valores: uno intrnseco (por el hecho de ser ese digito) y otro
posicional (por el sitio que ocupe en la hilera de dgitos).
En general, una hilera de dgitos para representar cantidades se presenta as:
Dn Dn1 D2 D1 D0
En la cual, al digito menos significativo se le asigna la posicin cero (D0) y a partir de ah, hacia la
izquierda las posiciones sern 1,2, hasta el digito de la posicin n.
Si queremos representar cantidades con parte entera y parte decimal, la hilera es:

Algoritmos II
Pg. 85
Dn Dn-1 D2 D1 D0 D-1 D-2 D-3 D-m

Observe que los dgitos correspondientes a la parte decimal se les asigna las posiciones -1, -2, -3, y
as sucesivamente.
Para determinar el valor representado en una hilera de dgitos se procede as:
Valor = Dn * bn + Dn-1 *bn-1 ++ D1 * b1 + D * b0 + . D-1 * b-1 ++D-m * b-m
Siendo b la base utilizada para representar cantidades.
i n
En general:
valor =
D *b
i m
Ej. Si se tiene el nmero (316.25)10 en base diez, el valor representado ser:

3*102 + 1*101 + 6*100 + 2*10-1 + 5*10-2
Nosotros estamos familiarizados con la representacin de cantidades en base diez. La base se
define de acuerdo al nmero de dgitos que se utilizan para representar cantidades. Nuestra base
se denomina base diez porque utiliza diez dgitos: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Sin embargo, existen tantas bases como quiera, para representar cantidades:
Base 4, utiliza cuatro dgitos
(0, 1, 2, 3)
Base 2, utiliza dos dgitos
(0, 1)
Base 8, utiliza ocho dgitos
(0, 1, 2, 3, 4, 5, 6, 7)
Base 16, utiliza diecisis dgitos (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F)
Para indicar en cual base se halla una hilera de dgitos escribiremos la hilera de dgitos entre
parntesis y en la parte externa derecha, como subndice, la base.
( Dn Dn-1 D2 D1 D0 D-1 D-2 D-3 D-m )b
Es bueno observar cmo se generan las hileras de dgitos para representar cantidades. Si estamos
en base diez, comenzamos desde el 0 hasta el 9; cuando se llega 9, como se agotaron los dgitos,
se aade un uno (1) a la izquierda y se comienzan a generar nuevamente los dgitos (10), desde
cero hasta el nueve en la posicin de la derecha: 10, 11, 12, 13, 14, 15, hasta 19; nuevamente se
han agotado los dgitos en la posicin de la derecha, entonces se suma 1 al digito de la izquierda y
se generan nuevamente los dgitos del 0 al 9 en la posicin de la derecha: 20, 21, 22, 23,,29; y as
sucesivamente hasta llegar a 99, en este punto se han agotado los dgitos en ambas posiciones,

Algoritmos II
Pg. 86
entonces se aade un nuevo 1 a la izquierda y se generan nuevamente todos los dgitos de las dos
posiciones de la derecha: 100, 101, 102,, 199 y as sucesivamente.
Si queremos generar hileras en base cinco, cuyos dgitos son 0, 1, 2, 3, 4; sera as: 0, 1, 2, 3, 4; se
han agotado los dgitos de la base cinco, entonces continuamos con 10, 11, 12, 13, 14; luego 20,
21, 22, 23, 24.
Por consiguiente, el 5 de la base diez, en base cinco, es el 10; el 6 de la base diez, en base cinco, es
el 11; el 7 de la base diez, en base cinco, es el 12, y as sucesivamente. El 10, de la base diez, en
base cinco es el 20.
En este punto estamos interesados en convertir cantidades representadas en una base hacia otra.
Plantearemos los siguientes casos:
Conversin de un numero en base b hacia base diez.
Conversin de un numero en base diez hacia base b.
Conversacin de nmeros cuyas bases son potencias entre s.
CONVERSIN DE UN NUMERO EN BASE b HACIA BASE DIEZ
Si se quiere convertir el (314)5 hacia base diez procedemos as:
3*52 + 1*51 + 4*50
3*25 + 1*5 + 4*1 = 84
y efectuamos las operaciones en base diez

por consiguiente (314)5 = (84)10
Si se tiene (275.25)8 y se desea trasladar a base 10, se realiza as:

2*82 + 7*81 + 5*80 + 2*8-1 + 5*8-2
128 + 56 + 5 + 0.25 + 0.078125 = 189.32812
Es decir, (275.25)8 = (189.32812)10
CONVERSIN DE UN NMERO EN BASE DIEZ HACIA BASE B
Para convertir un numero en base diez hacia base b hay que considerar por separado la parte
entera y la parte decimal. Ilustremos la conversin con un ejemplo: convertir (275.125)10 hacia
base 4.
La parte entera se convierte mediante divisiones sucesivas por la base destino, hasta que el
cociente sea menor que la base destino.

Algoritmos II
Pg. 87
275
68
17
Por cada divisin se seala el residuo correspondiente y el cociente final.

El nmero en base b ser la concatenacin de los residuos y el cociente final en orden inverso de
aparicin. Por consiguiente:
(275)10 = (10103)4
La parte decimal se convierte mediante multiplicaciones sucesivas de la parte decimal, por la base
destino hasta obtener 0 en la parte decimal o alcanzar la precisin deseada.
0.125 * 4 = 0.5
0.5
* 4 = 2.0
Por cada multiplicacin se seala la parte entera obtenida, y la parte decimal resultante se
multiplica nuevamente por la base destino. Las partes enteras de cada multiplicacin conformaran
el numero en la base b en el mismo orden de aparicin.
(0.125)10 = (0.02)4
Entonces, tenemos que (275.125)10 = (10103.02)3
CONVERSIN DE NMEROS CUYAS BASES SON POTENCIAS ENTRE S
Consideremos las bases b1 y b2, y llamemos k la relacin de potencias entre ellas, es decir:
b1 = (b2)k
Entonces, cada digito de la base b1 requiere k dgitos de la base b2.
Como ejemplo tomemos las bases dos y ocho, en donde 8 = 23, por consiguiente, cada digito de la
base ocho requiere tres dgitos de la base dos.
Construyamos entonces la siguiente tabla:

Algoritmos II
Pg. 88
Base
8
0
1
2
3
4
5
6
7
Base
2
000
001
010
011
100
101
110
111
Y si deseamos convertir un numero en base ocho hacia la base dos basta con utilizar dicha tabla,
reemplazando cada digito de la base ocho por sus correspondientes tres dgitos de la base dos.
Ejemplo: convertir (607514)8 hacia base 2
El 6 es el 110, el 0 es 000, el 7 es 111, el 5 es 101, ya as sucesivamente, por consiguiente el
numero en base dos es: (110000111101001100)2.
Si deseamos hacer el proceso inverso, es decir, convertir desde base dos hacia base ocho,
conformaremos grupos de tres dgitos, partiendo desde el extremo derecho en la parte entera y
de izquierda a derecha en la parte decimal, del nmero en base dos, y cada grupo de tres dgitos
se reemplaza por su correspondiente digito de la base ocho, segn la tabla.
Ejemplo: convertir (1100111.1101)2 a base ocho
Agrupando la parte entera de derecha a izquierda tendremos: 111, 100 y 001. Agregamos tantos
ceros a la izquierda como sea necesario para completar el grupo de dgitos.
Agrupando la parte decimal de izquierda a derecha tendremos: 110 y 100. El ltimo grupo se
completa con ceros a la derecha ya que ceros a la derecha en parte decimal no afecta el valor
representado.
Por consiguiente, utilizando la tabla anterior: (1100111.1101)2 = (147.64)8
Adicionalmente, aqu se aade una tabla con los valores de las bases ms utilizadas en la
computacin y la electrnica: decimal (10), hexadecimal (16), binaria (2) y octal (8):

Algoritmos II
Pg. 89
Base 10
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Base 16
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
Base 2
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Base 8
0
1
2
3
4
5
6
7
10
11
12
13
14
15
16
17
EJERCICIOS
Efecte las siguientes conversiones de bases:
(FEA)16 a ( )8
(5.14)7 a ( )12
(674.316)8 a ( )4
(1001110.001)2 a ( )16
4.2. Representacin de Datos en un Computador

Con el fin de representar datos dentro de un computador estos se clasifican en numricos y no
numricos, los datos numricos a su vez se clasifican entre enteros y reales, y los enteros se
clasifican entre positivos y negativos, como vemos en la siguiente figura.
No numricos
Datos
Positivos
Enteros
Numricos
Negativos
Reales

Algoritmos II
Pg. 90
DATOS NO NUMRICOS
La unidad bsica para representar datos dentro de un computador es el bit, el cual es un elemento
biestable (2 estados). Por convencin, se dice que cada bit representa el cero o el uno. Con el fin
de representar los diferentes caracteres se han construido grupos de 8 bits, los cuales se
denominan bytes, y cada byte, de acuerdo a la combinacin de unos y ceros que tenga,
representa un carcter diferente.
Esta convencin es la que se conoce como cdigo ASCII (American Standard Code for Information
Interchange). De los ocho bits que tiene un byte, en el cdigo ASCII solo se utilizan 7 para
representar datos, el octavo bit se utiliza para control de transmisin de datos.
De acuerdo con lo anterior, si deseamos representar la palabra ALGORITMO en memoria, esta
requerir 9 bytes, uno por cada carcter; o sea, 72 bits.
DATOS NUMRICOS ENTEROS Y SUMA DE BINARIOS
Para representar datos numricos el computador utiliza otra agrupacin de bits, la cual va desde 8
hasta 64 bits, dependiendo de la arquitectura de cada mquina. Nosotros, por simplicidad,
consideraremos grupos de 8 bits, cuya forma general es:
1 2 3 4 5 6 7 8
En donde el primer bit representa el signo y los siete restantes son el dato numrico.
En general la representacin de datos numricos enteros se hace de tres formas:
Signo-magnitud
(SM)
Signo-complemento a uno
Signo-complemento a dos
(SC1)
(SC2)
La estructura general de estos ocho bits es:

Bit del signo: 0 significa que el nmero es positivo, 1 que es negativo.
Los otros bits representan un nmero decimal (base 10) codificado en binario.
Por consiguiente, si tenemos la siguiente hilera 01101110 el nmero decimal representado en
ellas es: +110 en base diez.

Algoritmos II
Pg. 91
Los nmeros positivos se representan solo en signo-magnitud, mientras que los enteros negativos
se pueden representar de las tres formas vistas anteriormente.
El complemento a uno de un numero binario se obtiene cambiando ceros por unos y unos por
ceros, sin tocar el bit del signo. El complemento a dos se obtiene sumndole uno (1) al
complemento a uno. La suma de binarios se realiza de acuerdo a la siguiente tabla:
0+0=0
0+1=1
1+0=1
1 + 1 = 10
Note que al sumar 1 + 1 es 102, es decir, llevamos 1 a la siguiente posicin de la izquierda
(acarreo). Esto es equivalente, en el sistema decimal a sumar 9 + 1, que da 10: cero en la posicin
que estamos sumando y un 1 de acarreo a la siguiente posicin.
Por ejemplo, si queremos representar el -110 de la base diez lo podremos hacer de tres formas:
11101110
10010001
10010010
(SM)
(SC1)
(SC2)
Consideremos algunos ejemplos:

Determinemos el valor almacenado en la siguiente estructura, la cual se halla en signo-magnitud:
01000100
Como el primer bit es cero el nmero es positivo, y el valor almacenado en ella se obtiene
convirtiendo el numero binario 1000100 a base diez, el cual es 68.
Por consiguiente el valor almacenado en la estructura 01000100 en la representacin
signo-magnitud es +68.
Ahora determinemos el valor almacenado en la siguiente estructura, la cual se halla en signocomplemento a dos: 11000100
Sabemos que, como el primer bit es uno, el elemento es negativo y el valor almacenado se obtiene
determinando el signo-magnitud de los otros 7 bits y luego convirtiendo este resultado a base
diez.

Algoritmos II
Pg. 92
Primero debemos hallar el signo-complemento a uno y luego el signo-magnitud. Para hallar el

signo-complemento a uno intercambiamos ceros y unos, y al nmero que nos da le sumamos 1
para obtener el signo-magnitud
11000100
10111011
10111100
(SC2)
(SC1)
(SM)
Ahora que tenemos el nmero en signo-magnitud lo convertimos a base diez para conocer su valor
almacenado. Por consiguiente, el valor almacenado en 11000100 (SC2) en la representacin signomagnitud es -59.
En general, digamos que los enteros positivos se representan en la forma signo-magnitud,
mientras que los enteros negativos se representan en la forma signo-complemento a dos.
Para efectuar la suma entre binarios debemos pasar los nmeros negativos a SC2, mientras que los
positivos los sumamos en SM.
Si tenemos representados los positivos en la forma signo-magnitud y los negativos en la forma
signo-complemento a dos, bastar con sumar los nmeros digito a digito, incluyendo el bit del
signo y obtenemos el resultado correcto: si en el resultado el bit del signo es 0 el resultado es un
numero positivo y est en la forma signo-magnitud; si en el resultado el bit del siglo es 1 el
resultado es un numero negativo y est en la forma signo-complemento a dos, bastar con
convertirlo a signo-magnitud para obtener su valor almacenado.
NOTA: Si cuando sumamos aparece otro nmero despus de sumar el bit del signo, ste se
descarta.
Como ejemplo consideremos los nmeros +9, -9, +16 y -16:
+9
-9
+16
-16
es
es
es
es
00001001
11110111
00010000
11110000
(SM)
(SC2)
(SM)
(SC2)
La suma de estos nmeros, con base en la representacin anterior es:

(9)
+ (16)
(25)
0 0 0 0 1 0 0 1 (SM)
+ 0 0 0 1 0 0 0 0 (SM)
0 0 0 1 1 0 0 1 (SM)
Este es el nmero que buscamos

Algoritmos II
Pg. 93
(9)
+ (-16)
(-7)
0 0 0 0 1 0 0 1 (SM)
+ 1 1 1 1 0 0 0 0 (SC2)
1 1 1 1 1 0 0 1 (SC2)
Como el resultado es negativo, ste se encuentra en SC2 y debemos pasarlo a SM para obtener el
nmero que necesitamos. Si convertimos el nmero que nos dio como resultado (11111001)2 a
base diez, tendremos (-121)10; de all la importancia del SC2. Luego de convertir el resultado a SM
tendremos (10000111)2, que es equivalente a (-7)10.
1 1 1 1
(-9)
+ (-16)
(-25)
1 1 1 1 0 1 1 1 (SC2)
+ 1 1 1 1 0 0 0 0 (SC2)
1 1 1 0 0 1 1 1 (SC2)
Nuevamente tenemos un resultado negativo, y por ende se encuentra en SC2. Realizamos el

mismo proceso de pasar el resultado a SM para obtener el nmero que buscamos: (10011001)2
que es equivalente a (-25)10.
(-9)
+ (16)
(7)
1 1 1 1 0 1 1 1 (SC2)
+ 0 0 0 1 0 0 0 0 (SM)
0 0 0 0 0 1 1 1 (SM)
Este es el resultado que buscamos
DATOS NUMRICOS REALES

Los nmeros reales los representaremos en estructuras de 32 bits de dos formas: una que utiliza
exponente en base 2 y otra que utiliza exponente en base 16.
Estructura de 32 bits que utiliza exponente en base 2
La siguiente figura nos muestra cmo se representa la distribucin de los 32 bits:

1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
Mantisa
Caracterstica
Signo

Algoritmos II
Pg. 94
El primer bit es el bit del signo: 0 significa que el nmero es positivo, 1 que el nmero es
negativo.
Del bit 2 al 24 es un nmero binario conocido como mantisa.
Del bit 25 al 32 es un nmero decimal representando en binario conocido como
caracterstica.
Nuestros objetivos son nuevamente dos: uno, dada una estructura de estas, determinar el valor
representando en ella; y dos, teniendo un nmero real representarlo en dicha estructura.
Ocupmonos del primero de ellos.
Veamos el siguiente ejemplo:
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0
Para determinar el valor almacenado en una estructura de estas seguimos los siguientes pasos:
1. Determinar el signo del nmero. En nuestro ejemplo el prime bit es cero, por consiguiente
el nmero es positivo.
2. Determinar el valor de la caracterstica. Convertir el nmero de base 2 a base diez:
(10000100)2 = (132)10
3. Caracterstica = 132
4. Determinar el valor del exponente:
5. Exponente = caracterstica 128
6. Exponente = 132 128 = 4
El exponente nos indica cuntas veces debemos de correr el punto para obtener el valor
almacenado.
1. Valor almacenado = signo (.mantisa) * 2e
En nuestro ejemplo, tenemos que e=4:
Valor almacenado = + (.001010000000000000000000)*24
Ahora corremos el punto e veces, o sea, 4 veces:
Valor almacenado = + (0010.10)2

Algoritmos II
Pg. 95
2. Convertir el valor almacenado a base diez.

Entonces tenemos que:
Valor almacenado = +2.5
Veamos ahora el proceso inverso: representar (-65.125)10 en estructura de 32 bits que utiliza
exponente en base 2.
3. Convertir el 65.125 a base 2:
(65.125)10 = (1000001.001)2.
4. Determinar valor del exponente. Este se determina desplazando el punto de tal manera
que el nmero quede de la forma .1a, siendo a una hilera cualquiera de unos y ceros. Si el
punto hay que desplazarlo hacia la izquierda el valor del exponente es positivo, de lo
contrario es negativo. En nuestro ejemplo el punto hay que desplazarlo 7 posiciones hacia
la izquierda, por tanto el valor del exponente es 7.
Al desplazar el punto tendremos la mantisa que es (.1000001001
5. Calcular la caracterstica:
Exponente = caracterstica 128
Pero como ya conocemos el valor del exponente y necesitamos el de la caracterstica, pasamos el
128 al otro lado del igual con signo contrario. Entonces:
Caracterstica = 128 + exponente
Caracterstica = 128 + 7 = 135
6. Convertir la caracterstica a base 2
(135)10 = (10000111)2
7. Ubicamos el signo, la mantisa y la caracterstica dentro de nuestra estructura de 32 bits:
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
1 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1
El bit del signo es 1 porque inicialmente nuestro nmero era negativo (-65.125)10.

Algoritmos II
Pg. 96
Despus de ubicar la mantisa, llenamos los espacios sobrantes con ceros.

En la estructura de 32 bits que utiliza exponente en base de 16
La distribucin de los 32 bits con exponente base 16 se representa as:
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
Caracterstica
Mantisa
Signo
El primer bit es para el signo: 0 negativo, 1 positivo
Del bit 2 al 8 es la caracterstica, la cual es nmero decimal representado en binario.
Del bit 9 en adelante ser la mantisa.
Como esta es una estructura con exponente en base 16, la mantisa se convertir a base 16 para
mover el punto tantas veces como lo diga el exponente.
El valor almacenado ser: signo (.mantisa)*16e
Como ejemplo consideremos la siguiente estructura:
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
1 1 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0
8. Determinar el valor de la caracterstica.
Caracterstica = (1000011)2 = (67)10
1. Determinar el valor del exponente. Aqu la frmula para hallar el exponente es la
siguiente:
Exponente = caracterstica 64
Exponente = 67 64 = 3
2. Convertir la mantisa a base 16. Tomamos los dgitos desde el bit 9 hasta donde se halla el
ltimo 1. Agregamos ceros a la derecha para completar los grupos de 4 dgitos para la
conversin.
(0011100001110100)2 = (3874)16

Algoritmos II
Pg. 97
3. Valor almacenado = (.3874)16 *163

Corremos el punto tantas veces como lo indique el exponente
Valor almacenado = -(387.4)16
4. Convertimos el valor almacenado que est en base 16 a base diez.
(387.4)16 = (903.25)10
El proceso contrario consiste en teniendo un nmero en base diez, representarlo en estructura de
32 bits que utiliza exponentes en base 16. Ilustremos este proceso con un ejemplo: representar: el
(316.5)10 en estructura de 32 bits que utiliza exponentes en base 16.
1. Convertir 316.5 a base 16:
(316.5)10 = (13C.8)16
2. Mover el punto hacia el extremo izquierdo para determinar el valor del exponente:
(13C.8) = (.13C8)* 163. Por consiguiente el valor del exponente es 3.
3. Calcular la caracterstica:
Caracterstica = 64 + exponente
Caracterstica = 64 + 3 = 67
4. Convertir la caracterstica a base 2:
(67)10 = (1000011)2
5. Convertir la mantisa de base 16 a base 2:
(.13C8)16 = (0001001111001000)2
6. Construir la estructura:
1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
0 1 0 0 0 0 1 1 0 0 0 1 0 0 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
Despus de subir el signo, la caracterstica y la mantisa en nuestra estructura de 32 bits, los
espacios que quedan vacos a la derecha de la mantisa, se rellenan con ceros.

Algoritmos II
Pg. 98
EJERCICIOS
1. Representar en una estructura de 32 bits que utilice exponente en base 2 los siguientes
nmeros:
a. (5.141)10
b. (40252)10
2. Representar en una estructura de 32 bits que utilice exponente en base 16 los siguientes
nmeros:
a. (676.125)10
b. (5007)10
Prueba Final
1. Realice las siguientes conversiones:
a. (3F9.8)16 a ( )3
b. (21120212.200112)3 a ( )9
2.
a.
b.
c.
Realice las siguientes sumas en nmeros binarios:

15 + 32
42 31
-18 10
3. Representar en una estructura de 32 bits los siguientes nmeros:

a. (31675)10 con exponente en base 16
b. ( 564)10 con exponente en base 2

Algoritmos II
Pg. 99
5. EVALUACIN DE ALGORITMOS
OBJETIVO GENERAL
Medir la eficiencia de los algoritmos en cuanto a tiempo de ejecucin y en cuanto a consumo de
memoria.
Calcular el contador de frecuencias de un algoritmo.
Determinar el orden de magnitud de un algoritmo, con base al contador de frecuencias.
Prueba Inicial
1.
2.
3.
4.
En qu consiste el tiempo de ejecucin de un algoritmo?

Qu es una frecuencia?
Qu es una magnitud?
Qu es la memoria RAM?
EVALUACIN DE ALGORITMOS
La evaluacin de algoritmo consiste en medir la eficiencia de un algoritmo en cuanto a consumo
de memoria y tiempo de ejecucin.
Anteriormente, cuando existan grandes restricciones tecnolgicas de memoria, evaluar un
algoritmo en cuanto a consumo de recursos de memoria era bastante importante, ya que
dependiendo de ella los esfuerzos de programacin y de ejecucin sera grande. En la actualidad,
con el gran desarrollo tecnolgico del hardware, las instrucciones de consumo de memoria han
pasado a un segundo plano, por lo tanto, el aspecto de evaluar un algoritmo en cuanto a su
consumo de memoria no es relevante.
En cuanto al tiempo de ejecucin, a pesar de las altas velocidades de procesamiento que en la
actualidad existen, sigue siendo un factor fundamental, especialmente en algoritmos que tienen
que ver con el control de procesos en tiempo real y en aquellos cuya frecuencia de ejecucin es
alta.

Algoritmos II
Pg. 100
Procedamos entonces a ver como determinar el tiempo de ejecucin de un algoritmo.

Bsicamente existen dos formas de hacer esta medicin: una que llamamos a posteriori y otra que
llamamos a priori.
Consideremos la primera forma, a posteriori: el proceso de elaboracin y ejecucin de un
algoritmo consta de los siguientes pasos:
Elaboracin del algoritmo.
Codificacin en algn lenguaje de programacin.
Compilacin del programa.
Ejecucin del programa en una maquina determinada.
Cuando se ejecuta el programa, los sistemas operativos proporcionan la herramienta de informar
cunto tiempo consumi la ejecucin del algoritmo.
Esta forma de medicin tiene algunos inconvenientes: al codificar el algoritmo en algn lenguaje
de programacin estamos realmente midiendo la eficiencia del lenguaje de programacin, ya que
no es lo mismo un programa codificado en FORTRAN, que en PASCAL o que en C; al ejecutar un
programa en una mquina determinada estamos introduciendo otro parmetro, el cual es la
eficiencia de la mquina, ya que no es lo mismo ejecutar el programa en un XT, en un 386, en un
486, en un Pentium, es un AS400, es un RISC, etc.
En otras palabras con esta forma de medicin estamos es evaluando la calidad del compilador y de
la mquina, ms no la del algoritmo, que es nuestro inters.
Lo que nos interesa es medir la eficiencia del algoritmo por el hecho de ser ese algoritmo,
independiente del lenguaje en el que se haya codificado y de la mquina en la cual se ejecute.
Veamos entonces la forma de medir la ejecucin de un algoritmo a priori. Para ello necesitamos
definir dos conceptos bsicos que son: Contador de frecuencias y Orden de magnitud.
5.1. Contador de Frecuencias

El contador de frecuencias es una expresin algebraica que identifica el nmero de veces que se
ejecutan las instrucciones de un algoritmo. Para ilustrar como determinar esta expresin
consideramos los siguientes ejemplos:

Algoritmos II
Pg. 101
Algoritmo 1
1.
2.
3.
4.
5.
6.
LEA (a, b, c)
x=a+b
y=a+c
z=b*c
w=x/yz
IMPRIMA (a, b, c, w)
1
1
1
1
1
1
Contador de frecuencias
Algoritmo 2
1.
2.
3.
4.
5.
6.
7.
8.
LEA (n)
s=0
i=1
MQ (i <= n)
s=s+1
i=i+1
FINMQ
IMPRIMA (n, s)
1
1
1
n+1
n
n
n
1
4n+5
En todos los algoritmos las instrucciones estn numeradas secuencialmente. Al frente de cada
instruccin aparece un nmero o una letra que indica el nmero de veces que se ejecuta esa
instruccin en e l algoritmo.
En el algoritmo 1 cada instruccin se ejecuta solo una vez. El total de veces que se ejecutan todas
las instrucciones es 6. Este valor es el contador de frecuencias para el algoritmo 1.
En el algoritmo 2 las instrucciones 1, 2, 3 y 8 se ejecutan solo una vez, mientras que las
instrucciones 5, 6 y 7 se ejecutan n veces cada una, ya que pertenece a un ciclo, cuya variable
controladora del ciclo se inicia en uno, tiene un valor final de n y se incrementa de a uno, la
instruccin 4 se ejecuta una vez ms ya que cuando i sea mayor que n de todas formas hace la
pregunta para luego salir del ciclo. Por tanto, el nmero de veces que se ejecutan las instrucciones
del algoritmo es 4n + 5. Esta expresin es el contador de frecuencias para el algoritmo 2.
Veamos otros ejemplos de algoritmos con su contador de frecuencias respectivo

Algoritmos II
Pg. 102
Algoritmo 3
1. LEA (m, n)
2. s = 0
3. i = 1
4. MQ (i <= n)
5.
t=0
6.
j=1
7.
MQ (j <= m)
8.
t=t+1
9.
j=j+1
10.
FINMQ
11.
s=s+t
12.
i=i+1
13. FINMQ
14. IMPRIMA (n, m, s)
1
1
1
n+1
n
n
n*m+n
n*m
n*m
n*m
n
n
n
1
4(n*m)+7n+5
Algoritmo 4
1. LEA (n, m)
2. s = 0
3. i = 1
4. MQ (i <= n)
5.
t=0
6.
j=1
7.
MQ (j <= n)
8.
t=t+1
9.
j=j+1
10.
FINMQ
11.
s=s+t
12.
i=i+1
13. FINMQ
14. IMPRIMA (n, m, s)
1
1
1
n+1
n
n
n2+n
n2
n2
n2
n
n
n
1
4n2+7n+5

Algoritmos II
Pg. 103
Algoritmo 5
1. LEA (n, m)
2. s = 0
3. i = 1
4. MQ (i <= n)
5.
s=s+1
6.
i=i+1
7. FINMQ
8. IMPRIMA (n, s)
9. t = 0
10. i = 1
11. MQ (i <= m)
12.
t=t+1
13.
i=i+1
14. FINMQ
15. IMPRIMA (m, t)
1
1
1
n+1
n
n
n
1
1
1
m+1
m
m
m
1
4m+4n+9
De una manera anloga se obtuvieron los contadores de frecuencias para los algoritmos 3, 4 y 5.
EJERCICIOS
Calcule el contador de frecuencias de los siguientes algoritmos:
1. VOID PROGRAMA_1 (n)
2.
s=0
3.
PARA (i= 1, n, 1)
4.
PARA (j= 1, i, 1)
5.
PARA (k= 1, j, 1)
6.
s=s+1
7.
FINPARA
8.
FINPARA
9.
FINPARA
10. FIN
1. ALGORITMO PROGRAMA_2
2.
LEA (n)
3.
s=0
4.
i=2

Algoritmos II
Pg. 104
5.
MQ (i <= n)
6.
s=s+1
7.
i=i*i
8.
FINMQ
9.
IMPRIMA (n, s)
10. FIN
2.
LEA (n)
3.
s=0
4.
PARA (i= 1, n, 1
5.
t=0
6.
PARA (j= 1, i, 1)
7.
t=t+1
8.
FINPARA
9.
s=s+t
10.
FINPARA
11.
IMPRIMA (n, s)
12. FIN
5.2. Orden de Magnitud

El orden de magnitud es el concepto que define la eficiencia del algoritmo en cuanto a tiempo de
ejecucin. Se obtiene a partir del contador de frecuencias.
Para obtener el orden de magnitud seguimos los siguientes pasos: Se eliminan los coeficientes, las
constantes y los trminos negativos de los trminos resultantes; si son dependientes entre s, se
elige el mayor de ellos y este ser el orden de magnitud de dicho algoritmo, de lo contrario el
orden de magnitud ser la suma de los trminos que quedaron. Si el contador de frecuencias es
una constante, como en el caso del algoritmo 1, el orden de magnitud es 1 y lo representamos
como O(1).
Teniendo presente esto, los rdenes de magnitud de los algoritmos que vimos anteriormente son:
Algoritmo 1: O(1)
Algoritmo 2: O(n)
Algoritmo 3: O(n*m)
Algoritmo 4: O(n2)

Algoritmos II
Pg. 105
Algoritmo 5: O(n+m)
Es bueno aclarar lo siguiente: en los ejemplos, el valor de n es un dato que se lee dentro del
programa. En el caso ms amplio, n podr ser el nmero de registros que haya que procesar en un
archivo, el nmero de datos que haya que producir como salida, o quiz otro parmetro diferente;
es decir, hay que poner atencin en el anlisis que se haga del algoritmo, de cul es el parmetro
que tomamos como n.
En el ambiente de sistemas, los rdenes de magnitud ms frecuentes para los algoritmos que se
desarrollan son:
ORDEN DE MAGNITUD
REPRESENTACIN
Constante
O(1)
Lineal
Cuadrtico
Cubico
O(n)
O(n2)
O(n3)
Logartmico
O(log2(n))
Semilogartmico
exponencial
O(n log2(n))
O(2n)
Si quisiramos clasificar estas rdenes de magnitud desde la ms eficiente hasta la menos

eficiente, tendramos el siguiente orden:
1.
2.
3.
4.
5.
6.
7.
Constante
Logartmico
Lineal
Semilogartmico
Cuadrtico
Cbico
Exponencial
O(1)
O(log2(n))
O(n)
O(n log2(n))
O(n2)
O(n3)
O(2n)
Hasta aqu hemos visto algoritmos cuyo orden de magnitud es constante, lineal y cuadrtico. De
igual manera que se hizo el algoritmo con orden de magnitud cuadrtico se puede hacer uno
cbico; en el cuadrtico se necesitaron 2 ciclos anidados, controlados por la misma variable, para
el cbico se necesitaran 3 ciclos con las mismas condiciones.
Pasemos a tratar algoritmos con orden de magnitud logartmicos. Empecemos definiendo lo que
es un logaritmo.

Algoritmos II
Pg. 106
La definicin clsica del logaritmo de un nmero x es: es el exponente al cual hay que elevar un
nmero llamado base para obtener x.
Con fines didcticos, presentamos otra definicin de logaritmo: logaritmo de un numero x es el
nmero de veces que hay que dividir un nmero, por otro llamado base, para obtener como
cociente uno (1).
Por ejemplo, si tenemos el nmero 100 y queremos hallar su logaritmo en base 10, habr que
dividirlo por 10 sucesivamente hasta obtener como cociente uno (1).
100
0
10
10
0
10
1
Hubo que dividir el 100 dos veces por 10 para obtener 1 en el cociente, por tanto el logaritmo en
base 10 de 100 es 2 (log10 (100) = 2).
Si queremos hallar el logaritmo en base 2 de 16 habr que dividir 16 sucesivamente por 2 hasta
obtener un cociente de 1. Veamos:
16
0
2
8
0
2
4
0
2
2
0
2
1
Es decir, hubo que dividir el 16, cuatro (4) veces por dos (2) para obtener un cociente de 1, por
tanto el logaritmo en base 2 de 16 es 4 (log2 (16) = 4).
Planteemos un ejemplo prctico de algoritmo en el cual se presenta esta situacin.
Consideremos el caso de un vector en el cual tenemos los datos ordenados ascendentemente:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
V 2 4 7 9 11 15 17 28 31 36 43 50 58 62 69
Si nos interesa buscar el dato x = 85 y decir en cual posicin del vector se encuentra hay dos
formas de hacerlo:

Algoritmos II
Pg. 107
Una, es hacer una bsqueda secuencial a partir del primer elemento e ir comparando el contenido
de esa posicin con el dato x (85), el proceso terminar cuando lo encontremos o cuando hayamos
recorrido todo el vector y no lo encontremos. Un pequeo algoritmo que haga ese proceso es el
siguiente:
Sea n el nmero de elementos del vector y x el dato a buscar.
i=1
MQ ((i <= n) & (V[i] != x))
i=i+1
FINMQ
SI (i <= n)
Pos = i
SINO
IMPRIMA (el dato no existe)
FINSI
En dicho algoritmo tenemos planteado un ciclo, el cual, en el peor de los casos, se ejecuta n veces,
es decir, cuando el dato x no est en el vector. Por tanto el orden de magnitud de ese algoritmo es
O(n).
En general, cuando se efecta una bsqueda, el peor caso es no encontrar lo que se est
buscando.
En nuestro ejemplo hubo que hacer 15 comparaciones para poder decir que el 85 no est en el
vector.
Si el vector hubiera tenido un milln de datos y hubiramos tenido que buscar un dato que no
estaba, hubiramos tenido que haber hecho un milln de comparaciones para poder decir que el
dato buscado no se encontr.
Ahora, si aprovechamos la caracterstica de que los datos en el vector estn ordenados podemos
plantear otro mtodo de bsqueda:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
V 2 4 7 9 11 15 17 28 31 36 43 50 58 62 69
M
Comparamos el dato x con el dato del elemento de la mitad del vector, (llammoslo M). Pueden
suceder tres casos: V(M) == x; V(M) > x; V(M) < x

Algoritmos II
Pg. 108
Si V(M) == x se ha terminado la bsqueda.

Si V(M) > x significa que el dato x, si se encuentra en el vector, estar en la primera mitad del
vector.
Si V(M) < x significa que si el dato x se encuentra en el vector, estar en la segunda mitad del
vector.
En nuestro ejemplo, para seguir buscando el dato x (85) lo haremos desde la posicin 9 hasta la
posicin 15.
Es decir, con unas comparaciones hemos eliminado la mitad de los datos sobre los cuales hay que
efectuar la bsqueda. En otras palabras, hemos dividido la muestra por dos (2).
El conjunto de datos sobre el cual hay que efectuar la bsqueda queda as:
9 10 11 12 13 14 15
31 36 43 50 58 62 69
M
De la mitad que quedo escogemos nuevamente el elemento de la mitad y repetimos la
comparacin planteada anteriormente. Con esta comparacin eliminamos nuevamente la mitad
de los datos que nos quedan, es decir, dividimos nuevamente por dos.
Si continuamos este proceso, con cuatro comparaciones podremos afirmar que el dato x no est
en el vector.
Hemos reducido el nmero de comparaciones de 15 a 4.
Cuatro (4) es el logaritmo en base 2 de 15, aproximndolo por encima.
Si N fuera 65000, con 16 comparaciones podremos decir que un dato no se encuentra en un
conjunto de 65000 datos.
Como puede observarse, la ganancia en cuanto al nmero de comparaciones es grande.
Un algoritmo de bsqueda que funcione con esta tcnica tiene orden de magnitud logartmico en
base dos, ya que la muestra de datos se divide sucesivamente por dos.

Algoritmos II
Pg. 109
Consideremos ahora, algoritmos sencillos cuyo orden de magnitud es logartmico:

n = 32
s=0
i = 32
MQ (i > 1)
s=s+1
i=i/2
FINMQ
IMPRIMA (n, s)
En el algoritmo anterior, la variable controladora del ciclo es i, y dentro del ciclo, i se divide por
dos (2). Si hacemos un seguimiento detallado tendremos:
La primera vez que se ejecuta el ciclo, la variable i sale valiendo 16.
La segunda vez que se ejecuta el ciclo, la variable i sale valiendo 8.
La tercera vez que se ejecuta el ciclo, la variable i sale valiendo 4.
La cuarta vez que se ejecuta el ciclo, la variable i sale valiendo 2.
La quinta vez que se ejecuta el ciclo, la variable i sale valiendo 1 y termina el ciclo.
Es decir, las instrucciones del ciclo se ejecutan 5 veces.
Cinco (5) es el logaritmo en base dos (2) de n (32), por consiguiente, cada instruccin del ciclo se
ejecuta un nmero de veces igual al logaritmo en base dos de n. El contador de frecuencias y el
orden de magnitud de dicho algoritmo se presentan a continuacin:
n = 32
s=0
i = 32
MQ (i > 1)
s=s+1
i=i/2
FINMQ
IMPRIMA (n, s)
Orden de magnitud
1
1
1
log2 n + 1
log2 n
log2 n
log2 n
1
4 log2 n + 5
O(log2 (n))
Eliminando constantes y coeficientes el orden de magnitud es O(log2n).


Algoritmos II
Pg. 110
Consideremos este nuevo algoritmo:

n = 32
s=0
i=1
MQ (i < n)
s=s+1
i=i*2
FINMQ
IMPRIMA (n, s)
1
1
1
log2 n + 1
log2 n
log2 n
log2 n
1
En este logaritmo la variable controladora del ciclo i se multiplica por dos dentro del ciclo.
Haciendo un seguimiento tendremos:
En la primera pasada, la variable i sale valiendo 2.
En la segunda pasada, la variable i sale valiendo 4.
En la tercera pasada, la variable i sale valiendo 8.
En la cuarta pasada, la variable i sale valiendo 16.
En la quinta pasada, la variable i sale valiendo 32 y el ciclo se termina.
Las instrucciones del ciclo se ejecutan 5 veces, por tanto el orden de magnitud del algoritmo es
logartmico en base 2 (O(log2 n)).
En general, para determinar si un ciclo tiene orden de magnitud lineal o logartmico, debemos
fijarnos cmo se est modificando la variable controladora del ciclo: Si esta se modifica mediante
sumas o restas el orden de magnitud del ciclo es lineal, si se modifica con multiplicaciones o
divisiones el orden de magnitud del ciclo es logartmico.
Consideremos ahora el siguiente algoritmo:
n = 81
s=0
i = 81
MQ (i > 1)
s=s+1
i=i/3
FINMQ
IMPRIMA (n, s)

Algoritmos II
Pg. 111
Aqu, la variable controladora del ciclo i se divide por tres dentro del ciclo.
Hacindole el seguimiento tendremos:
En la primera pasada, la variable i sale valiendo 27.
En la segunda pasada, la variable i sale valiendo 9.
En la tercera pasada, la variable i sale valiendo 3.
En la cuarta pasada, la variable i sale valiendo 1, y termina el ciclo.
Las instrucciones del ciclo se ejecutaron 4 veces. Cuatro es el logaritmo en base 3 de 81. Por
consiguiente el orden de magnitud de dicho algoritmo es logartmico en base 3 (O(log3 n)).
En general, si tenemos un algoritmo:
n = 81
s=0
i = 81
MQ (i > 1)
s=s+1
i=i/X
FINMQ
IMPRIMA (n, s)
Aqu, la variable controladora del ciclo se divide por x. El nmero de veces que se ejecutan las
instrucciones del ciclo es logaritmo en base x de n (O(logx n)), por tanto el orden de magnitud es
logaritmo en base x.
Para obtener algoritmos con orden de magnitud semilogartmico basta con que un ciclo
logartmico se ubique dentro de un ciclo con orden de magnitud n (O(n)) o viceversa.
Por ejemplo:
LEA (n)
s=0
i=1
MQ (i <= n)
t=0
j=n
MQ (j > 1)
1
1
1
n+1
n
n
n*log2n +n

Algoritmos II
Pg. 112
t=t+1
j=j/2
n*log2n
n*log2n
n*log2n
FINMQ
IMPRIMA (t)
s=s+t
i=i+1
n
n
n
FINMQ
IMPRIMA (n, s)
n
1
Orden de magnitud
4nlog2n+8n+5
O(n log2n)
En el algoritmo anterior orden de magnitud es semilogartmico.

Digamos que la idea es elaborar algoritmos lo ms eficientes posible. Consideremos el siguiente
problema:
Elaborar algoritmo que lea un entero positivo n y que determine la suma de los enteros desde 1
hasta n.
Una solucin es la siguiente:
LEA (n)
s=0
i=1
MQ (i <= n)
s=s+i
i=i+1
FINMQ
IMPRIMA (n, s)
El anterior algoritmo lee un dato entero n (n>0), calcula e imprime la suma de los enteros desde 1
hasta n, y el orden de magnitud de ste es O(n).
Matemticamente hablando, la sumatoria de los enteros desde 1 hasta n, se representa as:
Esta representacin, convertida en frmula matemtica, quedara de la siguiente forma:


Algoritmos II
Pg. 113
n * (n + 1)
2
Conociendo esta frmula, podemos elaborar otro algoritmo que ejecute exactamente la misma
tarea que el anterior. Veamos cmo sera:
LEA (n)
s = n * (n + 1) / 2
IMPRIMA (n, s)
ste algoritmo tiene orden de magnitud lineal (O(1)). Es decir, tenemos dos algoritmos
completamente diferentes que ejecutan exactamente la misma tarea, uno con orden de magnitud
O(n) y el otro con orden de magnitud O (1).
Lo anterior no significa que toda tarea podr ser escrita con algoritmos O(1), no, sino que de
acuerdo a los conocimientos que se tengan o a la creatividad de cada cual, se podr elaborar
algoritmos ms eficientes.
Este ejemplo, el cual es vlido, desde el punto de vista de desarrollo de algoritmos, es aplicable
tambin a situaciones de la vida real. Seguro que alguna vez usted tuvo algn problema, y
encontr una solucin, y sali del problema, aplicando la solucin que encontr, y sin embargo, al
tiempo, dos o tres meses despus, pesando en lo que haba hecho, encontr que pudo haber
tomado una mejor determinacin y que le habra ido mejor.
La enseanza es que cuando se nos presente un problema debemos encontrar como mnimo dos
soluciones y luego evaluar cul es ms apropiada.
EJERCICIOS
Determine el orden de magnitud de los siguientes algoritmos, a los cuales en un ejercicio pasado
les calculamos el contador de frecuencias:
1. VOID PROGRAMA_1 (n)
2.
s=0
3.
PARA (i= 1, n, 1)
4.
PARA (j= 1, i, 1)
5.
PARA (k= 1, j, 1)
6.
s=s+1
7.
FINPARA

Algoritmos II
Pg. 114
8.
FINPARA
9.
FINPARA
10. FIN
2.
LEA (n)
3.
s=0
4.
i=2
5.
MQ (i <= n)
6.
s=s+1
7.
i=i*i
8.
FINMQ
9.
IMPRIMA (n, s)
10. FIN
2.
LEA (n)
3.
s=0
4.
PARA (i= 1, n, 1
5.
t=0
6.
PARA (j= 1, i, 1)
7.
t=t+1
8.
FINPARA
9.
s=s+t
10.
FINPARA
11.
IMPRIMA (n, s)
12. FIN
Prueba Final
Elabore los siguientes algoritmos y determine el contador de frecuencias y el orden de magnitud
de dichos algoritmos:
1. Realizar un algoritmo que calcule la suma de la siguiente serie aritmtica para n trminos:
2, 5, 8, 11, 14,...., n
2. Realizar un algoritmo que calcule la suma de la siguiente serie aritmtica para n trminos:
2, 4, 8, 16, 32, 64,., n

Algoritmos II
Pg. 115
5.3. Pistas de Aprendizaje

Recuerde que a la hora de intercambiar datos dentro de un vector o una
matriz, primero debe guardar el contenido de una celda a dentro de una
variable auxiliar, para no perder lo que hay en a; luego a la celda a le
lleva lo que tiene la celda b; y por ltimo, a la celda b le lleva lo que
guard en la variable auxiliar. As por ejemplo:
aux = vec[i]
vec[i] = vec[k]
vec[k] = aux
Recuerde que los parmetros por referencia son aquellas variables que
se modificarn dentro del subprograma y volvern al programa principal
con su valor modificado.
Recuerde que en la suma de nmeros binarios, al sumar 1+1 el resultado
ser 0 y llevaremos 1 para la siguiente posicin.
No olvide pasar los nmeros negativos a signo-complemento a dos antes
de sumarlos.
Tenga en cuenta los siguientes puntos en la suma de binarios:
Si el entero es positivo, llvelo a signo-magnitud (SM)
Si el entero es negativo, llvelo a signo-complemento a dos (SC2)
Si al sumar los dgitos ocurre un acarreo en el bit del signo y sobra un
dgito, ignrelo
Si el resultado de la suma es positivo, ste se encuentra en signomagnitud (SM)
Si el resultado de la suma es negativo, ste se encuentra en signocomplemento a dos (SC2) y se debe llevar a SM para obtener el valor
deseado.
Para pasar de SC2 a SM primero intercambiamos ceros y unos, y luego
sumamos 1
Recuerde que al representar un nmero entero en una estructura de 8
bits, los espacios vacos se rellenan con ceros. Los espacios vacos (si los
hay) deben estar entre el bit del signo y el nmero ya convertido en

Algoritmos II
Pg. 116
binario.
No olvide que al representar un nmero real en una estructura de 32
bits, los espacios que quedan vacos dentro de la estructura se rellenan
con ceros.
Tenga en cuenta que cuando se busca el contador de frecuencias de un
algoritmo, y en ste hay una instruccin que se ejecuta n*n veces, lo
representamos como n2; y si existe una instruccin que se ejecuta n*n*n
veces, sta instruccin la representamos como n3.
Recuerde que en la multiplicacin, tener 2*n es lo mismo que tener 2n.
Igualmente con los logaritmos: n*log2n es lo mismo que nlog2n.

Algoritmos II
Pg. 117
Glosario
Factorial. Se llama factorial de n al producto de todos los nmeros naturales desde 1 hasta n.
Frecuencia. Repeticin mayor o menor de un acto o de un suceso.
Magnitud. Grandeza, excelencia o importancia de algo.
Mantisa. Es la parte decimal de un logaritmo. En un nmero de punto flotante es el valor que
sigue a la potencia de la base.
Matriz transpuesta. Matriz donde el elemento aji de la matriz original A se convertir en el
elemento aij de la matriz transpuesta At.
Parmetro. Variable que, en una familia de elementos, sirve para identificar cada uno de ellos
mediante su valor numrico
Potencia. Producto que resulta de multiplicar una cantidad o expresin por s misma una o ms
veces.
Void. Significa vaco, esto indica que la funcin no devuelve nada si no que realiza ciertas
acciones.

Algoritmos II
Pg. 118
5.4. Referencias Bibliogrficas

Joyanes Aguilar, L. (1996). Fundamentos de programacin: Algoritmos y estructura de datos.
McGraw Hill/Interamericana de Espaa S.A.
Oviedo Regino, E. M. (2004). Lgica de programacin, segunda edicin. ECOE ediciones: Bogot.
Villalobos S., J. A., & Casallas G., R. (2006). Fundamentos de programacin, aprendizaje activo
basado en casos primera edicin. Bogot: Pearson educacin de Mxico S.A. de C.V.
Cairo, O., & Guardati Buemo, S. (1998). Estructuras de datos. McGraw-Hill Interamericano de
Mxico S.A.
Programacin en Castellano. (s.f.). Recuperado el 9 de Junio de 2011, de
http://www.programacion.com/articulo/introduccion_a_la_programacion_205/7
Universidad Nacional de Colombia sede Bogot. (s.f.). Recuperado el 8 de Abril de 2011, de
http://www.virtual.unal.edu.co/cursos/ingenieria/2001839/docs_curso/contenido.html
Canaria, D. d. (s.f.). Grupo de Estructuras de Datos y Lingstica Computacional. Recuperado el 6
de Junio de 2011, de http://www.gedlc.ulpgc.es/docencia/NGA/subprogramas.html
Granada, U. d. (s.f.). www.ugr.es. Recuperado el 9 de Junio de 2011, de
http://elvex.ugr.es/decsai/c/apuntes/vectores.pdf
TECNOLGICO. (s.f.). Obtenido de http://www.mitecnologico.com/:
http://www.mitecnologico.com/Main/ArreglosVectoresYMatrices
Universidad Tecnolgica de Pereira. (s.f.). Recuperado el 6 de Junio de 2011, de
http://www.utp.edu.co/~chami17/sn.htm
Vieyra, G. E. (31 de Agosto de 2000). Facultad de Ciencias Fsico-Matemticas UMSNH.
Recuperado el 8 de Junio de 2011, de http://www.fismat.umich.mx/~elizalde/curso/node110.html
Wikipedia. (s.f.). Recuperado el 8 de Junio de 2011, de
http://es.wikipedia.org/wiki/Sistema_de_numeraci%C3%B3n

02 Algoritmos II

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

02 Algoritmos II

Cargado por

Copyright:

Formatos disponibles

ESCUELA DE CIENCIAS BSICAS E INGENIERA

CORPORACIN UNIVERSITARIA REMINGTON

Corporacin Universitaria Remington Direccin Pedaggica

El mdulo de estudio de la asignatura Algoritmos II es propiedad de la Corporacin Universitaria Remington. Las

Corporacin Universitaria Remington Direccin Pedaggica

MAPA DE LA ASIGNATURA ............................................................................................. 7

Subprogramas Tipo Funcin .................................................................................................... 9

Parmetros y Variables ......................................................................................................... 16

Arreglos de Registros ............................................................................................................ 77

SISTEMAS NUMRICOS ................................................................................................ 84

Sistemas Numricos Pesados y Conversiones....................................................................... 84

Representacin de Datos en un Computador ....................................................................... 89

EVALUACIN DE ALGORITMOS .................................................................................... 99

Contador de Frecuencias..................................................................................................... 100

Orden de Magnitud ............................................................................................................. 104

Pistas de Aprendizaje .......................................................................................................... 115

Referencias Bibliogrficas ................................................................................................... 118

Corporacin Universitaria Remington Direccin Pedaggica

PROPSITO GENERAL DEL MDULO

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

2.1. Subprogramas Tipo Funcin

Corporacin Universitaria Remington Direccin Pedaggica

La cual se lee: el total de combinaciones de n elementos tomados en grupos de a r elementos es el

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

1. ENTERO FACTORIAL (m)

En la instruccin 1 definimos el nombre del subprograma y lo precedemos con la palabra ENTERO,

Tema 2: SUBPROGRAMAS TIPO VOID

Corporacin Universitaria Remington Direccin Pedaggica

1. VOID nombre subprograma (parmetros)

Corporacin Universitaria Remington Direccin Pedaggica

En la primara instruccin definimos el nombre del subprograma, el cual llamamos TITULOS, y le

Corporacin Universitaria Remington Direccin Pedaggica

2.2. Parmetros y Variables

Corporacin Universitaria Remington Direccin Pedaggica

1. VOID DEMO (por valor: x, y; por referencia: z)

En el algoritmo que hemos llamado PARMETROS, se definen tres variables enteras a, b y c,

Corporacin Universitaria Remington Direccin Pedaggica

En el subprograma DEMO se definen tres parmetros x, y, z. Los parmetros x, y se definen

Estado de la memoria cuando se invoca el subprograma

Corporacin Universitaria Remington Direccin Pedaggica

El resultado de efectuar estas operaciones se refleja en la siguiente figura:

Estado de la memoria despus de ejecutar el subprograma

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

vnom [1] = Ana

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

Nuestro algoritmo es:

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

IMPRIMA (acmpio [4])

Corporacin Universitaria Remington Direccin Pedaggica

Corporacin Universitaria Remington Direccin Pedaggica

SUMA DE LOS DATOS DE UN VECTOR

Corporacin Universitaria Remington Direccin Pedaggica

1. ENTERO MAYOR_DATO (V, m)

Para ilustrar como funciona este algoritmo consideremos el siguiente grfico: