Arreglos unidimensionales

Es un tipo de datos estructurado que está formado de una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales.

Están formados por un conjunto de elementos de un mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian por la posición que tiene cada elemento dentro del arreglo de datos. Al declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos. Para declarar un arreglo tiene que indicar su tipo, un nombre único y la cantidad de elementos que va a contener.

		Proceso Prueba
		    Definir num como entero;
		    Dimension num[5];
		FinProceso
						

En los arreglos empiezan desde 1 y acaban en la longitud que hayamos definido. En otros lenguajes de programación, los arreglos empiezan en 0 y acaban en la longitud -1 que hayamos definido.

		Proceso Prueba
		      Definir num como entero;
		      Dimension num[5];
		      num[0]=5;
		      num[1]=10;
		      num[2]=15;
		      num[3]=20;
		      num[4]=25;
		FinProceso
						

Como vemos, simplemente debemos indicar el nombre del arreglo, el indice y su valor. Deben estar dentro de la longitud creada, es decir, que en este caso no podríamos asignar un valor al indice 5.

Para recorrer un arreglo, deberemos usar una estructura repetitiva, lo mas recomendable es un Para o Desde donde la variable que declaremos, se insertara en el indice haciendo que en cada repetición varié. Veamos un ejemplo:

		Proceso Prueba
		      Definir num como entero;
		      Dimension num[5];
		      num[0]=5;
		      num[1]=10;
		      num[2]=15;
		      num[3]=20;
		      num[4]=25;
		      Para i<-0 Hasta 4 Con Paso 1 Hacer
		         escribir num[i];
		      Fin Para
		FinProceso
						

Ademas de mostrar los valores, también podemos introducirlos por teclado con leer nombre_array[indice] si queremos introducir valores en todos los indices, para ello usaremos un bucle. Veamos un ejemplo:

		Proceso Prueba
		      Definir num como entero;
		      Dimension num[5];
		      num[0]=5;
		      num[1]=10;
		      num[2]=15;
		      num[3]=20;
		      num[4]=25;
		      Para i<-0 Hasta 4 Con Paso 1 Hacer
		          leer num[i];
		      Fin Para
		      Para i<-0 Hasta 4 Con Paso 1 Hacer
		          escribir num[i];
		      Fin Para
		FinProceso
						

Por último, si has probado otros lenguajes de programación sabrás que se puede saber el tamaño de un arreglo, con un método. En pseudocódigo esto no existe, pero si podemos hacer para ello, podemos usar una constante para indicar el tamaño. La mayor ventaja es que si cambiamos el tamaño de un arreglo, solo deberemos cambiar en un lugar y no en todos.

		Proceso Prueba
		      Definir num como entero;
		      TAMANIO=5;
		      Dimension num[TAMANIO];
		      num[0]=5;
		      num[1]=10;
		      num[2]=15;
		      num[3]=20;
		      num[4]=25;
		      Para i<-0 Hasta TAMANIO-1 Con Paso 1 Hacer
		          Escribir "Escribe un valor para el indice ",i;
		          leer num[i];
		      Fin Para
		      Para i<-0 Hasta TAMANIO-1 Con Paso 1 Hacer
		          escribir num[i];
		      Fin Para
		FinProceso
						

Arreglo multidimensionales

Es un tipo de dato estructurado, que está compuesto por dimensiones. Para hacer referencia a cada componente del arreglo es necesario utilizar n índices, uno para cada dimensión. El término dimensión representa el número de índices utilizados para referirse a un elemento particular en el arreglo. Los arreglos de más de una dimensión se llaman arreglos multidimensionales.

Vemos que en Excel existen filas y columnas y que las celdas son el resultado de la unión de estas, es decir los campos que ellas forman, pues bien, los arreglos multidimensionales se asemejan a la unión de celdas de Excel, dicho arreglos tienen una dimensión la cual podemos acomodar a nuestro gusto y depende de las necesidades del programador.

		Proceso Prueba
		    Definir num como entero;
		    Dimension num[X,Y];
		FinProceso
						

X = Cantidad de filas,
Y = Cantidad de columnas

En los arreglos multidimensionales se declaran con las dos dimensiones a diferencia de el multidimensional.

		Proceso Prueba
		      Definir num como entero;
		      Dimension num[3,3];
		      num[0,0]=5;
		      num[1,0]=10;
		      num[2,0]=15;
		      num[0,1]=20;
		      num[1,1]=25;
		      num[2,1]=30;
		      num[0,2]=35;
		      num[1,2]=40;
		      num[2,2]=45;
		FinProceso
						

Como vemos, simplemente debemos indicar el nombre del arreglo, el renglon y la columna además de su valor. Deben estar dentro de la longitud creada, es decir, que en este caso no podríamos asignar un valor al indice 3,3 ni superior.

Para recorrer un arreglo, deberemos usar una estructura repetitiva, lo mas recomendable es un Para y necesitaremos realizar un siclo anidado, como ejemplo:

		Proceso Prueba
		      Definir num como entero;
		      Dimension num[3,3];
		      num[0,0]=5;
		      num[1,0]=10;
		      num[2,0]=15;
		      num[0,1]=20;
		      num[1,1]=25;
		      num[2,1]=30;
		      num[0,2]=35;
		      num[1,2]=40;
		      num[2,2]=45;
		      Para i<-0 Hasta 2 Con Paso 1 Hacer 
		         Para z<-0 Hasta 2 Con Paso 1 Hacer
			         escribir num[i,z];
			      Fin Para
		      Fin Para
		FinProceso
						

Ademas de mostrar los valores, también podemos introducirlos por teclado con leer nombre_array[renglon,columna] si queremos introducir valores en todos los indices, para ello usaremos dos bucles. Veamos un ejemplo:

		Proceso Prueba
		      Definir num como entero; 
		      Dimension num[3,3];
		      num[0,0]=5;
		      num[1,0]=10;
		      num[2,0]=15;
		      num[0,1]=20;
		      num[1,1]=25;
		      num[2,1]=30;
		      num[0,2]=35;
		      num[1,2]=40;
		      num[2,2]=45;
		      Para i<-0 Hasta 2 Con Paso 1 Hacer 
		         Para z<-0 Hasta 2 Con Paso 1 Hacer
			         leer num[i,z];
			      Fin Para
		      Fin Para
		      Para i<-0 Hasta 2 Con Paso 1 Hacer 
		         Para z<-0 Hasta 2 Con Paso 1 Hacer
			         escribir num[i,z];
			      Fin Para
		      Fin Para
		FinProceso