MÓDULO Algoritmos - II. Ingeniería Sistemas

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
TABLA DE CONTENIDO 1. 2. 2.1. 2.2. 3. 3.1. 3.2. 3.3. 4. 4.1. 4.2. 5. 5.1. 5.2. 5.3. 5.4. MAPA DE LA ASIGNATURA ............................................................................................. 7 SUBPROGRAMAS ........................................................................................................... 8 Subprogramas Tipo Funcin ............................................................................................... 9 Parmetros y Variables ..................................................................................................... 16 ARREGLOS ................................................................................................................... 21 Vectores ........................................................................................................................... 21 Matrices ........................................................................................................................... 53 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
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
SUBPROGRAMAS
UNIDAD 2
ARREGLOS
UNIDAD 3
SISTEMAS NUMRICOS
UNIDAD 4
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.
2. SUBPROGRAMAS
OBJETIVO GENERAL Reconocer cundo hacer uso de un subprograma, y qu tipo de subprograma utilizar. OBJETIVOS ESPECFICOS 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:
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
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:
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:
1. ALGORITMO COMBINACIONES(2) 2. VARIABLES: 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 = FACTORIAL (n) 9. fr = FACTORIAL (r) 10. fnr = FACTORIAL (n r) 11. tc = fn / (fr * fnr) 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: fnr = FACTORIAL (n r) 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:
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:
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: CORPORACIN UNIVERSITARIA REMINGTON ESCUELA DE CIENCIAS BSICAS E INGENIERA 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.
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: 1. ALGORITMO COMBINACIONES(3) 2. VARIABLES: 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. TITULOS (combinaciones) 9. fn = FACTORIAL (n) 10. fr = FACTORIAL (r) 11. fnr = FACTORIAL (n r) 12. tc = fn / (fr * fnr) 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: CORPORACIN UNIVERSITARIA REMINGTON ESCUELA DE CIENCIAS BSICAS E INGENIERA INGENIERA DE SISTEMAS ALGORITMOS II ALGORITMO: combinaciones n=5 r=3 total de combinaciones = 10
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.
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.
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 2 a 5 8 b 6 9 y x DEMO 2 19 8 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.
El resultado de efectuar estas operaciones se refleja en la siguiente figura: MEMORIA PARMETROS 2 a 5 8 b 6 45 y x DEMO 2 19 40 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.
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.
3. ARREGLOS
OBJETIVO GENERAL Identificar las diferentes estructuras estticas de almacenamiento de informacin, de una o ms dimensiones. OBJETIVOS ESPECFICOS 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:
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: 1 Ana 2 Pedro 3 Luis 4 Ral 5 Mara 6 Jos
vnom 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
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. IMPRIMA (Ingrese nombre) 8. LEA (vnom[i]) 9. FINPARA 10. PARA (i= 1, n, 1) 11. IMPRIMA (vnom[i]) 12. FINPARA 12. FININICIO 14. FIN
Tamao desconocido 1. ALGORITMO VECTOR_DESCONOCIDO 2. VARIABLES: vnom[], nom (ALFANUMRICO) n (ENTERO) 3. INICIO 4. n=0 5. IMPRIMA (Ingrese nombre) 6. LEA (nom) 7. MQ (nom != xx) 8. n=n+1 9. vnom[n] = nom 10. IMPRIMA (Ingrese nombre) 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:
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)
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: 1. Medelln: (acmed) 2. Bello: (acbel) 3. Itag: (acita) 4. Envigado: (acenv)
Mpio:
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
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:
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
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.
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:
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.
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
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:
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. VARIABLES: i (ENTERO) 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.
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 1 V 3 2 5 3 7 4 11 5 18 6 23 7 36 8 9 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
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 1 V 3 2 5 3 7 4 10 5 11 6 18 7 23
m 8 36 9
n 10
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 2 3 4 5 6
m 7 8 9
n 10
3 1 6 2 8 9 4
1. ENTERO BUSCAR_POSICION_DATO (V, m, d) 2. VARIABLES: i (ENTERO) 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:
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 1 V 3 2 1 3 6 4 2 5 8 6 9 7 4 8 9
n 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.
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 1 V 3 2 1 3 6 4 8 5 9 6 4 7 8 9 n 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
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.
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:
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
ls
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 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 m ls
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
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:
li
ls n 15 73
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
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:
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.
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 k j
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.
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 K J
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 k j
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.
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 k j
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
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.
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 Parte 4 1 3 2 6 8 4 Primera pasada: cinco comparaciones
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. En la parte 3 se compara el dato de la posicin 3 con el dato de la posicin 4. Como el dato de la 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. En la parte 4 se compara el dato de la posicin 4 con el dato de la posicin 5. Como el dato de la posicin 4 es menor que el dato de la posicin 5, los datos permanecen intactos. En la parte 5 se compara el dato de la posicin 5 con el dato de la posicin 6. Como el dato de la 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.
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 Parte 3 1 2 3 6 4 8 Segunda pasada: cuatro comparaciones
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:
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.
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,
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: a11 a21 A= ai1 amj a12 a22 ai2 am2 a1j a2j aij amj a1n a2n ain 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:
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.
mat 1 1 2 m 3 6 2 0 2 0 0 1 3 7 9 0
n 4 0 8 0
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.
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. VARIABLES: i, j (ENTEROS) 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.
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. VARIABLES: i, j (ENTEROS) 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.
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. VARIABLES: i, j (ENTEROS) 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.
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.
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 9 5 3 8 6 2 2 1 7 6 5 4 3 5 3 6 7 2 5 5 5 7 4 2 4 8 4 8 9 5 5 8 1 5 8 8 8 4 6 4 2 4 9 7 4 4 7 5 4 7 3 6 2 1
1 2 3 4 5 6 7
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.
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:
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.
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:
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 1 1 2 3 4 5 6 n 7 3 9 5 3 8 6 2 2 1 7 6 5 4 3 5 3 6 7 2 5 5 5 7 4 2 4 8 4 8 9 5 5 8 1 5 8 8 8 4 6 4 2 4 9 7 4 4 7 5 4 7 3 6 2 1
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.
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.
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 1 2 3 4 5 6 n 7 3 9 5 3 8 6 2 2 1 7 6 5 4 3 5 3 6 7 2 5 5 5 7 4 2 4 8 4 8 9 5 5 8 1 5 8 8 8 4 6 4 2 4 9 7 4 4 7 5 4 7 3 6 2 1
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
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 1 2 3 4 5 m 6 3 4 5 4 4 1 (a) 2 1 1 3 3 2 8 3 6 2 7 6 5 9 4 2 8 1 3 4 7 5 8 2 3 2 1 1 6 9 5 5 8 1 3 7 7 7 5 1 6 9 1 2 3 4 5 m 6 1 3 4 5 4 4 1 (b) 2 1 2 3 3 1 8 3 6 5 7 6 2 9 4 2 4 1 3 8 7 5 8 1 3 2 2 1 6 9 1 5 8 5 3
n 7 7 6 5 1 7 9
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.
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 1 2 3 4 5 m 6 3 4 5 4 4 1 (a) 2 1 1 3 3 2 8 3 6 2 7 6 5 9 4 2 8 1 3 4 7 5 8 2 3 2 1 1 6 9 5 5 8 1 3 7 7 7 5 1 6 9 n 1 2 3 4 5 6 1 3 4 5 4 4 1 (b) 2 8 2 3 2 1 1 3 6 2 7 6 5 9 4 2 8 1 3 4 7 5 1 1 3 3 2 8 6 9 5 5 8 1 3
n 7 7 7 5 1 6 9
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.
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 1 2 3 4 m 5 3 1 6 2 8 2 1 2 4 9 5 3 4 5 2 3 8 4 9 7 5 4 4 5 7 3 4 2 1 6 7 4 1 9 9 7 5 8 1 8 3 8 6 6 3 9 4
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:
1. VOID ORDENAR_POR_COLUMNA (mat, m, n, c) 2. VARIABLES: i, j, k (ENTEROS) 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.
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 1 2 3 4 m 5 3 1 6 2 8 (a) 2 1 2 4 9 5 3 4 5 2 3 8 4 9 7 5 4 4 5 7 3 4 2 1 6 7 4 1 9 9 7 5 8 1 8 3 8 6 6 3 9 4 1 2 3 4 m 5 1 3 1 6 2 8 (b) 2 1 2 4 9 5 3 4 5 2 3 8 4 9 7 5 4 4 5 7 3 4 2 1 6 7 4 1 9 9 7 5 8 1 8 3 n 8 6 6 3 9 4
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 1 1 3 2 7 A = m 3 4 4 6 5 4 2 1 7 1 3 1 3 6 2 3 2 2 4 2 5 8 1 2 5 8 1 1 5 1 6 4 5 2 5 3 7 9 4 8 3 7 n A t= 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.
Ahora veamos el algoritmo con el cual se construye la transpuesta de una matriz:
1. VOID TRANSPUESTA (A, m, n, At) 2. VARIABLES: i, j (ENTEROS) 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:
1. VOID SUMAR_MATRICES (A, m, n, B, p, q, C) 2. VARIABLES: i, j (ENTEROS) 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.
Veamos un ejemplo de suma de matrices: n 1 1 2 3 3 7 5 4 2 1 7 7 1 3 6 5 5 2 4 2 8 4 2 5 8 4 4 1 6 9 2 1 3 p 1 2 3 4 1 1 8 5 8 2 3 5 6 5 3 5 7 2 4 4 7 9 3 4 5 9 2 1 6
q
6 4 3 4 2 1 1 2 3 4 5
n 6
m4
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 A
Matriz B
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:
n
1 1 2 6 9 2 2 7 3 7 7 4 5 1 1 1 2 5 7 2 4 4 1
q
3 5 2 1 1 1 2 5 4 7 4 2 8 9 6 1 0 7 6 3
q
3 8 1 7 4 3 9
m 3 3 1 6 2
Matriz A
2 3
=
m
p 4 5 3 8
Matriz B 3
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
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:
1. VOID MULTIPLICAR_MATRICES (A, m, n, B, p, q, C) 2. VARIABLES: i, j, k (ENTEROS) 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.
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:
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 NOM SANDRA FONEGRA
DEDUC 40000 SAL 630000
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:
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> 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: EMP2 <Cdula> <Nombre> <Deduccin> <Salario>
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 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. EMP2 <Cdula> <Nombre> <Deduccin> <Salario>
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
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.
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.
4. SISTEMAS NUMRICOS
OBJETIVO GENERAL Conocer en las diferentes bases los sistemas numricos, y la representacin de datos dentro de un computador. OBJETIVOS ESPECFICOS 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:
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 =
i = m
D *b
i
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,
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.
275 3
4 68 0 4 17 1 4 4 0 4 1
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:
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):
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 Numricos Reales
Positivos Enteros Negativos
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.
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.
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
(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 Signo
Caracterstica
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
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.
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 Signo
Mantisa
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
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.
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
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. OBJETIVOS ESPECFICOS 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.
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:
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 6
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
Contador de frecuencias
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
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) Contador de frecuencias 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) Contador de frecuencias
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
1 1 1 n+1 n n n2+n n2 n2 n2 n n n 1 4n2+7n+5
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) Contador de frecuencias
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
5. MQ (i <= n) 6. s=s+1 7. i=i*i 8. FINMQ 9. IMPRIMA (n, s) 10. FIN 1. ALGORITMO PROGRAMA_3 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)
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 Constante Lineal Cuadrtico Cubico Logartmico Semilogartmico exponencial REPRESENTACIN O(1) O(n) O(n2) O(n3) O(log2(n)) 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.
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:
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
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.
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) Contador de frecuencias 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).

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)
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
Pgina Web: www.remington.edu.co - Medelln - Colombia
Corporacin Universitaria Remington - Calle 51 51-27 Conmutador 5111000 Ext. 2701 Fax: 5137892. Edificio Remington
t=t+1 j=j/2 FINMQ IMPRIMA (t) s=s+t i=i+1 FINMQ IMPRIMA (n, s) Contador de frecuencias Orden de magnitud
n*log2n n*log2n n*log2n n n n n 1 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:

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
8. FINPARA 9. FINPARA 10. FIN 1. ALGORITMO PROGRAMA_2 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 1. ALGORITMO PROGRAMA_3 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
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
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.
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.
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

MÓDULO Algoritmos - II. Ingeniería Sistemas

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

MÓDULO Algoritmos - II. Ingeniería Sistemas

Uploaded by

Copyright:

Available Formats

ESCUELA DE CIENCIAS BSICAS E INGENIERA ASIGNATURA: Algoritmos II

CORPORACIN UNIVERSITARIA REMINGTON DIRECCIN PEDAGGICA

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 5

RESPONSABLES Director Escuela De Ciencias Bsicas e Ingeniera Dr. Mauricio Seplveda

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 6

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 7

Capacidad para manejar operaciones aritmticas en diferentes sistemas numricos pesados.

Habilidad para realizar algoritmos que consuman menos recursos en un computador.

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 8

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 9

2.1. Subprogramas Tipo Funcin

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 10

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 11

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 12

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 13

Tema 2: SUBPROGRAMAS TIPO VOID

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 14

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 15

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 16

2.2. Parmetros y Variables

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 17

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 18

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 19

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 20

n = 675 u=0 r=0

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 21

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 22

Nombre del Vector

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 23

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 24

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 25

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 26

16. CIERRE(censo) 17. FININICIO 18. FIN

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 27

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 28

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 29

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 30

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 31

Para ilustrar como funciona este algoritmo consideremos el siguiente grfico:

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 32

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 33

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 34

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 35

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 36

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 37

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 38

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 39

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 40

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 41

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 42

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 43

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 44

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 45

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 46

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 47

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 48

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 49

Parte 2 1 3 6 2 8 4 Parte 3 1 3 6 2 8 4 Parte 4 1 3 2 6 8 4 Primera pasada: cinco comparaciones

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 50

Ahora veamos el estado actual de nuestro vector despus de la tercera pasada:

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 51

Quinta pasada: una comparacin

Corporacin Universitaria Remington Direccin Pedaggica Algoritmos II Pg. 52