Hola Mundo 05

15/10/2015
HolaMundo.pascal(online):Captulo5
Ms Siguienteblog
Crearblog Acceder
Publicaciones del Autor

.pas
.c
.java
7 DE AG O STO DE 2 0 0 7
Captulo 5
..
Arrays
Un array es un conjunto de variables del mismo tipo cuyas direcciones de memoria son
consecutivas. Por lo tanto se puede identificar a cada una de las variables del conjunto con un
subndice.
Veamos un ejemplo.
testArray.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
vararr:array[1..5]ofinteger;
begin
arr[1]:=2;
arr[2]:=4;//asignoelvalor4enlaposicion2
arr[3]:=6;
arr[4]:=8;//asignoelvalor8enlaposicion4
arr[5]:=10;
//imprimoelvalordecadaelementodelarray
writeln('valordearr[1]=',arr[1]);
writeln('valordelarr[2]=',arr[2]);
end.
>> Click para Ms Informacin <<
Recursos / Download
SZDelphi (por JDownloader)
Instalacin y uso de Delphi
Plantilla de Diagramas p/Visio
Contenidos
1 Introduccin
2 Operadores
En el programa anterior definimos una variable arr de tipo array [1..5] of integer. Es decir:
definimos un array de enteros, de 5 elementos. Luego le asignamos un valor entero a cada una
de los elementos del array y (por ltimo) mostramos los valores que contienen los elementos
de cada una de las posiciones.
Veamos una representacin grfica del array arr.
3 Procedimientos y Funciones
4 Corte de Control
5 Arrays
6 Archivos de Registros
7 Estructuras Dinmicas
8 Arboles y Recursividad
9 Teora de Objetos (intro)
EjemplosResueltos
Ahora en Video!
http://holamundopascal.blogspot.mx/2007/08/capitulo5.html
1/23
15/10/2015
Vemos en la columna principal (recuadrada con lneas negras) las celdas que representan cada
uno de los elementos del array y sus respectivos valores. Y en la columna de la izquierda (con
lneas grises) los subndices que representan las posiciones de cada uno de los elementos.
La posibilidad de acceder a los elementos del array referencindolos mediante un subndice es
fundamental y hace de los arrays un recurso indispensable para la resolucin de cierto tipo de
problemas.
Modifiquemos el programa testArray.pas para acceder automaticamente a las posiciones del
array mediante el uso de ciclos for.
testArray2.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
Acerca del Autor

vararr:array[1..5]ofinteger;
i:integer;
begin
//cargoelarray
fori:=1to5dobegin
arr[i]:=2*i;
end;
//muestroloselementosdelarray
fori:=1to5dobegin
writeln('valordelarr[',i,']=',arr[i]);
end;
end.
Ing. Pablo A. Sznajdleder

Agradecimientos
No al blog de Java
Super Baterista
Con el primer for cargamos el array. El for itera haciendo variar i entre 1 y 5. Por lo tanto en
la primer iteracin, cuando i vale 1 hablar de arr[i] es hablar de arr[1]. En la siguiente
iteracin i valdr 2 entonces hablar de arr[i] es hablar de arr[2] y as.
Asignamos arr[i] := 2*i ya que (siguiendo con el ejemplo anterior) lo que queremos asignar en
cada posicin coincide con "el doble del ndice" de cada posicin del array.
Con el segundo for recorremos el array y mostramos lo que contiene en cada una de sus
posiciones.
Sitios Relacionados
PascAlgo (por Lic. Hugo Cuello)
Es muy importante tener en cuenta que los arrays son estructuras de datos estticas. Se
definen antes de que comience a ejecutarse el algoritmo por lo tanto tenemos que definir de
antemano su longitud (cantidad de elementos).
Algoritmia.net
Java Algorithm Framework
No podemos hacer esto:

var arr: array [1..n] of integer
Definir un array de (por ejemplo) 10 elementos no implica que (luego) necesariamente
vayamos a utilizar esos 10 elementos. Podemos utilizar solo algunos o (a lo sumo) los 10.
Obviamente, aunque solo utilicemos 1 de los 10 elementos del array la memoria reservada
siempre ser de 10 elementos durante toda la ejecucin del programa.
Operaciones Sobre Arrays

Buscar, insertar, eliminar y ordenar elementos sobre un array son algunas de las operaciones
que vamos a estudiar en este captulo.
Analizaremos los siguientes procedimientos y funciones que definiremos en una unit.
untArray.pas
1:
2:
3:
4:
5:
6:
7:
unituntArray;
interface
const
//podemosdefinirlalongituddelarray
//comounaconstante
2/23
15/10/2015
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
LTArray=10;
type
//definimosuntipodedatosquerepresente
//alosarraysdeestetipo:
//unarrayde1aLTArray(10)deinteger
TArray=array[1..LTArray]ofinteger;
//operacionesasociadasalmanejodearrays
//insertaunelementoenelarray,enuna
//posicionespecificada(pos)desplazandohacia
//abajoloselementosdelasposicionessiguientes
procedureinsertar(vararr:TArray
;varlen:integer
;valor:integer
;pos:integer);
//eliminaelelementodelaposicionespecificada
//desplazandohaciaarribaloselementosdelas
//posicionessiguientes
procedureeliminar(vararr:TArray
;varlen:integer
;pos:integer);
//buscaunelementoenelarrayyretornala
//posiciondondeloencontroounvalornegativo
//sielelementonoseencontroenelarray
functionbuscar(arr:TArray
;len:integer
;valor:integer):integer;
//insertaunelementoenelarrayperomanteniendo
//elordenascendentedeloselementos,retornala
//posicionenlaqueelelementofueinsertado
functioninsertarOrdenado(vararr:TArray
;varlen:integer
//buscaunelementoenelarray.Siloencuentra
//retornasuposicion,sinoloencuentraentonces
//loinsertaordenadoyretornalaposicion(en
//negativo)enlaqueelelementofueinsertado
functionbuscarEInsertarOrdenado(
vararr:TArray
;varlen:integer
//busquedabinariasobreelarray(temaaparte)
functionbuscarBin(arr:TArray
;len:integer
//ordenaloselementosdelarray(temaaparte)
procedureordenar(vararr:TArray;len:integer);
//laseccionimplementationestamasabajo
//:
Notemos que todos los procedimientos y funciones reciben el parmetro len. Este parmetro
indica la cantidad de elementos tiles del array. Es decir, si tenemos un array de 10 posiciones
de las cuales hasta el momento ninguna est siendo utilizada entonces el valor del parmetro
len ser 0. Pero si en ese mismo array insertamos un valor entonces el parmetro len debe
pasar a valer 1 ya que en el array ahora tenemos 1 elemento til (y espacio libre para nueve
elementos ms que hasta el momento no estn siendo utilizados).
procedure insertar (implementacin)

El objetivo de este procedimiento es insertar un valor (valor) en una posicin (pos) del array
(arr) desplazando hacia abajo todos los elementos que se encuentran a partir de la posicin
pos inclusive.
3/23
15/10/2015
En el grfico vemos como queda el array luego de insertar el valor 5 en la posicin 3. El valor
que estaba en la posicion 4 pas a la posicin 5 y el valor que estaba en la posicin 5 pas a la
posicin 6.
Es importante notar como juega el valor del parmetro len. El parmetro len indica cuantas
posiciones del array estn siendo efectivamente utilizadas. En el primer caso el parmetro
len vale 4 ya que el array contiene 4 elementos. El procedimiento insertar debe incrementar
el valor del parmetro len para reflejar que (luego de insertar el nuevo elemento) el array
tiene un elemento ms.
Notemos que el array tiene una longitud de 10 elementos. Sin embargo no todos
necesariamente tienen que ser utilizados. Justamente eso es lo que refleja el parmetro len.
Los elementos tiles del array son los que estn en las posiciones 1 a len.
Anlisis
Utilizamos un for downto que comienza en len+1 y termina en pos+1.
Considerando el ejemplo anterior, tendremos: len=4 (entonces len+1=5) y pos=3 (o sea que
pos+1=4). El for itera con i variando entre 5 y 4. En la primera vuelta (i vale 5) a arr[5] le
asignamos arr[4]. En la prxima vuelta (i vale 4) a arr[4] le asignamos arr[3]. Luego
asignamos valor a arr[pos].
Desplazamos todos los elementos hacia abajo para poder insertar el nuevo valor en la posicin
pos.
4/23
15/10/2015
untArray.pas (implementacin: procedure insertar)

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
//comenzamosconlaseccionimplementation
implementation
procedureinsertar(vararr:TArray
;varlen:integer
;valor:integer
;pos:integer);
vari:integer;
begin
fori:=len+1downtopos+1dobegin
arr[i]:=arr[i1];
end;
arr[pos]:=valor;
len:=len+1;
end;
Con esto podemos resolver el siguiente problema.
Problema 5.1
Dado un conjunto de valores positivos (no sern ms de 10 valores) imprimirlo en orden
inverso. Fin de datos: valor negativo.
Anlisis
Leemos valores mientras no se ingrese un valor negativo y los insertamos en el array arr, en la
posicin 1. Todos los insertamos en la primer posicin.
Supongamos que los valores que ingresan son: { 3, 2, 1, 1 } entonces la secuencia ser la
siguiente.
5/23
15/10/2015
Insertamos el 3 en la posicion 1. Luego insertamos el 2 en la posicin 1 (desplazando el 3 a la

posicin 2). Luego insertamos el 1 en la posicin 1 (desplazando el 2 a la posicin 2 y el 3 a la
posicin 3). As, al momento de recorrer e imprimir el array la salida ser: 1, 2, 3.
Recordemos que el procedimiento insertar incrementa el valor del parmetro len cada vez
que inserta un valor en el array.
problema5.1.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
usesuntArray;
var
arr:TArray;
i,n,len:integer;
begin
len:=0;
readln(n);
while(n>=0)dobegin
insertar(arr,len,n,1);
readln(n);
end;
fori:=1tolendobegin
writeln(arr[i]);
end;
end.
procedure eliminar (implementacin)

El objetivo de este procedimiento es eliminar el valor contenido en una posicin del array
desplazando una posicin hacia arriba todos los elementos que se encuentren en las posiciones
siguientes.
6/23
15/10/2015
Anlisis
La solucin para este algoritmo es simple. Asignar en la posicin pos el elemento de la
posicin pos+1. Luego asignar en la posicin pos+1 el elemento de la posicin pos+2, y as, si
hacemos variar a i entre pos y len1 podemos asignar al array arr en la posicin arr[i] el
elemento de la posicin arr[i+1].
Por ltimo, la cantidad de elementos tiles del array decreci. Entonces tenemos que
decrementar el valor del parmetro len (que recibimos por referencia).
untArray.pas (implementacin: procedure eliminar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
procedureeliminar(vararr:TArray
;varlen:integer
;pos:integer);
vari:integer;
begin
fori:=postolen1dobegin
arr[i]:=arr[i+1];
end;
len:=len1;
end;
function buscar (implementacin)

Este algoritmo lo implementamos como una funcin. El objetivo es buscar un elemento en el
array. El elemento puede estar o no. Si el elemento est entonces la funcin retorna la
posicin en la cual se encontr el elemento. Si el elemento no est entonces la funcin retorna
1 para indicar que el elemento no se encontr en el array.
7/23
15/10/2015
Anlisis
Recorremos el array mientras no nos pasemos de la ltima posicin (len) y mientras no
encontremos el elemento que buscamos.
Cuando corta el while preguntamos por cual de las dos condiciones cort. si cort porque i es
mayor que len entonces llegamos al final y no encontramos el elemento. Retornamos 1. Si
cort porque arr[i] = valor entonces lo encontr en la posicin i. Retornamos el valor de i.
untArray.pas (implementacin: function buscar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
functionbuscar(arr:TArray
;len:integer
vari:integer;
begin
i:=1;
while((arr[i]<>valor)AND(i<=len))dobegin
i:=i+1;
end;
if(i>len)thenbegin
buscar:=1;
endelsebegin
buscar:=i;
end;
end;
Problema 5.2
Leer un conjunto A de valores positivos (finaliza con un valor negativo). Luego leer otro
conjunto B de valores positivos (finaliza con un valor negativo). Imprimir los valores del
conjunto A que no pertenezcan al conjunto B. Se garantiza que los conjuntos no tendrn ms
de 10 valores.
8/23
15/10/2015
Anlisis
Leemos los valores del conjunto A y los insertamos en el array arr, en la posicion len+1 (es
decir: siempre al final).
Luego leemos los valores del conjunto B y por cada valor buscamos en el array. Si se encuentra
entonces lo eliminamos del array.
Por ltimo, recorremos e imprimimos los elementos de arr que sern los elementos del
conjunto A que no pertencen al conjunto B.
problema5.2.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
usesuntArray;
var
len,n,m,i,pos:integer;
arr:TArray;
begin
len:=0;
//leemoselconjuntoAyloinsertamos
//alfinaldelarray
write('IngresevaloresdelconjuntoA');
readln(n);
while(n>=0)dobegin
insertar(arr,len,n,len+1);
read(n);
end;
//leemoselconjuntoB,buscamosy(si
//seencuentra)eliminamoselvalordelarray
write('IngresevaloresdelconjuntoB');
readln(m);
while(m>=0)dobegin
pos:=buscar(arr,len,m);
if(pos>0)thenbegin
eliminar(arr,len,pos);
end;
read(m);
end;
writeln('ResultadoAB:');
9/23
15/10/2015
32:
33:
34:
35:
36:
fori:=1tolendobegin
writeln(arr[i]);
end;
end.
function insertarOrdenado (implementacin)

El objetivo de esta funcin es insertar un elemento (valor) en el array (arr) pero considerando
un orden de precedencia. Luego retorna la posicin en la cual se insert el elemento.
Anlisis
Recorremos el array mientras no nos pasemos del ltimo elemento til (len) y mientras no
encontremos un elemento mayor que el valor que nos piden insertar (valor). Cuando corta el
while preguntamos por cual de las dos condiciones cort. Si corto porque i es mayor que len
entonces el array no contiene ningn elemento menor o igual que valor. Es el mayor y debemos
insertarlo al final.
Si el while cort porque arr[i] es mayor que valor entonces tenenos que insertar el elemento
en la posicin i. Llamamos al procedimiento insertar y retornamos el valor de i.
untArray.pas (implementacin: function insertarOrdenado)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
functioninsertarOrdenado(vararr:TArray
;varlen:integer
vari:integer;
begin
i:=1;
while((i<=len)AND(arr[i]<=valor))dobegin
i:=i+1;
end;
if(i>len)thenbegin//insertoalfinal
len:=len+1;
arr[len]:=valor;
insertarOrdenado:=len;
endelsebegin//insertoenlaposicioni
insertar(arr,len,valor,i);
10/23
15/10/2015
18: insertarOrdenado:=i;
19: end;
20: end;
21:
function buscarEInsertarOrdenado (implementacin)

Esta funcin es similar a la anterior. La diferencia es que antes de insertar el elemento
verifica si ya existe en el array. Si ya existe entonces no lo inserta y devuelve la posicin
donde lo encontr. Si no existe entonces lo inserta respetando el orden de precedencia y
retorna la posicin donde lo insert. Para indicar al usuario (quien llama a la funcin) si el
elemento exista previamente o si lo tuvo que insertar, la funcin retorna su valor en positivo
o en negativo. Es decir:
pos:= buscarEInsertarOrdenado(...);
si pos es positivo entonces el elemento se encontr en la posicin pos
si pos es negativo entonces el elemento se insert en la posicin abs(pos)
Anlisis
A medida que vamos teniendo ms funciones resueltas resulta ms facil programar nuevas
funciones.
Para resolver esta funcin primero buscamos el elemento valor. Si no lo encontramos entonces
lo insertamos ordenado. En ret tenemos la posicin donde se insert el elemento pero la
tenemos que negativizar para retornar ese mismo valor en negativo. De esta manera le
indicamos al llamador (programa que invoca a esta funcin) que el elemento no estaba y
entonces lo insertamos.
Si el elemento fue encontrado entonces simplemente retornamos la posicin en la que se
encontr.
untArray.pas (implementacin: function buscarEInsertarOrdenado)
1:
2:
3:
4:
5:
6:
7:
8:
9:
functionbuscarEInsertarOrdenado(
vararr:TArray
;varlen:integer
vari,ret:integer;
begin
i:=buscar(arr,len,valor);
if(i<0)thenbegin
11/23
15/10/2015
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
ret:=insertarOrdenado(arr,len,valor);
//negativizamoselvalorderet
ret:=0ret;
endelsebegin
ret:=i;
end;
buscarEInsertarOrdenado:=ret;
end;
Problema 5.3
Leer un conjunto de valores e imprimirlos ordenados, sin repeticin. El conjunto finaliza con
un valor cero. No tendr ms de 10 valores. Indicar cuantos valores repetidos tiene el
conjunto.
Anlisis
El problema es muy simple. Leemos los valores del conjunto mientras no se ingrese el
elemento final identificado por un valor cero. Tenemos un array arr en el cual
buscamosEInsertamos los valores del conjunto. Es decir: solo insertamos si no existen
previamente. Los que se repiten los podemos identificar porque la funcin
buscarEInsertarOrdenado los encontrar en el array y retornar un valor positivo entonces
en contRep contamos la cantidad de valores repetidos del conjunto. Al finalizar el ingreso de
datos, el array contendr todos los elementos no repetidos del conjunto y estos estarn
ordenados.
problema 5.3.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
usesuntArray;
var
contRep,len,i,v,pos:integer;
arr:TArray;
begin
contRep:=0;
len:=0;
readln(v);
12/23
15/10/2015
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
while(v<>0)dobegin
pos:=buscarEInsertarOrdenado(arr,len,v);
if(pos>0)thenbegin
contRep:=contrep+1;
end;
readln(v);
end;
writeln('Repetidos:',contRep);
fori:=1tolendobegin
writeln(arr[i]);
end;
end.
Problema 5.4
Un kiosco vende 100 artculos diferentes. Al finalizar el da de trabajo cuenta con una planilla
con la siguiente informacin:
nroTicket
idArticulo [1..100]
cantidad
precioUnit
Fin de datos: nroTicket = 0.
Se requiere un programa que permita totalizar la cantidad vendida de cada uno de los artculos
que comercializa el kiosco imprimiendo un listado con el siguiente diseo:
Anlisis
Para resolver este programa ser necesario utilizar dos arrays de 100 posiciones cada uno.
Un array para totalizar la cantidad vendida de cada artculo (arrCant) y otro array para
totalizar los montos de facturados en cada ticket (arrMonto).
El problema se limita a leer los datos de la planilla y acumular los valores en los arrays, en la
posicin identificada por idArticulo. Recordemos que son 100 artculos numerados de 1 a 100.
13/23
15/10/2015
Ahora vamos a modificar el enunciado del problema anterior para ilustrar una situacin muy
comn cuya resolucin se facilita enormemente si disponemos de las funciones que analizamos
ms arriba.
Problema 5.4.1
Idem. problema 5.4 pero con las siguientes modificaciones:
1. idArticulo valor alfanumrico, 3 caracteres.
2. El kiosco comercializa a lo sumo 100 artculos (pueden ser menos)
Anlisis
Si bien puede no haber demasiada diferencia con el enunciado anterior, los cambios que se
proponen en este problema complican bastante la resolucin del ejercicio.
La principal diferencia es que el idArticulo ahora es alfanumrico y por este motivo no lo
podemos utilizar como ndice para acceder a los arrays.
Por otro lado, el kiosco no necesariamente comercializa 100 artculos diferentes. Podran ser
menos.
Para resolver este problema tendremos que explicar el concepto de array paralelo. Es decir:
un array en el que iremos guardando los idArticulo. La posicin que cada idArticulo ocupa en
el array ser la posicin que utilizaremos para acceder a los otros arrays para acumular los
montos y las cantidades.
Supongamos que la planilla tiene la siguiente informacin:
14/23
15/10/2015
Entonces a medida que leemos cada idArticulo buscamosEInsertamos en un array

(arrArticulo). La funcin nos retorna la posicin donde se insert o donde se encontr el
idArticulo. Luego utilizamos esa posicin para acumular en los otros arrays.
Vemos que tanto arrCant como arrMonto son arrays paralelos a arrArticulo. Es decir: por cada
artculo que leamos de la planilla primero lo tendremos que buscar en arrArticulo para ver en
que posicin est y luego, con esa posicin acceder a arrCant y a arrMonto para acumular las
cantidades correspondientes.
Comparemos la solucin del problema 5.4 con la solucin del problema 5.4.1.
.Problema 5.4.......................Problema 5.4.1
15/23
15/10/2015
Comparando podemos notar la diferencia. En este caso, por cada idArticulo buscamos en el
array arrArticulo en que posicin est. Si an no estaba entonces lo insertamos. La funcin
buscarEInsertarOrdenado podra devolver un valor negativo (si es que el idArticulo no estaba
y lo tuvo que insertar). Por ese motivo eliminamos el signo asignndole su valor absoluto.
Una vez que tenemos la posicin en la que el idArticulo est ubicado en arrArticulo utilizamos
esa posicin para acceder a los otros array.
Podramos decir que el acceso es indirecto. Primero accedemos al array paralelo para obtener
la posicin y luego, con esa posicin accedemos a otros arrays. En cambio, en la solucin de la
derecha (del problema 5.4) el acceso es directo.
Ordenamiento
Hasta aqu trabajamos con arrays ordenados porque a medida que insertbamos los elementos
lo hacamos desplazando los mayores hacia abajo de forma tal que el array siempre mantenga
su orden (con la funcin insertarOrdenado por ejemplo).
Veremos ahora un algoritmo que nos permitir ordenar un array desordenados. El algoritmo
burbuja.
La idea es la siguiente: recorrer el array de arriba (primer posicin) a abajo (ltima posicin)
preguntando si el elemento de la posicin [i] es mayor que el elemento de la posicin [i+1].
Si se verifica esa pregunta entonces esos dos elementos estn desordenados entre si. As que se
los permuta y se pregunta por el elemento en la posicin [i+1] respecto del de la posicin
[i+2] y as sucesivamente.
16/23
15/10/2015
Anlisis
El algoritmo itera el array desde 1 hasta len1 y compara cada posicin respecto de la
siguiente. Si la posicin arr[i+1] es menor que arr[i] entonces esos elementos estn
desordenados entre s y los permuta. Luego compara arr[i+2] respecto de arr[i+1] y as hasta
comparar arr[len] respecto de arr[len1].
Luego de terminar la iteracin del array (es decir, luego de que termina el ciclo for) el array
queda un poco ms ordenado. Es decir que forzando una nueva recorrida lo podremos ordenar
un poco ms. Para esto se utiliza la variable ordenado. Esta variable comienza en false pero
ni bien ingresamos al while se pone en true. Si realizamos al menos una permutacin la
ponemos en false para forzar una nueva iteracin del while y as una nueva barrida del array.
Pongamos el siguiente ejemplo. Un array arr = { 4, 3, 2, 1 } en ese orden. Est desordenado si
consideramos un orden ascendente. El len (elementos tiles) del array ser 4.
En la figura de la izquierda vemos la primer iteracin del ciclo while (es decir: las primeras 4
iteraciones del ciclo for)
Vemos que para un array de 4 elementos totalmente desordenados, en la primer pasada del for
se realizarn 3 permutaciones.
En la figura de la derecha vemos la segunda iteracin del while (prximas 4 iteraciones del
for). Podemos ver que en este caso solo se realizan 2 iteraciones ya que el array est un poco
ms ordenado que al principio.
Veamos las prximas iteraciones del while.
17/23
15/10/2015
En la tercer iteracin del while (figura de la izquierda), dentro del for solo se realiza una
nica permutacin. Si bien el array queda ordenado, la variable ordenado qued en false con
lo cual se fuerza una nueva iteracin del while (figura de la derecha). En esta ltima
iteracin, dentro del for no se realiza ninguna permutacin. As que la variable ordenado
permanecer en true y as finaliza el algoritmo.
untArray.pas (implementacin: procedure ordenar)
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
procedureordenar(vararr:TArray;len:integer);
varordenado:boolean;i,aux:integer;
begin
ordenado:=false;
while(NOTordenado)dobegin
ordenado:=true;
fori:=1tolen1dobegin
if(arr[i+1]<arr[i])thenbegin
aux:=arr[i];
arr[i]:=arr[i+1];
arr[i+1]:=aux;
ordenado:=false;
end;
end;
end;
end;
Bsqueda Binaria
Este algoritmo provee una bsqueda mucho ms eficiente que la bsqueda secuencial. Parte de
la supocicin de que el array sobre el que se va a realizar la bsqueda est ordenado.
La idea es descartar "mitades" del array. Se hace un promedio (k) entre la primer posicin (i) y
la ltima (j) y se compara el elemento que se encuentra en esa posicin promedio (arr[k])
respecto del valor que estamos buscando. Si coincide entonces el problema est resuelto. Si no
coincide entonces el elemento encontrado podra ser mayor o menor. Si el elemento
encontrado es menor quiere decir que el elemento que nosotros buscamos est en la segunda
mitad. Si lo que encontramos es mayor entonces lo que buscamos est en la primer mitad del
array.
Veamos un ejemplo: El array arr tiene 6 elementos y est ordenado. Buscamos el elemento 14.
18/23
15/10/2015
Con i=1 y j=6 la posicin promedio (haciendo k:=(i+j) div 2) es 3. Si el elemento que estamos
buscando es el 14 entonces vemos que lo que encontramos (arr[k]=9) es menor que 14.
Entonces descartamos la primer mitad asignando a i el valor de k+1.
En la imagen del medio vemos que i=4, j=6 y k=5. Buscamos el valor 14 y arr[k]=17.
Entonces descartamos la segunda mitad haciendo j:=k1 con lo que j queda en 4.
En la imagen de la derecha vemos que i=4, j=4 entonces k=4 y resulta que arr[4]=14.
Encontramos lo que buscbamos.
Pero que pasa si buscamos un valor que no existe dentro del array? Busquemos el valor 8.
Vemos que los ndices i y j terminan cruzados. Es decir: i resulta mayor que j. Esto nos indica
que el valor que buscamos no existe en el array.
Ahora si, podemos ver el algoritmo.
La bsqueda binaria realiza un mximo de log2(len) comparaciones (siendo len la cantidad de

elementos tiles del array).
untArray.pas (implementacin: function buscarBin)
1:
2: functionbuscarBin(arr:TArray
19/23
15/10/2015
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
;len:integer
vari,j,k:integer;encontrado:boolean;
begin
encontrado:=false;
i:=0;
j:=len;
while((i<=j)AND(NOTencontrado))dobegin
k:=(i+j)div2;
if(arr[k]=valor)thenbegin
encontrado:=true;
endelsebegin
if(arr[k]<valor)thenbegin
i:=k+1;
endelsebegin
j:=k1;
end;
end;
end;
if(i>j)thenbegin
buscarBin:=1;
endelsebegin
buscarBin:=k;
end;
end;
end.//finuntArray.pas
Matrices
Vimos que los arrays son conjuntos de variables del mismo tipo: arrays de integer, arrays de
string, etc. Que pasara si definimos un array donde cada uno de sus elementos fuese un
array? Un array de arrays...
Llamamos matriz a un array de arrays, y en Pascal se define as:
// notacion Pascal
var mat: array[1..3,1..4] of integer;
o bien as:
// notacion alternativa, tambien es valida
var mat: array[1..3] of array[1..4] of integer;
Problema 5.5
Leer los valores de una matriz numrica de 3 filas y 4 columnas. Primero los 4 valores de la
fila 1, luego los de la fila 2 y luego los de la fila 3. Imprimir la matriz traspuesta.
Anlisis
Primero analicemos una matriz de 3x4 con datos de ejemplo y estudiemos su traspuesta para
entender lo que tiene que hacer el algoritmo.
Vemos que si la matriz original es de 3x4 entonces su traspuesta es de 4x3, de forma tal que
20/23
15/10/2015
las columnas de la matriz original pasan a ser las filas de la matriz traspuesta.
Entonces el algoritmo consiste en leer los valores, cargarlos en una matriz y luego recorrer la
matriz por columnas.
Como vemos manejamos 2 pares de ciclos for anidados. El primero es para leer los valores de
la matriz. La variable i representa las filas y la variable j representa las columnas. Entonces
si i vara entre 1 y 3 y por cada valor de i, j vara entre 1 y 4, cuando leemos en mat[i,j]
estamos leyendo cada una de las celdas de la matriz, comenzando de arriba hacia abajo (filas)
y de izquierda a derecha (columnas).
El segundo par de ciclos for anidados es para imprimir los valores. Notemos que en este caso el
for externo hace variar j entre 1 y 4 y el interno hace que i vare entre 1 y 3. Con esto
recorremos la matriz por columnas y as logramos imprimir la matriz traspuesta.
problema5.5.pas
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
var
mat:array[1..3,1..4]ofinteger;
i,j:integer;
begin
//recorrolasfilas
fori:=1to3dobegin
write('Ingresefila',i,':');
//recorrolascolumnas
forj:=1to4dobegin
readln(mat[i,j]);
end;
end;
//recorrolascolumnas
forj:=1to4dobegin
//recorrolasfilas
fori:=1to3dobegin
write(mat[i][j],'');
end;
writeln();
end;
end.
21/23
15/10/2015
Arrays Multidimensionales
As como una matriz es un "array de arrays", si consideramos una "matriz de arrays" tendremos
un array de 3 dimensiones: un "array de arrays de arrays" o simplemente un array 3d.
// notacion
var x: array[1..3,1..4,1..4] of iteger;
Luego de la definicin anterior x ser un array de 3 dimensiones y lo podemos representar
as:
La primer dimensin representa las filas, la segunda representa las columnas y la tercer
dimensin representa la profundidad (o plano).
.
Algoritmos y Estructuras de Datos UTN UBA.
Publicado por PabloSZ
3 comentarios:
Annimo dijo...
En los diagramas utilizas el elemento utilizado para graficar los WHILE en los FOR, los
esquemas son distintos.
18 octubre, 2008 01:42
Ivn Mikiej dijo...
cometiste un error, en la resolucion del problema 5.3, porqe vos estas contando CADA
vez q se repite un numero, pero NO cuantos numeros distintos se repiten. Es una
peqea diferencia, pero es;)
29 septiembre, 2009 14:55
PabloSZ dijo...
Es un tema de interpretacin del enunciado. La resolucin est bien.
Saludos,
Pablo.
22/23
15/10/2015
06 abril, 2010 19:05
Publicar un comentario en la entrada
Entrada ms reciente
Pgina principal
Entrada antigua
Suscribirse a: Enviar comentarios (Atom)
Todos los Derechos Reservados Propiedad Intelectual Nro. 591212
23/23

Hola Mundo 05

Uploaded by

Document Information

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

Hola Mundo 05

Uploaded by

Copyright:

Available Formats

15/10/2015

Publicaciones del Autor

>> Click para Ms Informacin <<

Acerca del Autor

Ing. Pablo A. Sznajdleder

No podemos hacer esto:

Operaciones Sobre Arrays

procedure insertar (implementacin)

untArray.pas (implementacin: procedure insertar)

Con esto podemos resolver el siguiente problema.

Insertamos el 3 en la posicion 1. Luego insertamos el 2 en la posicin 1 (desplazando el 3 a la

procedure eliminar (implementacin)

function buscar (implementacin)

function insertarOrdenado (implementacin)

function buscarEInsertarOrdenado (implementacin)

Entonces a medida que leemos cada idArticulo buscamosEInsertamos en un array

La bsqueda binaria realiza un mximo de log2(len) comparaciones (siendo len la cantidad de

Publicar un comentario en la entrada

Suscribirse a: Enviar comentarios (Atom)

Todos los Derechos Reservados Propiedad Intelectual Nro. 591212

You might also like