Unidimensional y bidimensional de una matriz en C ++

INTRODUCCION

El siguiente trabajo se realizó con la finalidad de analizar e interpretar lo que es un arreglo unidimensional y bidimensional en c++. Ya que es de suma importancia para un buen diseño de programación y estética.

Los diferentes tipos de arreglos también nos pueden ayudar para mejorar la organización de la información y así tener una buena relación con la información tratada.

Contenido

ARREGLOS UNIDIMENSIONALES 3

ARREGLOS BIDIMENSIONALES 5

ARREGLOS MULTIDIMENSIONALES 6

OPERACIONES CON ARREGLOS 7

ORDENACIONES EN ARREGLOS 9

BÚSQUEDAS EN ARREGLOS 11

REFERENCIAS BIBLIOGRAFICAS 13

ARREGLOS UNIDIMENSIONALES

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.

Representación En Memoria

Los arreglos se representan en memoria de la forma siguiente:

x : array[1..5] of integer

Para establecer el rango del arreglo (número total de elementos) que componen el arreglo se utiliza la siguiente formula:

RANGO = Ls - (Li+1)

Donde:

ls = Límite superior del arreglo

li = Límite inferior del arreglo

Para calcular la dirección de memoria de un elemento dentro de un arreglo se usa la siguiente formula:

A[i] = base(A) + [(i-li) * w]

Donde:

A = Identificador único del arreglo

i = Indice del elemento

li = Límite inferior

w = Número de bytes tipo componente

Si el arreglo en el cual estamos trabajando tiene un índice numerativo utilizaremos las siguientes fórmulas:

RANGO = ord (ls) - (ord (li)+1)

A[i] = base (A) + [ord (i) - ord (li) * w]

ARREGLOS BIDIMENSIONALES

Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado, finito ordenado y homogéneo. El acceso a ellos también es en forma directa por medio de un par de índices.

Los arreglos bidimensionales se usan para representar datos que pueden verse como una tabla con filas y columnas. La primera dimensión del arreglo representa las columnas, cada elemento contiene un valor y cada dimensión representa una relación

La representación en memoria se realiza de dos formas: almacenamiento por columnas o por renglones.

Para determinar el número total de elementos en un arreglo bidimensional usaremos las siguientes fórmulas:

RANGO DE RENGLONES (R1) = Ls1 - (Li1+1)

RANGO DE COLUMNAS (R2) = Ls2 - (Li2+1)

No. TOTAL DE COMPONENTES = R1 * R2

Representación En Memoria Por Columnas

x : array [1..5,1..7] of integer

Para calcular la dirección de memoria de un elemento se usan la siguiente formula:

A[i,j] = base (A) + [((j - li2) R1 + (i + li1))*w]

Representación En Memoria Por Renglones

x : array [1..5,1..7] of integer

Para calcular la dirección de memoria de un elemento se usan la siguiente formula:

A[i,j] = base (A) + [((i - li1) R2 + (j + li2))*w]

Donde:

i = Indice del renglón a calcular

j = Indice de la columna a calcular

li1 = Límite inferior de renglones

li2 = Límite inferior de columnas

w = Número de bytes tipo componente

ARREGLOS MULTIDIMENSIONALES

Este también es un tipo de dato estructurado, que está compuesto por n dimensiones. Para hacer referencia a cada componente del arreglo es necesario utilizar n índices, uno para cada dimensión

Para determinar el número de elementos en este tipo de arreglos se usan las siguientes fórmulas:

RANGO (Ri) = lsi - (lii + 1)

No. TOTAL DE ELEMENTOS = R1 * R2* R3 *...* Rn

Donde:

i = 1... n

n = No. total de dimensiones

Para determinar la dirección de memoria se usa la siguiente formula:

LOC A[i1,i2,i3,...,in] = base(A) + [(i1-li1)*R3*R4*Rn + (i2-li2)*R3*R2*...

...