ARREGLOS MULTIDIMENSIONALES

VARIABLES CON ÍNDICE O LOCALIZADOR. ARRAYS. MATRICES. (CONTINUACIÓN).

ARRAYS MULTIDIMENSIONALES.

 

 

Supongamos una academia en la que se imparten cuatro asignaturas de idiomas con tres

niveles: básico, medio y perfeccionamiento. Para el tratamiento informático de datos podemos

recurrir a un array de dos localizadores. Trasladaremos siempre la realidad a forma

matemática. En este caso, podríamos decir:

 

 

 

 

 

 

La definición como variables normales sería algo así:

 

Clave:   N   =    nivel                  Función de variable: indicar el número de alumnos en un grupo dado            I     =    idioma

 N1I1, N1I2, N1I3, N1I4, N2I1, N2I2, N2I3, N2I4, N3I1, N3I2, N3I3, N3I4.

 

 

La definición como matriz sería algo así:

 

 

 

Normalmente no nos interesa representar la matriz indicando la posición de las variables, sino

su contenido. Así podríamos tener:

 

 

 

La matriz anterior nos informaría de que en el nivel 2 (nivel medio), idioma 3 (alemán), hay 7

alumnos.

 

El tratamiento de datos, al igual que indicáramos para el caso de arrays de un localizador,

resulta muy ventajoso usando matrices en vez de variables normales. Así para calcular el

número de alumnos totales podríamos:

 

    a) Con variables normales efectuar un sumatorio del tipo:

 

TOTAL = N1I1 + N1I2 + N1I3 + N1I4 + N2I1 + N2I2 + N2I3 + N2I4 + + N3I1 + N3I2 + N3I3 + N3I4

 

 

b) Con variables con índice usar una instrucción del tipo:

 

TOTAL = TOTAL + NI (i,j)   para i enteros entre 1 y 3, y j enteros entre 1 y 4

 

 

Aunque las variables con uno o dos localizadores son las más usadas, podremos recurrir a

tantos localizadores como estimemos necesarios. La representación matemática o visual ya no

es tan sencilla. Para interpretarlos o saber cuándo usarlos, recurriremos a pensar que cada uno

de los localizadores representa una característica, condicionante, o parámetro definidor del

elemento.

 

Volvamos al ejemplo del conteo de coches. El tipo de variable a usar depende de qué

queramos hacer. Así podríamos plantear:

 

 

Duración

del

conteo

 

 

Tipo de variables a emplear 

 

Ejemplo 

 Un día

 Array de un localizador (hora) Nc(1), Nc(2),Nc(3),...

Varios días

Array de dos localizadores (hora y día)

 Nc(1,1), Nc(2,1), Nc(3,1),...Nc(1,2), Nc(2,2), Nc(3,2),...

 

Varios meses

 Array de tres localizadores (hora, día y mes)

 Nc(1,1,1), Nc(2,1,1),....

Varios años

Array de cuatro localizadores (hora, día, mes y año)

 Nc(1,1,1,2005),

Nc(2,1,1,2005),... 

 

 

La interpretación de cada variable pasaría por interpretar el significado de cada localizador. Así:

 

Nc(1)  equivaldría a “Número de coches en la hora 1” Nc(3,2)  equivaldría a “Número de coches en la hora 3 del día 2” Nc(2,1,4)  equivaldría a “Número de coches en la hora 2 del día 1 del mes 4” Nc(15,3,4,2005)   equivaldría a “Número de coches en la hora 15 del día 3 del mes 4 del año 2005”

 

 

Nos hemos referido hasta ahora a arrays de contenido numérico: número de

coches, número de alumnos, etc. Éstos serán quizás los que más usemos, pero igualmente

podemos usar arrays con contenido alfanumérico.

 

Por ejemplo en un array que definiera el curso de un alumno y el número que tiene asignado

podríamos disponer de información del tipo:

 

      A(3,24) = “Pedro Hernández González"

 

 

Esto vendría a ser equivalente a: “El alumno número 24 del curso tercero se llama Pedro

Hernández González”.

 

Repetiremos en relación a los arrays lo que ya hemos dicho para las variables: podemos crear

arrays de tipo numérico o de tipo alfanumérico, pero una vez creados evitaremos modificar el

tipo de información que contienen. Es decir:

 

 

 

Por otro lado, evitaremos tener variables de distinta condición (numérica– alfanumérica) dentro

de un array. Todos los elementos del array serán del mismo tipo:

 

 

 

Muchas veces necesitaremos mantener relacionada información numérica con alfanumérica,

por ejemplo nombre del cliente con importe de una compra, o color de una superficie con

metros cuadrados de extensión. En algunas ocasiones nos dará igual sustituir la variable

alfanumérica por una clave numérica (p. ej. 1 = amarillo, 2 = verde, 3 = rojo) pero en otras

preferiremos conservar la información alfanumérica tal cual. En este caso usaremos distintas

variables a las que consideraremos “asociadas”.

 

 

 

Obviamente no todas las variables con el mismo localizador se considerarán “asociadas”. Es el

programador quien decide cuáles considera asociadas y cuáles no.

 

 

 

 

 

 

Para acceder a la información general sobre este curso y al listado completo de entregas pulsa

en este link:  Ver curso completo.

 

Para  hacer un comentario o consulta utiliza los foros aprenderaprogramar.com, abiertos a

cualquier persona independientemente de su nivel de conocimiento.

ARREGLOS MULTIDIMENSIONALES

INTRODUCCIÓN Un arreglo multidimensional es simplemente una extensión de un arreglounidimensional. Más que almacenar una sola lista de elementos, piense en un arreglomultidimensional como el almacenamiento de múltiples listas de elementos. Por ejemplo, un arreglo bidimensional almacena listas en un formato de tabla de dos dimensiones de filas y columnas, en donde cada fila es una lista. Las filas proporcionan la dimensión vertical del arreglo, y las columnas dan la dimensión horizontal. Un arreglo de tres dimensiones almacena listas en un formato de tres dimensiones de filas, columnas y planos, en donde cada plano es un arreglo bidimensional. Las filas proporcionan la dimensión vertical; las columnas, la dimensión horizontal; y los planos, la dimensión de profundidad del arreglo. • • Declarar y manipular arreglos con múltiplesíndices. En esta lección, aprenderá acerca de los arreglos de dos y tres dimensiones (raramente se necesitan en programación arreglos de mayor dimensión) La lección concluirá con un extenso ejercicio de solución de problemas empleando arreglos de dos dimensiones para resolver una serie de ecuaciones simultáneas usando la regla de Cramer.

-----------------------------------------------------------------------------------------------------------------------------Arreglos multidimensionales: 

Dado que casi nadie ha hecho preguntas ni ha comentado nada, asumo que la llevan bien con la lección anterior y pues, publico esta como anexo ya que es un poco más de lo mismo. Espero que comenten en esta lección como llevan el curso hasta ahora, qué les ha parecido las explicaciones dadas, si creen que se entiende bien a pesar de la complejidad creciente, etc. De verdad eso es un estímulo para continuar con este trabajo. 

Los arreglos que hemos visto hasta ahora son unidimensionales (lineales), o sea, de una única dimensión. Se dice esto ya que se requiere una única coordenada (índice) para ubicar una celda del mismo. Sin embargo es posible definir arreglos de dos dimensiones (2D), de tres dimensiones (3D) y más. Aquí veremos ejemplos de arreglos de hasta tres dimensiones ya que no requerimos de más para trabajar, sin embargo muchos programas usan arreglos de N dimensiones. Como nosotros existimos en un espacio de dimensión 3 solo podemos ver gráficamente arreglos de dimensión 3 o menor, pero visualizar un arreglo de dimensión 4 o más se hace difícil y no compete a este curso. 

Arreglos bidimensionales: 

Comencemos por ver arreglos de dos dimensiones. Estos dibujarán una tabla de datos del mismo tipo, también conocidas matemáticamente como matrices. Hay dos maneras de declarar arreglos bidimensionales, una es declarar un arreglo de un arreglo, o sea, un arreglo cuyas celdas sean también arreglos. Esta es la forma más fea de hacerlo y la que menos recomiendo, pero existe. Veámoslo en un ejemplo: 

Código:

1   PROGRAM BIDIMENSIONAL; 2 3   Type 4      arr1= array[1..5] of integer; 5      Tabla= array[1..7] of arr1; 6 7   Var 8      i, j: integer; 9      matriz: Tabla; 10 11 BEGIN 12 For i:= 1 to 7 do 

13    For j:= 1 to 5 do 14       matriz[i,j]:= 0; 15 END.

En la línea 4 vemos un tipo arr1 que es un arreglo de 5 celdas de enteros. En la línea 5 vemos el tipo Tabla que es un arreglo de 7 celdas del tipo arr1, o sea que cada celda es un arreglo de 5 celdas. Si dibujáramos Tabla al igual que lo hicimos antes tendríamos 7 celdas del 1 al 7, esto estaría indicando cuantas filas tiene nuestra tabla. Si desplegamos cada celda de Tabla estaríamos abriendo hacia la derecha 5 lugares con lo cual estaríamos indicando las columnas de nuestra tabla. 

 

Ese sería el dibujo de Tabla, como ven hay 7 filas (líneas horizontales) y 5 columnas (líneas verticales). El 0 corresponde a la posición (3,3) de la tabla ya que está en la fila 3 y en la columna 3. Siempre para una tabla se especificarán las coordenadas de una celda nombrando primero el número de filas y luego el de columnas. 

En la línea 9 del ejemplo declaramos la variable matriz del tipo Tabla. El trabajo con los arreglos bidimensionales es idéntico al de los arreglos unidimensionales. Cada celda es una variable independiente y para acceder a cada una simplemente nombramos nuestro arreglo y damos entre paréntesis rectos las coordenadas de nuestra celda separadas por comas. La forma genérica sería así: 

Variable_arreglo[fila,columna] 

de este modo, si quisiéramos ir a la celda que está en la fila 7 y en la columna 4 deberíamos escribir matriz[7,4]. 

En nuestro programa de ejemplo asignamos a cada celda el valor 0. Como ven debemos usar dos FOR anidados para recorrer una tabla, uno para recorrer las filas y otro para las columnas. 

Vean que el subrango en arr1 indica cuántas columnas tendrá la matriz y en subrango en Tabla indica cuántas filas. Una sintaxis alterna para acceder a una celda de nuestra tabla es la siguiente: 

Variable_arreglo[fila][columna] 

y por tanto si, usando esta sintaxis, quisiéramos acceder a la fila 7 y la columna 4 deberíamos escribir matriz[7][4]. No recomiendo esta sintaxis. 

Veamos ahora la segunda forma de declarar un arreglo bidimensional, la cual es la que yo recomiendo que usen: 

Código:

1   PROGRAM BIDIMENSIONAL; 2 3   Type 4      Tabla= array[1..7,1..5] of integer; 5 6   Var 7      i, j: integer; 8      matriz: Tabla; 9 10 BEGIN 11 For i:= 1 to 7 do 12    For j:= 1 to 5 do 13       matriz[i,j]:= 0; 14 END.

Como ven en la línea 4 hemos declarado el tipo Tabla en el cual hemos incluido dos subrangos entre los paréntesis rectos separados por coma. El primer subrango (1..7) indica la cantidad de filas y el segundo (1..5) la cantidad de columnas que tendrá la matriz. Esto siempre es así. Como ven, de este modo queda todo mucho más claro. 

NOTA: La cantidad de celdas de un arreglo bidimensional es igual al resultado de multiplicar la cantidad de filas por la cantidad de columnas. 

Como ejercicio quiero que modifiquen ese programa para que despliegue en la salida estándar la matriz. En este caso aparecerá una tabla de 0 como esta: 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 

Esto no es muy difícil y radica explícitamente en el uso de FOR. 

------------------------------------------------------------------------------------- 

Ejercicios: 

Ejercicio2: Modifiquen los programas anteriores para que, si el usuario no ingresa un entero, notifiquen el error y vuelvan a pedir el valor correcto. 

----------------------------------------------------------------- 

Ejercicio3: Se llama matriz cuadrada a toda aquella matriz que tiene tantas filas como columnas, o sea, si tiene 5 filas tiene 5 columnas. La transpuesta de una matriz cuadrada es aquella matriz que tiene como columnas lo que antes eran filas. O sea, si tenemos una matriz cuadrada A, una matriz cuadrada B es transpuesta de A si las columnas de B son iguales a las filas de A, o sea, si se satisface que B[i,j]=A[j,i] para todos los valores posibles de i y j. 

Ejemplo. Sea A de 5 filas y 5 columnas como se muestra en la figura, veamos como sería su transpuesta B: 

A 1 2 3 4 5 0 0 0 0 0 1 1 1 1 1 5 4 3 2 1 2 2 2 2 2 

B 1 0 1 5 2 2 0 1 4 2 3 0 1 3 2 4 0 1 2 2 5 0 1 1 2 

Como ven, lo que en A eran filas, en B son columnas. La primera fila de A que contiene los valores 1, 2, 3, 4 y 5 es la primera columna de B 1, 2, 3, 4 y 5, y así sucesivamente. 

Escriban un programa que calcule la transpuesta de un arreglo de números reales con cinco renglones y cinco columnas. Los valores de la matriz se leen desde la entrada estándar. El resultado se debe imprimir en la salida estándar. Recuerden la relación B[i,j]=A[j,i] para que sean transpuestas. 

Este ejercicio no es muy complicado. Tal vez lo peor de esto es que trabaja con una propiedad matemática de las matrices y para aquellos que no lo han estudiado puede resultar difícil de comprender. Aún así creo que no deberían tener problemas, sin embargo se trata de comprender el Álgebra Lineal y eso no es lo que quiero en este curso. 

------------------------------------------------------------------------------------- 

Arreglos tridimensionales: 

Esto es básicamente lo mismo. Se declaran exactamente igual solo que ahora habrá tres subrangos entre paréntesis rectos y por ende deberemos colocar tres coordenadas para indicar cual celda deseamos ver (una coordenada para la fila (altura), otra para la columna (largo) y otra para el eje (ancho)). Hago esta aclaración porque si bien un arreglo bidimensional dibuja una tabla, uno tridimensional dibuja un prisma y por tanto debemos decir cuan a lo alto, largo y ancho queremos posicionarnos. 

 

Esto es un arreglo bidimensional de 5 filas y 8 columnas. Visto de este modo es un rectángulo donde la cantidad de filas son su altura y la cantidad de columnas su largo. Este es un arreglo de 5x8. 

 

Así podríamos visualizar un arreglo tridimensional de 5x8x6. Como ven es un arreglo de tablas que estarían todas bien pegadas formando un prisma. Nosotros debemos indicar en qué fila y

columna está nuestra celda y en cual tabla de todas. Siempre indicamos [fila, columna, tabla]. Esto es un intento de que puedan visualizar un arreglo tridimensional. 

El punto rojo correspondería a la posición [4,8,3] por estar en la cuarta fila, octava columna de la tercera tabla. El azul correspondería a la posición [1,3,6]. Hasta aquí llegamos con arreglos, en la siguiente lección les propondré un proyecto llamado Master Mind enfocado para el uso de arreglos, pero necesito que me comenten que tal la llevan hasta ahora, qué les parece todo y si creen que vale la pena continuar de esta manera. 

------------------------------------------------------------------------------------- 

Librería CRT: 

Limpiar la pantalla: Muchas veces puede resultar muy conveniente el hecho de borrar el contenido de la pantalla para mostrar uno nuevo y no que lo anterior se desplace hacia arriba. Ustedes mismos habrán visto que al ejecutar mediante el IDE varias veces un programa, todo lo que se muestra en la pantalla va quedando allí, lo cual hace que se vea feo o confuso en varios casos. 

Para lograr limpiar la pantalla utilizaremos una librería de pascal. Esto no se corresponde con el cometido de este curso por lo que solo explicaré cómo limpiar la pantalla. El uso de librerías lo veremos más adelante cuando abordemos la programación en Modula 2; si no manejan bien todos los conceptos que hay aquí pues simplemente no tiene sentido seguir con cosas más complejas. 

¿Qué es una librería? Básicamente es una unidad de programa que consta de funciones y procedimientos (lo veremos más adelante) que alguien programó y puso a nuestra disposición para que podamos utilizarlos. Dicho de manera sencilla para que se entienda ahora, una librería consta de un código fuente ya compilado pero que no crea un archivo .exe, sino que queda en otro formato. La librería tiene un nombre y además, dentro de su código tiene "partes" que nosotros podemos llamar y utilizar para nuestros propósitos. Para usar una librería simplemente debemos saber su nombre y claro, qué partes de ella queremos usar. Existen librerías por defecto que ya vienen con el compilador, pero hay otras que pueden obtenerse por la web. 

Existe una librería incluida en Free Pascal llamada CRT. Esta librería nos provee de funciones para el control de la pantalla y el teclado. De todas ellas solo nos interesa una, ClrScr, lo cual es una abreviación de Clear Screen, que significa Limpiar Pantalla. 

Para indicar las librerías que vamos a usar debemos escribir la palabra reservada USES luego de la declaración del identificador de nuestro programa. Luego de USES escribimos los nombres de nuestras librerías y ya, podemos comenzar llamar a sus funciones y procedimientos sin problema. Veamos un simple ejemplo de la limpieza de la pantalla: 

Matriz unidimensional

Matriz bidimensional

Matriz tridimensional

Vector multidimensional

En programación, un vector multidimensional es un vector que se indexa mediante una lista

ordenada de enteros. El número de enteros que se utiliza en esta lista para indexar el vector

multidimensional es siempre el mismo y se conoce como la dimensionalidad del vector. Por

otra parte, los límites de cada uno de los enteros que forman parte del indice, determinan

la dimensión del vector. A un vector con dimensionalidad k se le suele llamar k-dimensional.

Los vectores 1-dimensional se corresponden con los vectores ordinarios en los que los

elementos están dispuestos en una única fila (o columna); los vectores 2-dimensional son otra

forma de llamar a las clásicas matrices en las que sus elementos están dispuestos en varias

filas y columnas (dos dimensiones). En la práctica, la dimensionalidad de un vector raras veces

excede de tres.

[editar]Representación en memoria

La forma de disponer los elementos de un vector 1-dimensional en la memoria de

un ordenador es trivial, ya que ésta, en sí misma, tiene la forma de un vector 1-dimensional

(muy grande). Cuando se quiere almacenar vectores n-dimensionales, sin embargo, el

problema ya no es evidente. Supongamos que queremos representar esta simple matriz de dos

dimensiones:

La forma más común de indexar esta matriz (o vector 2-dimensional) es utilizando la

convención RC (del inglés Row-Column, fila-columna), en la que los elementos se

referencian indicando primero la fila y luego la columna (ejemplo,  ), de esta forma

se tiene que:

La indexación de vectores multidimensionales se puede hacer de alguna de estas

maneras:

Orden fila-principal: Los elementos de cada fila son almacenados en orden,

primero una fila, luego otra, y así sucesivamente. Este método se utiliza sobre

todo en los arrays estáticos declarados en C.

1 2 3 4 5 6 7 8 9

Orden columna-principal: Análogo al anterior pero esta vez almacenando los

elementos por columnas en vez de por filas:

1 4 7 2 5 8 3 6 9

Vector 2-dimensional almacenado en un vector 1-dimensional de vectores 1-

dimensionales.

Vector de X dimensiones: Típicamente, los vectores multidimensionales se

representan utilizando un vector 1-dimensional que contiene referencias (o

punteros) a otros vectores 1-dimensionales. Estos subvectores pueden ser,

indistintamente, las filas o las columnas de la matriz, todo depende del criterio o la

interpretación que se quiera tomar.

Las dos primeras formas son más compactas y tienen potencialmente mejor

localización de referencia, pero también son más limitadas; los vectores deben

ser rectangulares, en el sentido de que ninguna fila puede contener más elementos

otra. Los vectores de vectores, por otro lado, permiten la creación de vectores

desiguales, también llamados vectores dentados, en la que el rango válido de un

índice depende del valor de otro, o dicho con otras palabras, que las diferentes filas (o

columnas) pueden ser de diferentes tamaños. Los vectores de vectores también son

de utilidad en los lenguajes de programación que sólo permiten vectores 1-

dimensionales como primitivas.

En muchas aplicaciones, como aplicaciones numéricas que trabajan con matrices, hay

que iterar sobre vectores rectangulares 2-dimensionales de forma predecible. Por

ejemplo, calcular un elemento de la matriz producto A x Bimplica iterar sobre una fila

de A y una columna de B simultáneamente. Al indexar los elementos de la matriz

según se encuentre esta almacenada en memoria, se deben optimizar las operaciones

de localización de cada elemento tanto como se pueda. A veces, un compilador puede

determinar automáticamente el diseño de la serie secuencial de elementos de un

vector para que se almacenen también secuencialmente en memoria, en nuestro

ejemplo, podría elegir el orden de fila-principal para A, y el orden columna-

principal para B. Existen más formas de almacenar los elementos de una matriz en

memoria, que serán más eficientes para otro tipo de problemas, por ejemplo si se

quiere iterar sobre la diagonal principal de una matriz.

ARREGLOS MULTIDIMENSIONALES

En ocasiones es útil tener arreglos de más de un índice. Esto se puede hacer en

C++ y en la mayoría de los lenguajes de programación. La siguiente sentencia

declara un arreglo multidimensional de variables de punto flotante que llevan el

nombre genérico de Temperatura:

double Temperatura[3][20];

Los índices de este arreglo son:

Temperatura[0][0] Temperatura[1][0] Temperatura[2][0]

Temperatura[0][1] Temperatura[1][1] Temperatura[2][1]

M M M

Temperatura[0][19] Temperatura[1][19] Temperatura[2][19]

Observe que con la declaración anterior se declaran simultáneamente 60

variables indexadas. Note también que los valores que indican el tamaño del

arreglo multidimensional deben encerrarse entre corchetes (para cada conjunto

de valores).

De hecho, los arreglos multidimensionales pueden contener cualquier número

de índices, pero rara vez son necesarios más de dos para la mayoría de las

aplicaciones en ingeniería química. La sintaxis formal para declarar un arreglo

multidimensional es:

nombre_tipo nombre_arreglo [tamanio_1] [tamanio_2] ... [ultimo_tamanio]; Programación Instituto Tecnológico de Celaya

Ingeniería Química

INICIALIZACIÓN DE ARREGLOS MULTIDIMENSIONALES

La inicialización de arreglos multidimensionales es muy similar a la que se

describió para arreglos de un solo índice. Otra vez es necesaria La inicialización de arreglos multidimensionales es muy similar a la que se

describió para arreglos de un solo índice. Otra vez es necesario enlistar los

valores de cada uno de los elementos del arreglo entre llaves y separados

por comas. La diferencia sin embargo, es que es necesario tener más de un

grupo de valores encerrados entre llaves. Por ejemplo:

int x[2][3]={{1,2,3},{4,5,6}};

Observe que tenemos un conjunto de llaves que encierra a otros grupos de

números también encerrados entre llaves y separados por comas. ¿Cuántos

grupos de números se tienen encerrados por las llaves de los extremos?

2, porque la dimensión del primer índice es 2. ¿Cuántos números se tienen en

cada uno de los grupos? 3, por el tamaño correspondiente al segundo índice es

3.

El ejemplo equivaldría a tener el siguiente arreglo de números. El primer índice

representaría al renglón y el segundo índice a la columna:

1 2 3

x[0][0] x[0][1] x[0][2]

4 5 6

x[1][0] x[1][1] x[1][2]

Un arreglo es un conjunto de datos o una estructura de datos homogéneos que se encuentran ubicados en forma

consecutiva en la memoria RAM (sirve para almacenar datos en forma temporal).

Contenido

 [ocultar]

1   Definición

2   Tipos de arreglos

o 2.1   Arreglos unidimensionales

o 2.2   Arreglos multidimensionales

o 2.3   Arreglos con múltiple subíndices

3   Operaciones con arreglos

4   Ordenaciones en Arreglos

o 4.1   Selección directa

o 4.2   Ordenación por burbuja

o 4.3   Ordenación por mezcla

5   Algoritmos de búsqueda que existen

6   Fuente

Definición

Un arreglo puede definirse como un grupo o una colección finita, homogénea y ordenada de elementos. Los arreglos

pueden ser de los siguientes tipos:

De una dimensión.

De dos dimensiones.

De tres o más dimensiones.

Tipos de arreglos

Arreglos unidimensionales.

Arreglos multidimensionales.

Arreglo con múltiple subíndices.

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.

Arreglos 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.

Arreglos con múltiple subíndices

Es la representación de tablas de valores, consistiendo de información arreglada en renglones y columnas. Para

identificar un elemento particular de la tabla, deberemos de especificar dos subíndices; el primero identifica el renglón

del elemento y el segundo identifica la columna del elemento. A los arreglos que requieren dos subíndices para

identificar un elemento en particular se conocen como arreglo de doble subíndice. Note que los arreglos de múltiples

subíndices pueden tener más de dos subíndices. El estándar ANSI indica que un sistema ANSI C debe soportar por lo

menos 12 subíndices de arreglo.

Operaciones con arreglos

Las operaciones en arreglos pueden clasificarse de la siguiente forma:

Lectura: este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno de sus componentes

Escritura: Consiste en asignarle un valor a cada elemento del arreglo.

Asignación: No es posible asignar directamente un valor a todo el arreglo

Actualización: Dentro de esta operación se encuentran las operaciones de eliminar, insertar y modificar datos.

Para realizar este tipo de operaciones se debe tomar en cuenta si el arreglo está o no ordenado.

Ordenación.

Búsqueda.

Insertar.

Borrar.

Modificar.

Ordenaciones en Arreglos

La importancia de mantener nuestros arreglos ordenados radica en que es mucho más rápido tener acceso a un dato

en un arreglo ordenado que en uno desordenado.

Existen muchos algoritmos para la ordenación de elementos en arreglos, algunos de ellos son:

Selección directa

Este método consiste en seleccionar el elemento más pequeño de nuestra lista para colocarlo al inicio y así excluirlo de

la lista. Para ahorrar espacio, siempre que vayamos a colocar un elemento en su posición correcta lo intercambiaremos

por aquel que la esté ocupando en ese momento.

Ordenación por burbuja

Es el método de ordenación más utilizado por su fácil comprensión y programación, pero es importante señalar que es

el más ineficiente de todos los métodos. Este método consiste en llevar los elementos menores a la izquierda del

arreglo ó los mayores a la derecha del mismo. La idea básica del algoritmo es comparar pares de elementos

adyacentes e intercambiarlos entre sí hasta que todos se encuentren ordenados.

Ordenación por mezcla

Este algoritmo consiste en partir el arreglo por la mitad, ordenar la mitad izquierda, ordenar la mitad derecha y mezclar

las dos mitades ordenadas en un array ordenado. Este último paso consiste en ir comparando pares sucesivos de

elementos (uno de cada mitad) y poniendo el valor más pequeño en el siguiente hueco.

Algoritmos de búsqueda que existen

Búsquedas en Arreglos: Una búsqueda es el proceso mediante el cual podemos localizar un elemento con un

valor especifico dentro de un conjunto de datos. Terminamos con éxito la búsqueda cuando el elemento es

encontrado.

Búsqueda secuencial: A este método también se le conoce como búsqueda lineal y consiste en empezar al

inicio del conjunto de elementos , e ir a través de ellos hasta encontrar el elemento indicado ó hasta llegar al final

de arreglo. Este es el método de búsqueda más lento, pero si nuestro arreglo se encuentra completamente

desordenado es el único que nos podrá ayudar a encontrar el dato que buscamos.

Búsqueda binaria: Las condiciones que debe cumplir el arreglo para poder usar búsqueda binaria son que el

arreglo este ordenado y que se conozca el numero de elementos. Este método consiste en lo siguiente: comparar

el elemento buscado con el elemento situado en la mitad del arreglo, si tenemos suerte y los dos valores

coinciden, en ese momento la búsqueda termina. Pero como existe un alto porcentaje de que esto no ocurra,

repetiremos los pasos anteriores en la mitad inferior del arreglo si el elemento que buscamos resulto menor que el

de la mitad del arreglo, o en la mitad superior si el elemento buscado fue mayor. La búsqueda termina cuando

encontramos el elemento o cuando el tamaño del arreglo a examinar sea cero.

Búsqueda por hash: La idea principal de este método consiste en aplicar una función que traduce el valor del

elemento buscado en un rango de direcciones relativas. Una desventaja importante de este método es que puede

ocasionar colisiones.

----------------------------------------------------------------------------------------------------------------------

APUNTES DE CÁTEDRA: ARREGLOS MULTIDIMENSIONALESExtenderemos el uso de arreglos para facilitar la organización conveniente de datos relacionados entre sí en tablas y en listas de más de una dimensión. Por ejemplo, veremos cómo se puede utilizar un arreglo bidimensional de tres renglones y tres columnas para representar un juego de TA-TE-TI.

Este arreglo tiene nueve elementos, cada uno de los cuales puede llamarse especificando el subíndice del renglón (1,2 ó 3) y el subíndice de la columna (1,2 ó 3).TIPO DE ARREGLO (Multidimensional)

ARRAY [subíndice 1 OF ARRAY [subíndice 2 OF... ARRAY[subíndice n OF tipo-elemento

o ARRAY [subíndice1, subíndice2, … , subíndicen OF tipo-elementoSubíndice i representa el tipo de subíndice de dimensión i de un arreglo multidimesional. Se puede especificar cualquier tipo escalar finito o subintervalo. El tipo-elemento puede ser cualquier tipo de datos estándar o previamente definido.EJEMPLO: Las declaraciones varTATETI: array [1..3,1..3 of char;TABLA: array [1..7, 1..5, 1..6 of real;definen el arreglo TATETI como un arreglo dimensional de 9 elementos. Ambos subíndices pueden tomar los valores 1.2 ó 3. El arreglo TABLA consiste en tres dimensiones: el primer subíndice puede tomar los valores de 1 a 7; el segundo, de 1 a 5; y el tercero, de 1 a 6. Hay un total de 7x5x6, o sea 210 elementos en el arreglo TABLA.MANEJO DE ELEMENTOS INDIVIDUALES DEL ARREGLOnombre-arreglo [s1, s2,..., sn Cada una de las si es una expresión con subíndice que corresponde al tipo de subíndice de dimensión i. El valor de cada expresión determina qué elemento de nombre-arreglo se está manejando.EJEMPLOS: 1) TATETI [2, 3 selecciona el elemento del renglón 2, columna 3 del arreglo TATETI (estamos pensando en MATRICES).2) Una universidad ofrece 50 cursos en cada uno de sus 5 planteles. Podemos almacenar las inscripciones a estos cursos en el arreglo INSCRIPCIÓN:TYPEPLANTEL= (Norte, Sur, Centro, Oriente, Poniente);VARINSCRIPCION: array [1..50, PLANTEL of integer;------------------------------------------------------------------------------------------------

Arreglos Unidimensionales y Multidimensionales

Un arreglo unidimensional 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.

El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos

acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o

posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su

posición relativa.

Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe

proporcionar la dirección base del arreglo, la cota superior y la inferior.

REPRESENTACION EN MEMORIA

Los arreglos se representan en memoria de la forma siguiente:

Los arreglos multidimensionales tienen más de una dimensión. En C#, las dimensiones se

manejan por medio de un par de corchetes, dentro de los que se escriben los valores de cada

dimensión, separados por comas.

O P E R A C I O N E S .

Para manejar un arreglo, las operaciones a efectuarse son:

Declaración del arreglo,

Creación del arreglo,

Inicialización de de los elementos del arreglo, y

Acceso a los elementos del arreglo.

A continuación describiremos cada una de estas operaciones, en C#.

D E C L A R A C I Ó N .

La sintaxis para declarar un arreglo multidimensional es la siguiente:

<tipo> [ , ...] < identificador > ;

Donde:

tipo indica el tipo correspondiente a los elementos del arreglo ,

identificador es el nombre del arreglo, y

el par de corchetes, la coma y las diéresis, [ , ...], representan las dimensiones del arreglo.

Los corchetes encierran todas las comas necesarias para separar las dimensiones del arreglo.

Ejemplos:

double [ , ] bidim; // Dos dimensiones.

int [ , , ] tridim ; // Tres dimensiones.

char [ , , , ] enciclopedia; // Cuatro dimensiones.

Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que,

durante dicha operación, no se reserva espacio en la memoria.

C R E A C I Ó N .

La creación de un arreglo multidimensional consiste en reservar espacio en la memoria para

todos sus elementos, utilizando la siguiente sintaxis:

< identificador > = new <tipo> [ dim1, dim2 ... dimN ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de ejecución,

dim1 , dim2 , dimN son valores enteros que representan las dimensiones del arreglo.

El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y

representa el número de elementos del arreglo.

Ejemplos:

bidim = new double [2, 3] ;

tridim = new int[ 2, 3, 4] ;

enciclopedia = new char[30, 80, 500, 10] ;

Las operaciones de declaración y creación anteriores se pueden agrupar en una sola

instrucción, como se muestra enseguida:

double [ , ] bidim = new double [2,3] ;

int [ , , ] tridim = new int[2, 3, 4] ;

char [ , , , ] enciclopedia = new char[ 30, 80, 500, 10 ] ;

I N I C I A L I Z A C I Ó N .

Un arreglo es un objeto que,cuando es creado por el compilador, se le asignan

automáticamente valores iniciales predeterminados a cada uno de sus elementos, de

acuerdo a los siguientes criterios:

Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.

Si el tipo del arreglo es char, a sus elementos se les asigna el valor '\u0000'.

Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.

Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.

Cuando se requiere asignar valores iniciales diferentes de los predeterminados, es posible

agrupar las operaciones de declaración, creación e inicialización en una sola instrucción, por

ejemplo:

int [ , , ] tridim={{{12, 59, 70, 45} , {20, 16, 29, 48} , {93, 75, 43, 10}},

{{44, 72, 30, 24} , {60, 89, 39, 61} , {99, 52, 34, 47}}};

A C C E S O .

Se puede acceder a los valores de los elementos de un arreglo bidimensional a través del

nombre del arreglo y dos subíndices. Los subíndices deben escribirse entre corchetes y

representa la posición del elemento en el arreglo. Así, podemos referirnos a un elemento del

arreglo escribiendo el nombre del arreglo y los subíndices del elemento entre corchetes. Los

valores de los subíndices empiezan en cero para el primer elemento, hasta el tamaño del

arreglo menos uno.

A P L I C A C I O N E S .

Se necesita manejar, en un arreglo, la posición todos los caracteres escritos en una

enciclopedia. El arreglo deberá tener las siguientes dimensiones:

Una para manejar el renglón en la página,

otra para la columna en la página,

otra para la hoja en el volumen y

otra para el volumen en la enciclopedia.

Cada página tiene 30 renglones y 80 columnas.

Cada volumen tiene 500 páginas.

La enciclopedia tiene 18 volúmenes.

El siguiente fragmento de programa implementa la solución a este problema.

char car;

// Declara y crea el arreglo.

char[ , , , ] enciclopedia = new char [18,500,30,80] ;

// Lee, desde el teclado, cada carácter para la enciclopedia.

for(int v = 0 ; v < class="Estilo32">// Volumen

for(int p = 0 ; p < class="Estilo32">// Página

for(int r = 0 ; r < class="Estilo32">// Renglón

for(int c = 0 ; c < class="Estilo32">// Columna

{

car = (char)Console.Read( ) ;

enciclope ARRAYS MULTIDIMENSIONALES:Un array multidimensional es un array de 3 ó más dimensiones. Si tenemos un array de N dimensiones, cada dimensión de tamaño d1,d2,..,dN, el número de elementos del array será:d1*d2*..*dN, y para acceder a un elemento concreto del array utilizaremos N índices, cada uno de los cuales referenciará a una posición dentro de una dimensión, siempre según el orden de declaración. En memoria, el array se sigue almacenando en posiciones consecutivas.La declaración de un array multidimensional seríaNom_array: array [LI1..LS1,LI2..LS2,LI3..LS3,LIN..LSN] de tipoNom_array [I1,I2,I3,IN]LI1<= I1<= LS2LIN<= I2<= LSN

dia[v,p,r,c] = car ;

}