Lectura 3 PDF

Lectura 3: Arreglos
Unidad 4: Estructura de Datos: Arreglos
4.1 Concepto de arreglo unidimensional
Una estructura de datos es una colección de datos organizados de una cierta manera, y que se
caracterizan por las operaciones que se definen sobre ellas.
Las estructuras de datos son muy importantes en los sistemas de computadora.
Las estructuras de datos se clasifican en estáticas y dinámicas. Esta clasificación se basa en la

forma de gestionar la memoria de sistema para almacenar un conjunto de elementos del mismo
tipo.
Las estructuras estáticas, la memoria se gestiona en tiempo de compilación, mientras que para las
estructuras dinámicas la memoria se gestiona en tiempo de ejecución. La forma de generar los
almacenamientos implican ventajas y desventajas, ambos tipos de estructuras existen en los
lenguajes reales, el uso más conveniente de una forma u otra dependerá de los requerimientos
del problema a resolver.
Dentro de las estructuras estáticas, se encuentran los arreglos (cualquiera sea el número de
dimensiones que tenga) y los registros (estas son colecciones de elementos que pueden ser de
distinto tipo, los cuales se verán más adelante).
Dentro de las estructuras dinámicas se encuentran: pila, cola, lista simplemente enlazada, lista
doblemente enlazada, listas circulares, árboles, grafos. En todas ellas, se almacena el dato
genuino 8 por ejemplo alturas de personas) más otro tipo de información que ayuda a formar la
estructura de datos de una forma particular.
En programación, un arreglo, es un conjunto finito de elementos del mismo tipo (homogéneos)

que ocupa un espacio o zona de almacenamiento en memoria dinámica físicamente contiguo.
Los arreglos pueden ser unidimensionales también llamados vectores (o arreglos lineales), o
bidireccionales (matrices) o multidimensionales.
Todo arreglo unidimensional o vector tiene asociado un único nombre o identificador. Cada
elemento es referenciado por la posición que ocupa dentro del vector. Dichas posiciones son
llamadas índice y siempre son correlativos.
Los vectores se pueden representar gráficamente como muestra la figura1, es decir como un
rectángulo dividido en tantas partes iguales como elementos tiene el vector o arreglo
unidimensional. La figura 1 representa un arreglo unidimensional llamado Dato de 4 elementos.
Materia: Programación Lógica
Profesor: Ing. Silvia Carrera -1-

El nombre o identificador sirve para todos los elementos del conjunto, el valor del subíndice
asociado identifica en forma precisa a alguno de esos elementos.
Dato [ 1] Dato [ 2] Dato [3] Dato [4]
Figura 1
El número de elementos de un vector se llama rango del vector. En el caso de la figura 1, el rango
del vector llamado Dato, es 4.
Los arreglos en general pueden contener datos numéricos y no numéricos, por ejemplo se puede
pensar en un arreglo de carácter. La figura 2, muestra un arreglo de tipo carácter de 5 elementos,
llamado Info.
Info [ 1] Info [ 2] Info [3] Info [4] Info [5]
Figura 2
Otro ejemplo de un arreglo unidimensional no numérico, puede ser un vector que contiene los
nombres de los 8 alumnos de un curso, entonces el vector se llama Alumno y su rango es de 8.
En la figura 3 se muestra el vector Alumno.
Cada elemento de un vector se puede procesar como si fuese una variable simple al ocupar una
posición de memoria. Por ejemplo:
Dato [4]  3
Almacena el valor entero o real 3 en el vector Dato en la posición número 4 (dato debe ser de tipo
entero o real).
La instrucción:
escribir (Dato [4])
muestra por pantalla el contenido de la posición 4 del vector llamado Dato.


Los arreglos cualquiera sea su dimensión necesitan ser dimensionados previamente a su uso
dentro de un programa.
Alumno
Luis
Jose
Sonia
Pedro
Celeste
Tomás
Sonia
Pedro
Figura 3
En pseudocódigo un arreglo unidimensional se declara de la siguiente forma:
Algoritmo declaración_arreglo
tipo
array [1..10] de entero : dato
var
dato : info
entero: índice
inicio
………..
Se debe nota que en este trozo de código se agrega una sección llamada tipo, en esta parte se
declaran los arreglos y otros tipos de datos definidos por el usuario como se verá más adelante.
Se usa la palabra reservada array, seguido entre corchetes el rango como un intervalo cerrado

entre 1 y el límite superior o cantidad máxima de elementos. En el ejemplo el arreglo tiene 10
elementos. A continuación se indica el tipo de dato que contiene el arreglo y finalmente el
identificador. En la sección correspondiente a las variables (var) se indica el nombre de la variable con la
que se va a manipular el conjunto de elementos. En el ejemplo el arreglo es de enteros y la variable por
media de la cual se va a acceder a los elementos del vector, es info.
Si se desea guardar el valor entero 5, en la segunda posición del vector, la instrucción es:
info [2]  5
En el siguiente trozo de código, se crean dos vectores distintos:
Algoritmo declaración_arreglo2
tipo
var
dato : origen, destino
entero: índice
inicio
………..
En este trozo de código, se crean dos arreglos distintos, uno de ellos se trabaja mediante la
variable origen (arreglo unidimensional de 10 elementos de tipo entero) y otro se trabaja mediante
la variable destino (arreglo de 10 elementos de tipo entero).
En este ejemplo, dato es un tipo de dato definido por el usuario, así como entero, real, lógico son
tipos de datos primitivos o simples, dato es un tipo de dato compuesto, que reciben el nombre de:
tipo de dato definido por el usuario.
En un mismo algoritmo pueden declararse varios tipos de arreglos, según las necesidades que
surjan de los requerimientos del problema a resolver, en el siguiente código se declaran tres
arreglos distintos.
tipo
array [1..20] de real: vector1
array [1..3] de cadena: vector2
var
dato : origen
vector1: vec1

vector2: vec2
entero: índice
inicio
………..
4.2 Utilización de arreglos unidimensionales en algoritmos
Los arreglos se utilizan cuando es necesario almacenar varios valores. También se podrían
guardar valores en un conjunto de variables simples, pero esto es más engorroso, y más complejo
de manejar. En lugar de tener 10 variables de tipo real para guardar las alturas de personas, es
más sencillo crear un arreglo de 10 elementos de tipo real, ya que toda la información la manejo
con el mismo nombre de variable; y los elementos se diferencian entre sí según el valor que
asuma un subíndice asociado al vector.
En la práctica suele ser necesario procesar conjuntos de datos, como por ejemplo listas de
alumnos, docentes, cuentas bancarias, etc. Por ejemplo si necesitase procesar datos de 5000
alumnos respecto al promedio de inasistencia de ellos, deberíamos tener 5000 variables simple,
cada una de ellas contendría un entero que represente este dato (inasistencias). Si por ejemplo se
quisiese ordenar los alumnos por número creciente de inasistencias, para por ejemplo otorgarles
un premio, sería imperioso tener todos los datos activos en memoria, y necesitaría otra variable
para indicar el orden de los datos (5000 variables enteras más). Mientras que con un arreglo
unidimensional de 5000 elementos de tipo entero sería suficiente para contener los datos y una
variable más de tipo entero para indicar el orden dentro del arreglo (subíndice). Ordenado los
datos de menor a mayor, en la primer posición del arreglo (índice = 1) tendría la menor
inasistencia y en la última posición tendría el número más grande correspondiente al mayor
número de falta (índice = 5000).
Como queda explicado con esta breve reflexión, es necesario que los lenguajes de programación
brinden soporte para mantener juntos (referenciados mediante un mismo identificador)
colecciones de de datos del mismo tipo.
4.3 Manejo de índices.

Un vector como ya se mencionó es una secuencia ordenada de elementos como
x[1], x[2],…,x[n]
El límite inferior no tiene que empezar en 1, puede ser cualquier valor para el subíndice, aunque
es más fácil si el subíndice también sirve para indicar posición, como en el ejemplo anterior. Un
subíndice igual a 1, también indica posición 1, y así.
Entonces también sería válido
P[0], P[1], P[2], P[3], P[4], P[5]


En este caso el rango del arreglo P es 6, y la posición 1 le corresponde el subíndice 0.
Lo mismo sucede con el siguiente caso:
P[-10], P[-11], P[-12], P[-13], P[-14], P[-15]
En este caso el rango del arreglo P es 6, y la posición 1 le corresponde el subíndice -10 y así
sucesivamente.
Las operaciones que pueden realizarse con vectores son:
 Asignación
 Lectura/escritura
 Recorrido
 Ordenación búsqueda
En general, las operaciones con vectores implican el procesamiento o tratamiento de los

elementos individuales del arreglo lineal.
ASIGNACION
La asignación de valores a un elemento del arreglo lineal se realiza con la siguiente instrucción:
A [4]  20
Si se desea asignara valores a todas las posiciones de un arreglo, desde el teclado, se deberá
utilizar una estructura repetitiva, cualquiera. La que mejor se adapta es la estructura desde/fin-
desde; ya que esta estructura tienen asociada a ella necesariamente una variable que permite
contar las iteraciones, esa variable es la que nos sirve de subíndice.
Algoritmo almacena-valores_arreglo
tipo
var
dato : origen
entero: índice
inicio
escribir („ ingresar los 10 elementos del arreglo‟)
desde índice  1 hasta 10 hacer
leer ( origen [índice])
fin-desde

………..
………..
En el trozo de código anterior se declara un arreglo lineal de 10 elementos de tipo entero, la

variable para manejar la colección de datos se llama origen. La estructura repetitiva desde/fin-
desde, itera 10 veces para asignar desde el teclado 10 valores enteros al arreglo, uno por cada
posición del mismo.
LECTURA /ESCRITURA DE DATOS
Las operaciones de lectura y escritura de los elementos de un arreglo lineal generalmente se

realizan con estructuras repetitivas, aunque también pueden hacerse con estructuras selectivas
(dependerá de los requerimientos).
Si se desea mostrar por pantalla el contenido de una posición de un arreglo se utilizará la

siguiente instrucción:
Mostrar ( a[2])
Esta instrucción muestra por pantalla el contenido de la posición 2 (si el límite inferior del arreglo
es 1) del arreglo lineal a.
Si se desea mostrar por pantalla el contenido de todo un arreglo se usará una estructura repetitiva
como se muestra en el siguiente trozo de código:
tipo
var
dato : origen
entero: índice
inicio
desde índice  1 hasta 10 hacer //se toman los valores del teclado
fin-desde
escribir („ Se muestran los elementos del arreglo lineal‟)
desde índice  1 hasta 10 hacer // se muestran por pantalla los datos del arreglo lineal
escribir (origen [índice])


fin-desde
fin
4.4 Resolución de problemas usando arreglos unidimensionales.
Ejemplo 1) Se desea crear un algoritmo en pseudocódigo que permita ingresar 10 valores enteros
por teclado, y los guarde en un arreglo unidimensional. Luego recorrerlo y mostrar los valores que
ocupan las posiciones pares por pantalla.
Algoritmo Muestra_posi_par
tipo
var
dato : origen
entero: índice
inicio
fin-desde
escribir („ Se muestran los elementos de las posiciones pares del arreglo lineal‟)
desde índice  2 hasta 10 inc 2 hacer // se muestran por pantalla los datos del arreglo lineal
escribir (origen [índice])
fin-desde
fin
por teclado, y los guarde en un arreglo unidimensional. Luego recorrerlo y mostrar los valores
positivos que sean pares por pantalla.
Algoritmo Muestra_positivos_par
tipo
var

dato : vec
entero: índice
inicio
leer ( ver [índice])
fin-desde
escribir („ Se muestran los elementos positivos pares‟)
desde índice  1 hasta 20 hacer // se recorre los datos del arreglo lineal
si (vec [índice] > 0) y (vec [índice] mod 2 = 0) entonces
mostrar (vec[índice])
fin-si
fin-desde
fin
por teclado, y los guarde en un arreglo unidimensional. Luego recorrerlo y mostrar los valores
positivos que sean pares por pantalla.
Algoritmo Muestra_positivos_par
tipo
var
dato : vec
entero: índice
inicio
fin-desde
escribir („ Se muestran los elementos positivos pares‟)
desde índice  1 hasta 20 hacer // se recorre los datos del arreglo lineal

si (vec [índice] > 0) y (vec [índice] mod 2 = 0) entonces
mostrar (vec[índice])
fin-si
fin-desde
fin
por teclado, y los guarde en un arreglo unidimensional. Luego recorrerlo y guardar los enteros
positivos en otro arreglo del mismo tipo. Mostrar los valores de este segundo arreglo porr pantalla.
Algoritmo Detecta_positivos_arreglo
tipo
var
dato : origen, destino
entero: índice, indice2
inicio
fin-desde
//„ Se detectan y guardan los enteros positivos en arreglo destino
Indice2  1
desde índice  1 hasta 20 hacer // se recorre los datos del arreglo origen
si (vec [índice] > 0) entonces
destino[índice2]  vec [índice]
indice2  indice2 +1
fin-si
fin-desde
escribir („Se muestran los elementos del arreglo destino‟)
desde índice  1 hasta indice2 hacer
mostrar( destino [índice])

Profesor: Ing. Silvia Carrera - 10 -

fin-desde
fin
Ejemplo 5) Se desea crear un programa que permita guardar 15 caracteres tomados desde el
teclado, el algoritmo deberá contar cuantas letras son mayúsculas. Mostrar este resultado por
pantalla.
Algoritmo Cuenta_Mayúsculas
tipo
array [1..15] de caracter : dato
var
dato : ar
entero: índice, cant_May
inicio
cant_May  0
escribir („ ingresar los 15 caracteres del teclado‟)
leer ( ar [índice])
fin-desde
//„ Se detectan y cuentan las letras mayúsculas
desde índice  1 hasta 15 hacer
si ((ar [índice] > „A‟) y ( ar[índice] < „Z‟0)) entonces
cant_May  cant_May +1
fin-si
fin-desde
escribir („La cantidad de letras mayúsculas del arreglo es:‟, cant_May)
fin
4.5 Concepto de arreglo bidimensional.

Los vectores hasta aquí analizados, se denominan arreglos lineales o unidimensionales.
Existen situaciones en que la información es mejor organizarla en forma de tabla o matriz con dos
subíndices, uno para las filas y otro para recorrer las columnas.

El arreglo bidimensional se puede considerar como un vector de vectores. Por lo tanto es un
conjunto de elementos, todos del mismo tipo, en el cual el orden de los elementos es significativo
y en el que se necesita especificar dos subíndices, para poder identificar cada elemento del
arreglo.
En la figura 4, se representa una tabla de 4 filas por 3 columnas. Cada elemento del arreglo se
referencia con el mismo nombre, pero los valores de los subíndices son únicos para cada
elemento de la tabla.
Fila 1
Fila 2
Fila 3
Fila 4
Fila 5
Columna 3
Columna 2
Columna 1
Figura 4
En notación estándar el primer subíndice hace referencia a las filas, y el segundo a los elementos
de las columnas del arreglo. Es decir Tabla [2,3] es el elemento Tabla que ocupa la posición
segunda fila, tercer columna, como se indica en la figura 5.
El arreglo Tabla se dice que tiene 5 por 3 elementos.
En pseudocódigo los arreglos bidimensionales se declaran de la siguiente forma:
Algoritmo Declaracion_ArregloBidimensional
tipo
array [1..5,1..3] de enteros : T
var

T : Tabla
entero: j,k
inicio
……………..
Tabla
Fila 1
Fila 2 Tabla[2,3]
Fila 3
Fila 4
Fila 5
Columna 3
Columna 2
Columna 1
Figura 5
4.6 Utilización de arreglos bidimensionales en algoritmos.

Los arreglos bidimensionales son muy frecuentes, por ejemplo si se desease almacenar las
calificaciones de los alumnos de un determinado grado, en tres materia: matemática, lengua e
historia, se debería construir una tabla, las filas serían los nombre de los alumnos y las columnas
serían las notas de los alumnos en las tres materias distintas, por ejemplo en la columna 1, las
notas de matemática, en la columna 2 las de lengua y en la columna 3 las de historia. El contenido
de cada celda sería un número entero, la declaración de esta tabla para 10 alumnos, se muestra
en la figura 6.
Según la tabla de la figura 6, las notas de los alumnos de matemática son: 8, 7, 4, 10, 2, 1, 7, 8,
10, 2.
Las notas de los alumnos en la materia de lengua son: 5, 2, 10, 2, 8, 8, 5, 5, 10, 5 y las notas en la
materia de historia son: 7,10, 5, 4, 1, 3, 7, 4, 3, 10.
Si se hace una lectura horizontal, se puede decir que el alumno de la fila 1, tiene un 8 (ocho) en
matemática, un 5 (cinco) en lengua y un 7 (siete) en historia.

nota-alu
8 5 7
Fila 1
Fila 2 7 2 10
4 10 5
Fila 3
Fila 4 10 2 4
Fila 5
2 8 1
1 8 3
7 5 7
8 5 4
10 10 3
2 5 10
Columna 1 Columna 3
matemática historia
Columna 2
lengua
Figura 6
También son útiles para representar los elementos de un almacén, por ejemplo. Los saldos en
cuentas bancarias, o en distintos tipos de cuentas bancarias de un mismo cliente, etc.
4.7 Manejo de índices.

Para recorrer arreglos bidimensionales es necesario tener dos estructuras repetitivas anidadas.
Las estructuras que mejor se adaptan a estos casos son las estructuras desde/fin-desde.

En pseudocódigo se expresa de la siguiente manera:
Algoritmo Declaracion_ArregloBidimensional1
tipo
var
T : Tabla
Entero: i,j
Inicio
desde i  1 hasta 5 hacer
desde j  1 hasta 3 hacer
// sentencias
fin-desde
fin-desde
fin
Para leer datos desde el teclado, guardarlos en un arreglo bidimensional, y luego recorrerlo para
mostarlo, se realiza lo siguiente:
Algoritmo Declaracion_ArregloBidimensional1
tipo
var
T : Tabla
entero: i,j
Inicio
leer ( Tabla [i,j]
fin-desde

fin-desde
// se recorre el arreglo para mostrar los elementos almacenados por pantalla
escribir ( Tabla [i,j]
fin-desde
fin-desde
fin
Por cada valor que toma la variable i, el bucle interno ocurre completamente, es decir por cada
valor que asume la variable i, j toma los valores de 1 a 3.
4.8 Resolución de problemas usando arreglos bidimensionales.

Ejemplo 1) Se desea crear un algoritmo en pseudocódigo que permita ingresar las notas de 10
alumnos en las materias de física (primera columna) y matemática (segunda columna)
correspondientes a un curso. Se desea determinar el promedio general del curso y por materia.
Mostrar estos valores por pantalla.
Algoritmo Muestra_promedios
tipo
array [1..10, 1..2] de entero : matriz
var
matriz: mat
entero: i, j, total, total2
inicio
total  0
escribir („ ingresar las notas de los 10 alumnos en las dos materias‟)
// se carga por fila desde el teclado
leer ( mat [i,j)

fin-desde
fin-desde
//se calcula el promedio general
total  total + mat [i, j]
fin-desde
fin-desde
escribir ( „ el promedio general es: „, total / 20‟)
total  0
total2  0
escribir („ Se calculan los promedios por materia‟)
total  total + mat [i,1]
total2  total2 + mat [i, 2]
fin-desde
escribir („ el promedio en física es: „, total/10, „ el promedio en matemática es:‟, total2/ 10)
fin
Ejemplo 2) Se desea crear un algoritmo en pseudocódigo que permita leer una tabla con
temperaturas. La tabla tiene 5 filas correspondientes a 5 momentos distintos del día, y tiene 3
columnas correspondientes a 3 días distintos. Se desea detectar la temperatura mínima y la
máxima de la tabla completa. Mostrar los valores hallados por pantalla.
Algoritmo Muestra_mín_máx
tipo
array [1..5, 1..3] de real : matriz
var
matriz : mat
entero: i, j
real: mi, ma

inicio
escribir („ ingresar los 15 elementos de la tabla‟)
desde i  1 hasta 5 hacer //se toman los valores del teclado
leer ( mat [i, j])
fin-desde
fin-desde
escribir („ Se detecta el mínimo y el máximo‟)
ma  mat [1, 1]
mi  mat [1, 1]
si mat [i, j] > max entonces
ma  mat [i, j]
fin-si
si mat [i, j]< mi entonces
mi  mat [i, j]
fin-si
fin-desde
fin-desde
mostrar („la temperatura mínima es: „, mi, „la temperatura máxima es:‟, ma)
fin
Ejemplo 3) Se desea crear un algoritmo en pseudocódigo que permita obtener el número de

elementos positivos de una tabla de m x n. Mostrar el valor hallado por pantalla.
Algoritmo Muestra_positivos
tipo
array [1..50, 1..50] de entero : matriz
var
matriz : ma

entero: i, j, cont, cat_f, cant_c
inicio
escribir („ ingresar el número de filas menor a 50‟)
leer (cant_f)
escribir („ ingresar el número de columnas menor a 50‟)
leer (cant_c)
escribir („se ingresan los elementos de una tabla de :‟,cant_f, „y de „, cant_c,‟de columnas‟)
desde i  1 hasta cant_f hacer //se toman los valores del teclado
desde j  1 hasta cant_c hacer
leer ( ma [i, j])
fin-desde
fin-desde
cont  0
escribir („ Se cuentan los positivos‟)
desde i  1 hasta cant_f hacer // se recorre los datos del arreglo lineal
desde j  1 hasta cant_c hacer
si (ma [i, j] > 0) entonces
cont  cont + 1
fin-si
fin-desde
fin-desde
mostrar ( „la cantidad de positivos es: „, cont)
fin
Ejemplo 4) Se desea crear un algoritmo en pseudocódigo que permita sumar los contenidos de
dos tablas de 5x 5 cada una. El resultado se almacenara en otra tabla de la misma dimensión.
Luego recorrer la tabla suma para mostrar los valores por pantalla.
Algoritmo suma_tablas
tipo
array [1..5, 1..5] de entero : mat
var

mat :ma1, ma2,maSuma
entero: i, j
inicio
escribir („ ingresar los elementos de la primera tabla de 5 x5 por fila‟)
leer ( ma1 [i, j])
fin-desde
fin-desde
escribir („ ingresar los elementos de la segunda tabla de 5 x5 por fila‟)
leer ( ma2 [i, j])
fin-desde
fin-desde
// se suman elementos homólogos y se guardan en la matriz
desde i  1 hasta 5 hacer //
desde j  1 hata 5 hacer
maSuma [ i, j]  ma1 [i, j] + ma2 [i, j]
fin-desde
fin-desde
escribir („Se muestran los elementos de la matriz suma‟)
desde j1 hasta 5 hacer
mostrar( maSuma [i, j])
fin-desde
fin-desde
fin

Ejemplo 5) Se desea crear un programa que permita guardar 16 caracteres tomados desde el
teclado, en un arreglo bidimensional de 4 x 4. Se solicitará el ingreso del número de fila desde el
teclado, el programa mostrará por pantalla todos los elementos de esa fila.
Algoritmo Muestra_fila
tipo
array [1..4, 1..4] de caracter : dato
var
dato : ar
entero: i, j, fila
inicio
escribir („ ingresar los 16 caracteres del teclado‟)
leer ( ar [i, j])
fin-desde
fin-desde
mostrar („ Introducir una fila entre 1 y 4‟)
repetir
leer ( fila)
hasta-que fila >=1 y fila < =4
escribir („Los elementos de la fila: „, fila, „son:‟)
mostrar ( ar [fila, j])
fin-desde
fin-desde
fin
4.9 Ejercicios de aplicación.

Ejemplo 1) Leer una tabla de 3 x3. Declarar dos arreglos unidimensionales uno llamado fila y otro
columna, en estos arreglos se guardarán los totales de las filas y los totales de las columnas de la
tabla de 3 x 3. Luego mostrar por pantalla los arreglos lineales.
Algoritmo Suma_fila_columna
tipo
array [1..3, 1..3] de entero : Mat
array [1..3] de entero :vector
var
Mat : ma
vector: vec1, vec2
entero: i, j, suma
inicio
escribir („ ingresar los 9 elementos del teclado‟)
leer ( ma [i, j])
fin-desde
fin-desde
// se completa el arreglo fila
Suma  0
suma  suma + ma [i, j])
fin-desde
vect1[i]  suma
suma 0
fin-desde
// se completa el arreglo columna
Suma  0


suma  suma + ma [i, j])
fin-desde
vect1[j]  suma
suma 0
fin-desde
//se muestran por pantalla los elementos del vector de filas
mostrar ( vect1 [ i ])
fin-desde
//se muestran por pantalla el vector de columnas
mostrar ( vect2 [ i ])
fin-desde
fin
Ejemplo 2) Crear una tabla de 4 x4. Declarar un arreglo unidimensional, en el se guardarán los
elementos de la diagonal principal. Luego mostrar por pantalla los elementos del arreglo lineal.
Algoritmo vector-diagonal
tipo
array [1..4, 1..4] de real : Mat
array [1..4] de real :vector
var
Mat : ma
vector: vec1
entero: i, j
inicio
escribir („ ingresar los 16 elementos del teclado‟)

leer ( ma [i, j])
fin-desde
fin-desde
// se completa el arreglo lineal
vec [ i ] ma [i, i])
fin-desde
//se muestran por pantalla los elementos del vector diagonal principal
mostrar ( vec [ i ])
fin-desde
fin
Ejemplo 3) Crear una lista con N temperaturas almacenadas. Se desea calcular la media y crear
otro arreglo con los valores mayores a la media. Luego mostrar por pantalla los elementos de los
arreglos lineales.
Algoritmo vector-media
tipo
array [1..50] de real : vector
var
vector: origen, destino
entero: i, N
real: suma, media
inicio
escribir („ ingresar el número de elementos que tendrá el arreglo‟)
leer (N )
escribir („Ingresar los elementos del arreglo lineal‟)
desde i  1 hasta N hacer //se toman los valores del teclado
leer ( origen [i ])
fin-desde

// se calcula la media
Suma  0
desde i  1 hasta N hacer
suma  suma + origen [ i ]
fin-desde
media  suma / N
j0
//se comparan los elementos del arreglo origen con la madia
si origen [ i ] > media entonces
j j+1
destino [j ]  origen [ i]
fin-si
fin-desde
mostrar („ se muestra el arreglo origen‟ )
escribir ( origen [i ])
fin-desde
mostrar („ se muestra el arreglo destino‟ )
desde i  1 hasta j hacer //se toman los valores del teclado
mostrar ( destino [i ])
fin-desde
fin
Ejemplo 4) Crear una lista con N nombres de alumnos. Se desea introducir un nombre de alumno
por teclado 10 veces, y mostrar un mensaje adecuado si el nombre está en la lista.
Algoritmo Lista-nombre
tipo
array [1..50] de cadena : vector
var

vector: vec
entero: i, cant
cadena: nom
inicio
repetir
escribir („ ingresar el número de elementos que tendrá el arreglo‟)
leer (N )
hasta-que N>=1 y N <= 50
escribir („Ingresar los elementos del arreglo lineal‟)
leer ( vec [i ])
fin-desde
cant 0
mientras cant < 10 hacer
escribir („Ingresar un nombre de alumno a buscar en la lista
leer ( nom)
si vec [ i ] = nom entonces
mostrar („ el nombre:‟, nom, „está en la lista‟)
si-no
mostrar („el nombre:‟, nom, „no está en la lista‟)
fin-si
fin-desde
cant cant + 1
fin-miesntras
fin
Bibliografía Obligatoria:

“Fundamentos de programación. Algoritmos, Estructuras de datos y Objetos”, Luis Joyanes
Aguilar. Mc Graw Hill. Tercera edición. Capítulo 7 (páginas 247 a 284)
Unidad 5: Ordenación y búsqueda

5.1 Ordenación. Métodos
El ordenamiento es una labor común que realizamos continuamente. ¿Pero, qué es ordenar? El
ordenamiento es algo tan corriente en nuestras vidas que no nos detenemos a pensar en ello.
Ordenar es simplemente colocar información de una manera especial basándonos en un criterio
de ordenamiento. La finalidad de un ordenamiento, es el de facilitar el acceso a la información.
En la computación el ordenamiento de datos también cumple un rol muy importante, ya sea como
un fin en sí o como parte de otros procedimientos más complejos. Se han desarrollado muchas
técnicas en este ámbito, cada una con características específicas, y con ventajas y desventajas
sobre las demás. En esta unidad vamos a mostrar algunas de las más comunes, tratando de
hacerlo de una manera sencilla y comprensible.
CONCEPTOS PRELIMINARES
Antes de comenzar a ver cada algoritmo vamos a ponernos de acuerdo en algunos conceptos,
para que no haya confusiones:
Clave: La parte de un conjunto de datos (registro), por la cual se ordena la lista. Por ejemplo, una
lista de registros, en la que cada registro de esa lista tiene tres campos diferentes: nombre,
dirección y teléfono se puede ordenar alfabéticamente de acuerdo a la clave nombre. En este
caso los campos dirección y teléfono no se toman en cuenta en el ordenamiento.
Criterio de ordenamiento (o de comparación): EL criterio que utilizamos para asignar valores a

los registros con base en una o más claves. De esta manera decidimos si un registro es mayor o
menor que otro.
Registro: Un grupo de datos que forman la lista. Pueden ser datos atómicos (enteros, caracteres,
reales, etc.) o grupos de ellos.
Cuando se estudian algoritmos de todo tipo, no sólo de ordenamiento, es bueno tener una forma
de evaluarlos antes de pasarlos a código, que se base en aspectos independientes de la
plataforma o el lenguaje. De esta manera podremos decidir cuál se adapta mejor a los
requerimientos de nuestro programa. Algunos de estos aspectos son:
 Estabilidad: Este parámetro establece o mide cómo se comporta, el algoritmo con

registros que tienen claves iguales. Algunos algoritmos mantienen el orden relativo entre

éstos y otros no. Veamos un ejemplo. Si tenemos la siguiente lista de datos (nombre,
edad): "Pedro 19, Juan 23, Felipe 15, Marcela 20, Juan 18, Marcela 17", y la ordenamos
alfabéticamente por el nombre con un algoritmo estable quedaría así: "Felipe 15, Marcela
20, Marcela 17, Juan 23, Juan 18, Pedro 19". Un algoritmo no estable podría dejar a
Juan 18 antes de Juan 23, o a Marcela 20 después de Marcela 17.
 Tiempo de ejecución: Este parámetro mide la complejidad del algoritmo, que no tiene que
ver con dificultad, sino con rendimiento. Es una función independiente de la
implementación.
Una medida de eficiencia es:
 Contar el número de comparaciones
 Contar el número de movimientos de ítems
Estos están en función del número de elementos a ser ordenados.
En el ordenamiento una operación fundamental es la de comparar. Ahora contamos

cuántas veces el algoritmo necesita comparar. Si en una lista de n términos realiza n
comparaciones la complejidad es O(n). (En realidad es un poco más complicado que eso).
Algunos ejemplos de complejidades comunes son:
O(1): Complejidad constante.
O(n2): Complejidad cuadrática.
O(n log(n)): Complejidad logarítmica.
Ahora podemos decir que un algoritmo de complejidad O(n) es más rápido que uno de
complejidad O(n2). Otro aspecto a considerar es la diferencia entre el peor y el mejor caso.
Cada algoritmo se comporta de modo diferente de acuerdo a cómo se le entregue la
información; por eso es conveniente estudiar su comportamiento en casos extremos, como
cuando los datos están prácticamente ordenados o muy desordenados.
 Requerimientos de memoria: El algoritmo puede necesitar memoria adicional para

realizar su labor. En general es preferible que no sea así, pero es común en la
programación tener que sacrificar memoria por rendimiento.
Hay más aspectos que se pueden tener en cuenta para realizar un análisis de calidad sobre un
algoritmo de ordenamiento en particular, pero sólo vamos a mencionar en esta materia los hasta
aquí descriptos.
Por último estableceremos algunas convenciones sobre el pseudocódigo:
Vamos a ordenar la lista en forma ascendiente, es decir, de menor a mayor. Obviamente es

esencialmente lo mismo que hacerlo en forma inversa.
La forma de intercambiar los elementos depende de la estructura de datos: si es un arreglo

(dinámico o estático) es necesario guardar una copia del primer elemento, asignarle el segundo al
primero y el temporal al segundo. La variable temporal es necesaria, porque de lo contrario se
perdería uno de los elementos. Si la estructura es una lista dinámica el procedimiento es parecido,

pero se utilizan las direcciones de los elementos. En el pseudocódigo se utilizará el primer
método.
La siguiente es una tabla comparativa de algunos algoritmos de ordenamiento, según los

parámetros ya vistos.
Tabla comparativa de algoritmos
Nombre Complejidad Estabilidad Memoria adicional
Ordenamiento Burbuja O(n2) Estable No
Ordenamiento por Selección O(n2) No Estable No
Ordenamiento por inserción O(n2) Estable No
Ordenamiento Rápido (Quicksort) O(n * log2(n)) No Estable No
Cada algoritmo se comporta de modo diferente de acuerdo a la cantidad y la forma en que se le

presenten los datos, entre otras cosas. No existe EL algoritmo de ordenamiento. Sólo existe el
mejor para cada caso particular. Se debe conocer el problema que se desea resolver, y aplicar el
algoritmo más adecuado. Hay algunos interrogantes que pueden ayudar a escoger un algoritmo
en especial:
¿Qué grado de orden tendrá la información que vas a manejar? Si la información va a estar
casi ordenada y no quieres complicarte, un algoritmo sencillo como el ordenamiento burbuja será
suficiente. Si por el contrario los datos van a estar muy desordenados, un algoritmo poderoso
como Quicksort puede ser el más indicado. Si por forma en que se presenta la información no es
posible hacer una presunción sobre el grado de orden de la información, lo mejor será elegir un
algoritmo que se comporte de manera similar en cualquiera de estos dos casos extremos.
¿Qué cantidad de datos vas a manipular? Si la cantidad es pequeña, no es necesario utilizar un

algoritmo complejo, y es preferible uno de fácil implementación. Una cantidad muy grande puede
hacer prohibitivo utilizar un algoritmo que requiera de mucha memoria adicional.
¿Qué tipo de datos quieres ordenar? Algunos algoritmos sólo funcionan con un tipo específico
de datos (enteros, enteros positivos, etc.) y otros son generales, es decir, aplicables a cualquier
tipo de dato.
¿Qué tamaño tienen los registros de tu lista? Algunos algoritmos realizan múltiples
intercambios (burbuja, inserción). Si los registros son de gran tamaño estos intercambios son más
lentos.

El ordenamiento es una labor común que realizamos cotidianamente, es un proceso tan común en
nuestras vidas que no nos detenemos a meditar mucho en ello. Ordenar es meramente colocar
información de una manera especial basándonos en un criterio de ordenamiento.
El ordenar un grupo de datos significa mover los datos o sus referencias para que queden en una
secuencia tal que represente un orden, el cual puede ser numérico, alfabético o incluso
alfanumérico, ascendente o descendente.
Tipos de ordenamientos
a- internos
Los datos a ordenar están en memoria la principal Ram, por lo que se asume que el tiempo que se
requiere para acceder cualquier elemento sea el mismo. En el siguiente cuadro aparecen métodos
que explícitamente pide desarrollar el programa y otros que no se trabajan en la materia, como
para presentar un panorama amplio del ordenamiento
Inserción Directa
Inserción Directa
Inserción Binaria
Selección Directa Selección Directa
Burbuja
Intercambio Directo
Shake
Inserción Disminución Incremental Shell
Heap
Ordenamiento De Árbol
Tournament
Sort Particionado Quick Sort
Merge Sort
Radix Sort
Cálculo De Dirección
b- externos

Los datos a ordenar están en la memoria secundaria, es decir, por ejemplo disco duro, disco
extraíble, por lo que se asume que el tiempo que se requiere para acceder a cualquier elemento
depende de la última posición consultada.
Straight Merging
Natural Merging
Balanced Multiway Merging
Polyphase Sort
Distribution Of Initial Runs
Clasificación de los algoritmos de ordenamiento:
Inserción Directa
Shell
Algoritmos de inserción:
Inserción Binaria
Hashing
Burbuja
Algoritmos de intercambio: Shake
QuickSort
Algoritmos de selección: Selección Directa
Merge
Algoritmos de enumeración: Radix
Heap
Los métodos simples son: Inserción Directa, Selección, Burbuja y Shell, en dónde el último es una
extensión al método de Inserción, siendo más rápido. Los métodos más complejos son Quick Sort
y Heap.
La ordenación (clasificación) es la operación de organizar un conjunto de datos en algún orden

dado, tal como creciente o decreciente para los datos numéricos, o en orden alfabético para
caracteres o cadenas (directo o inverso).
Los métodos de ordenamiento directos, son aquellos que para realizar el ordenamiento utilizan el
espacio del arreglo.

La ordenación de información es una de las aplicaciones más importantes de la computación. Por
ejemplo un banco ordena los cheques por número de cuenta para poder preparar los estados de
cuenta al cierre del mes. Otro caso lo constituyen las compañías de teléfonos, estos ordenan sus
listas de cuenta por apellido y nombre para hacer más fácil la localización de números telefónicos.
Prácticamente todas las organizaciones tienen información a ordenar y en muchos casos son
grandes volúmenes de datos. El ordenamiento de datos es un problema interesante que ha
provocado áreas de investigaciones en la ciencia de la computación.
Los métodos de ordenamiento más populares son:
 Intercambio
 Selección
 Inserción
En algunas circunstancias es clara la ventaja de usar un método en lugar de otros.
5.2 Ordenación por selección.

Este método se basa en buscar el elemento menor del vector y colocarlo en primera posición.
Luego se busca el segundo elemento más pequeño y se coloca en la segunda posición, y así
sucesivamente.
Los pasos sucesivos son:
1. Seleccionar el elemento menor del vector de n elementos
2. Intercambiar dicho elemento con el primero
3. Repetir estas operaciones con los n-2 elementos restantes hasta que sólo quede el mayor
Un ejemplo aclarará el método:
120 45 2 36 89 90 23
El método busca el más pequeño, y lo intercambia con el elemento que ocupa la primera posición
2 45 120 36 89 90 23
Luego busca el número más pequeño entre los que quedan menos el primer elemento que ya está
ubicado.
2 23 120 36 89 90 45
Ahora busca el elemento que ocupa la tercera posición en el ordenamiento:
2 23 36 120 89 90 45
Busca el elemento que ocupa la 4 posición en el vector ordenado:
2 23 36 45 89 90 120

Busca el elemento que ocupa la 5 posición:
2 23 36 45 89 90 120
La posición 6 y 7 ya están ordenadas, pero el método seguirá iterando y confirmará sus

posiciones en el ordenamiento.
2 23 36 45 89 90 120
La última pasada ratificará el último valor
2 23 36 45 89 90 120
Un algoritmo para este método de ordenación es:
Algoritmo ordenación_selección
tipo
array [1..7] de entero : vector
var
vector: vec
entero: i, j, aux
inicio
escribir („ ingresar los valores 2, 23, 36, 45, 89, 90, 120‟)
leer (vec [i ] )
fin-desde
escribir („Comienza el ordenamiento‟)
desde j  i+1 hasta 7 hacer
si vec [i ] > vec [ j ] entonces

aux  vec [ i ]
vec [i ]  vec [ j ]
vec [j ]  aux
fin-si
fin-desde
fin-desde
escribir („el vector ordenado es:‟ )


fin-desde
fin
Si se quisiese ordenar en forma decreciente los elementos, sólo habría que dar vuelta el signo de
la desigualdad:
si vec [i ] < vec [ j ] entonces
La parte del intercambio corresponde al siguiente trozo de código:

aux  vec [ i ]
vec [j ]  aux
cómo puede verse se requiere una variable auxiliar para el intercambio.
5.3 Ordenación por inserción.

Este método consiste en insertar un elemento en una parte ya ordenada del vector y comenzar de
nuevo con los elementos restantes. Este también es un algoritmo lento, pero puede ser de utilidad
para listas que están a medio ordenar, pues en ese caso realiza pocos desplazamientos.
También se lo conoce como el método de la baraja.
Tiempo de Ejecución: Para una lista de n elementos el ciclo externo se ejecuta n-1 veces.
Complejidad O(n2).
Estabilidad: No intercambia registros con claves iguales. Por lo tanto es estable.
Ventajas:
Fácil implementación.
Requerimientos mínimos de memoria.
Desventajas:
Lento.
Numerosas comparaciones.
EJEMPLO PRACTICO

Explicaremos el método sobre una lista de números enteros desordenados, por ejemplo:
67 90 30 21 4 51
Paso1: toma las dos primeras posiciones y las ordena
67 90 30 21 4 51
Paso 2: toma el 3 elemento y lo inserta ordenado en la parte que ya está ordenada, previo
desplazar los elementos ordenados en forma lineal, para lo cual el elemento a insertar se guarda
en una variable auxiliar, lo cual permite hacer el desplazamiento de los elementos ordenados de la
lista:
67 90 30 21 4 51
67 90 90 21 4 51 aux= 30
67 67 90 21 4 51
Paso 3: toma el 4 elemento y busca insertarlo en la parte ordenada del vector. Para ello guarda el
valor a insertar en una variable auxiliar, y luego entra a desplazar los elementos ordenados
buscando el lugar adecuado para la inserción.
30 67 90 21 4 51
Aux = 21
30 67 90 90 4 51 (notar que el 4 y el 51 de la lista ocupan el mismo lugar)
21 67 67 90 4 51
30 30 67 90 4 51
21 30 67 90 4 51
21 30 67 90 4 51
Aux = 4
21 30 67 90 90 51 (notar que el 51 de la lista ocupa el mismo lugar)
21 30 67 67 90 51
21 30 30 67 90 51
21 21 30 67 90 51
4 21 30 67 90 51

4 21 30 67 90 51
Aux = 51
4 21 30 67 90 90
4 21 30 67 67 90
4 21 30 51 67 90
El arreglo lineal queda ordenado.
Por lo tanto el método se basa en comparaciones y desplazamientos sucesivos. El algoritmo de

clasificación de un vector X para N elementos se realiza con un recorrido de todo el vector y la
inserción del elemento correspondiente en el lugar adecuado. El recorrido se puede realizar desde
el segundo al n-ésimo.
// insertar X [i ] en el lugar adecuado entre X[1 ].. X [i-1 ]
fin-desde
En el siguiente código se utiliza un centinela o bandera (sw)
algoritmo orden_inserción-directa
//declaraciones
inicio
……
aux  X [ i]
k  i-1
sw  falso
mientras no (sw) y ( k > = 1) hacer
si aux < X [k ] entonces
X [k +1]  X [k ]
K  k-1
si-no
sw  verdadero
fin-si

fin-mientras
X [k +1]  aux
fin-desde
fin
Existe una forma de mejorar el algoritmo de inserción lineal o directa. Para ello se utiliza el método
de buscada binaria para ubicar la posición correcta y no realizar un desplazamiento lineal.
En pseudocódigo el algoritmo de inserción mejorada es:
algoritmo orden_inserción_binaria
//declaraciones
inicio
……
aux  X [ i]
P  1 //primero
U  i -1 // ultimo
mientras P < = U hacer
C  ( P+ U) div 2
si aux < X [C ] entonces
UC-1
si-no
P  C +1
fin-si
fin-mientras
desde K  i -1 hasta P decrementar 1 hacer
X [k +1]  X [ K ]
fin-desde
X [ P ]  aux
fin-desde
fin

5.4 Ordenación por burbuja.
Algoritmo Burbuja
BubbleSort recorre el arreglo intercambiando los elementos adyacentes que estén desordenados.
Recorre el arreglo tantas veces hasta que ya no haya cambios. Prácticamente lo que hace es
tomar el elemento mayor y lo coloca en las últimas posiciones o tomar el menor y colocarlo en las
primeras posiciones.
Tiempo de ejecución: El ciclo interno se ejecuta n veces. El ciclo externo también se ejecuta n
veces, la complejidad es n * n = O(n2). El comportamiento del caso promedio depende del orden
de entrada de los datos, pero es sólo un poco mejor que el del peor caso, y sigue siendo O(n2).
Estabilidad: No intercambia registros con claves iguales.
Ventajas:
Fácil implementación.
No requiere memoria adicional.
Desventajas:
Muy lento.
Muchas comparaciones.
Muchos intercambios.
En pseudocódigo el algoritmo es:
algoritmo Método_Burbuja
//declaraciones
inicio
// lectura del vector
leer ( vec[ i ] )
fin-desde
//ordenamiento del vector
desde i  1 hasta n-1 hacer
desde j  1 hasta n-1 hacer


si vec [ j ] > vec [ j +1 ] entonces
//intercambiar
aux  vec [ j ]
vec [ j ]  vec [ j +1 ]
vec [ j+1 ]  aux
fin-si
fin-desde
fin-desde
// mostrar por pantalla el arreglo ordenado
mostrar ( vec[ i ] )
fin-desde
fin
5.5 Ordenación por burbuja mejorada.

Después de cada pasada (el bucle desde más externo), el elemento de más valor se ubica en el
extremo del arreglo. Lo que significa que toma su posición correcta, por este motivo sería
conveniente que en vez de realizar todas las comparaciones en la segunda pasada, se haga una
comparación menos.
algoritmo Método_Burbuja_mejorada
//declaraciones
inicio
leer ( vec[ i ] )
fin-desde
//ordenamiento del vector
desde i  1 hasta n-1 hacer
desde j  1 hasta n- i hacer
si vec [ j ] > vec [ j +1 ] entonces
//intercambiar

aux  vec [ j ]
vec [ j]  vec [ j +1 ]
vec [ i+1 ]  aux
fin-si
fin-desde
fin-desde
// mostrar por pantalla el arreglo ordenado
mostrar ( vec[ i ] )
fin-desde
fin
5.6 Ejercicios de aplicación.

Ejemplo 1) Generar un arreglo de 10 elementos enteros ordenados de menor mayor.
tipo
var
vector: vec
entero: i, j, aux
inicio
escribir („ ingresar los valores‟)
leer (vec [i ] )
fin-desde
si vec [i ] > vec [ j ] entonces


aux  vec [ i ]
vec [j ]  aux
fin-si
fin-desde
fin-desde
fin-desde
fin
Ejemplo 2) Generar un arreglo de 10 elementos enteros ordenados de mayor a menor.
tipo
var
vector: vec
entero: i, j, aux
inicio
escribir („ ingresar los valores ‟)
leer (vec [i ] )
fin-desde
si vec [i ] < vec [ j ] entonces

aux  vec [ i ]

vec [j ]  aux
fin-si
fin-desde
fin-desde
fin-desde
fin
5.7 Búsqueda. Métodos.

Un algoritmo de búsqueda es aquel que está diseñado para localizar un elemento concreto
dentro de una estructura de datos. Consiste en solucionar un problema de existencia o no de un
elemento determinado en un conjunto finito de elementos, es decir, si el elemento en cuestión
pertenece o no a dicho conjunto, además de su localización dentro de éste.
5.8 Búsqueda secuencial.

Se utiliza cuando el contenido del vector no se encuentra o no puede ser ordenado. Consiste en
buscar el elemento comparándolo secuencialmente (de ahí su nombre) con cada elemento del
arreglo hasta que éste se encuentre, o hasta que se llegue al final del arreglo. La existencia se
puede asegurar desde el momento que el elemento es localizado, pero no podemos asegurar la
no existencia hasta no haber analizado todos los elementos del arreglo. A continuación se
muestra el pseudocódigo del algoritmo:
algoritmo Método_Busqueda_secuencial
//declaraciones
inicio
leer ( vec[ i ] )

fin-desde
//se toma la clave de búsqueda
leer ( clave)
//búsqueda
ban  falso
desde i  1 hasta n hacer
si vec [i ] = clave entonces
ban  verdadero
fin-si
fin-desde
si ban = verdadero entonces
mostrar ( „la clave de búsqueda está en el arreglo‟ )
si-no
mostrar ( „la clave de búsqueda NO está en el arreglo‟ )
fin-si
fin
5.9 Búsqueda binaria.

Se utiliza cuando el vector en el que queremos determinar la existencia o no de un elemento está
ordenado, o puede estarlo, este algoritmo reduce el tiempo de búsqueda considerablemente, ya
que disminuye exponencialmente con el número de iteraciones.
Para implementar este algoritmo se compara el elemento a buscar con un elemento cualquiera del
arreglo (normalmente el elemento central), si el valor de éste es mayor que el del elemento
buscado se repite el procedimiento en la parte del arreglo que va desde el inicio de éste hasta el
elemento tomado, en caso contrario se toma la parte del arreglo que va desde el elemento tomado
hasta el final. De esta manera obtenemos intervalos cada vez más pequeños, hasta que se
obtenga un intervalo indivisible, con el elemento buscado como elemento central. Si el elemento
no se encuentra dentro de este último entonces se deduce que el elemento buscado no se
encuentra en el arreglo.
La búsqueda binaria utiliza un método de „divide y vencerás‟ para localizar el elemento deseado.
A continuación se presenta el pseudocódigo del algoritmo, tomando como elemento inicial el

elemento central del arreglo.

Algoritmo búsqueda_binaria
// declaraciones
inicio
// llenar el arreglo x con N valores
// ordenar el arreglo
leer ( K) // clave de búsqueda
// se inicializan las variables para la búsqueda
bajo  1
alto  N // N es el número de elementos del arreglo
central  ent ( ( bajo + alto ) / 2)
mientras ( bajo < = alto ) y ( x [ central ] <> K) hacer
si K < x [ central] entonces
alto  central -1
si-no
bajo  central + 1
fin-si
central ent (( bajo +alto ) / 2)
fin-mientras
si K = x [central] entonces
escribir ( „valor encontrado‟)
si-no
escribir ( „valor no encontrar‟)
fin-si
fin
Bibliografía Obligatoria:

“Fundamentos de programación. Algoritmos, Estructuras de datos y Objetos”, Luis Joyanes
Aguilar. Mc Graw Hill. Tercera edición. Capítulo 10 (páginas 360 a 412)

Lectura 3 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lectura 3 PDF

Cargado por

Copyright:

Formatos disponibles

Lectura 3: Arreglos

Unidad 4: Estructura de Datos: Arreglos

4.1 Concepto de arreglo unidimensional

Las estructuras de datos son muy importantes en los sistemas de computadora.

Las estructuras de datos se clasifican en estáticas y dinámicas. Esta clasificación se basa en la

En programación, un arreglo, es un conjunto finito de elementos del mismo tipo (homogéneos)

Profesor: Ing. Silvia Carrera -1-

Dato [ 1] Dato [ 2] Dato [3] Dato [4]

Info [ 1] Info [ 2] Info [3] Info [4] Info [5]

escribir (Dato [4])

muestra por pantalla el contenido de la posición 4 del vector llamado Dato.

Profesor: Ing. Silvia Carrera -2-

En pseudocódigo un arreglo unidimensional se declara de la siguiente forma:

array [1..10] de entero : dato

Profesor: Ing. Silvia Carrera -3-

En el siguiente trozo de código, se crean dos vectores distintos:

array [1..10] de entero : dato

dato : origen, destino

array [1..10] de entero : dato

array [1..20] de real: vector1

array [1..3] de cadena: vector2

Materia: Programación Lógica

Profesor: Ing. Silvia Carrera -4-

4.2 Utilización de arreglos unidimensionales en algoritmos

4.3 Manejo de índices.

Entonces también sería válido

P[0], P[1], P[2], P[3], P[4], P[5]

Profesor: Ing. Silvia Carrera -5-

Lo mismo sucede con el siguiente caso:

P[-10], P[-11], P[-12], P[-13], P[-14], P[-15]

Las operaciones que pueden realizarse con vectores son:

En general, las operaciones con vectores implican el procesamiento o tratamiento de los

array [1..10] de entero : dato

escribir („ ingresar los 10 elementos del arreglo‟)

desde índice  1 hasta 10 hacer

leer ( origen [índice])

Materia: Programación Lógica

Profesor: Ing. Silvia Carrera -6-

En el trozo de código anterior se declara un arreglo lineal de 10 elementos de tipo entero, la

LECTURA /ESCRITURA DE DATOS

Las operaciones de lectura y escritura de los elementos de un arreglo lineal generalmente se

Si se desea mostrar por pantalla el contenido de una posición de un arreglo se utilizará la

array [1..10] de entero : dato

escribir („ ingresar los 10 elementos del arreglo‟)

leer ( origen [índice])

escribir („ Se muestran los elementos del arreglo lineal‟)

escribir (origen [índice])

Profesor: Ing. Silvia Carrera -7-

4.4 Resolución de problemas usando arreglos unidimensionales.

array [1..10] de entero : dato

escribir („ ingresar los 10 elementos del arreglo‟)

leer ( origen [índice])

escribir (origen [índice])

array [1..20] de entero : dato

Materia: Programación Lógica

Profesor: Ing. Silvia Carrera -8-

escribir („ ingresar los 20 elementos del arreglo‟)

leer ( ver [índice])

escribir („ Se muestran los elementos positivos pares‟)

si (vec [índice] > 0) y (vec [índice] mod 2 = 0) entonces

array [1..20] de entero : dato

escribir („ ingresar los 20 elementos del arreglo‟)

leer ( ver [índice])