Arreglos

ARREGLOS UNIDIMENSIONALES
Un arreglo unidimensional es la estructura natural para modelar listas de
elementos iguales. Están formados por una colección finita y ordenada de datos
del mismo tipo.  Los datos que se guarden en los arreglos todos deben ser del
mismo tipo.

Se caracteriza por ser un 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.

Los arreglos nos permiten hacer un conjunto de operaciones para manipular los
datos guardados en ellos, estas operaciones son: ordenar, buscar, insertar,
eliminar, modificar entre otras.

Para recordar:
* Un arreglo se usa para almacenar elementos del mismo
tipo.
* Un arreglo es de tamaño fijo.
* Cada elemento se guarda en un espacio independiente.
* Cada espacio se referencia con un índice (0,1,2,3,…,n).

La declaración de un arreglo se hace de la siguiente forma:

TipoDeDato nombre[] = new TipoDeDato [n];

Donde n es la capacidad (tamaño) del arreglo.
Ejemplos:

String nombres[ ] = new String [4];

double notas[ ] = new double [5];
int edadEstudiantes[ ] = new int [3];

String nombres[] = new String [4];

Define un arreglo llamado nombres, que almacena cadenas de texto y puede
contener máximo 4 elementos (con índices 0, 1, 2 y 3).
double notas[] = new double [5];
Define un arreglo llamado notas, que almacena números reales y puede tener
máximo 5 elementos (con índices 0, 1, 2, 3 y 4).
int edadEstudiantes[] = new int [3];
Define un arreglo llamado edadEstudiantes, que almacena
números enteros y puede tener máximo 3 elementos (con
índices 0, 1 y 2).
TipoDeDato nombre[] = new TipoDeDato [n];
Los arreglos definidos de esta forma no están inicializados, es decir, no contienen
ningún valor, lo cual se representa con null si es String o con 0 si es int o double.

ARREGLOS MULTIDIMENSIONALES
 

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.

Operaciones.

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
 Acceso a los elementos del arreglo.
A continuación describiremos cada una de estas operaciones, en C#.

Declaració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.

Creació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 ] ;

Inicializació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}}};
Acceso.

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.

Registros
Registro (estructura de datos)
Un registro, en programación, es un tipo de dato estructurado formado por la
unión de varios elementos bajo una misma estructura. Estos elementos pueden
ser, o bien datos elementales (entero, real, carácter,...), o bien otras estructuras de
datos. A cada uno de esos elementos se le llama campo.
Un registro se diferencia de un vector en que este es una colección de
datos iguales, es decir, todos del mismo tipo, mientras que en una estructura los
elementos que la componen, aunque podrían serlo, no tiene por qué ser del
mismo tipo.

Ejemplo: Creación de un registro (o estructura) en C [editar]

Un ejemplo de como se declararía un registro en C podría ser:

typedef struct TipoNodo

{
int dato;
struct TipoNodo *sig;
struct TipoNodo *ant;
} TNodo;

En este ejemplo se define el tipo de dato TNodo (o struct TipoNodo, sería equivalente) como

una estructura (registro) que contiene un dato de tipo entero y
dos punteros sig y ant (siguiente y anterior) que sirven para referenciar a otros registros del
tipo TNodo. Ésta es la estructura de datos que se suele utilizar como nodo en
las listas doblemente enlazadas.

Combinaciones entre arreglos y registros

Qué son los arreglos y registros
Antes de hablar sobre las combinaciones entre arreglos y registros, es
importante entender qué son y cómo funcionan por separado.

Un arreglo es una estructura de datos lineal que permite almacenar una

colección de elementos del mismo tipo en una posición de memoria
continua. Esto significa que una vez que se define el tamaño del arreglo, no
se puede cambiar. Los elementos del arreglo son accesibles mediante un
índice que indica su posición en el arreglo.

Por otro lado, un registro es una estructura de datos que permite almacenar
diferentes tipos de datos relacionados en una sola entidad. Los registros
están conformados por campos, cada uno de los cuales tiene un nombre y
un tipo de dato. Los campos son accesibles mediante su nombre.

Combinaciones entre arreglos y

registros
Como mencionamos anteriormente, las combinaciones entre arreglos y
registros pueden ser realmente útiles. Una de las formas en que se pueden
combinar es mediante el uso de arreglos de registros.

Un arreglo de registros es una estructura de datos que permite almacenar

una colección de registros del mismo tipo en una posición de memoria
continua. Cada registro tiene campos que describen diferentes aspectos de
un objeto. Por ejemplo, si estamos trabajando con una aplicación de gestión
de clientes, el registro podría tener campos como nombre, apellido,
dirección y número de teléfono.
En lugar de crear un arreglo para cada uno de los campos como nombre, un
arreglo para apellido y así sucesivamente, podemos definir un registro que
contenga todos estos campos y luego crear un arreglo de este registro para
almacenar múltiples clientes.

Otra combinación entre arreglos y registros es mediante el uso de arreglos

de punteros a registros. Un puntero a registro es una variable que contiene
la dirección de memoria de un registro. Esto significa que en lugar de copiar
todo el registro cada vez que se necesita, solo se copia la dirección de
memoria. Esto puede ser muy eficiente en términos de memoria y
rendimiento.

Ejemplo práctico
Supongamos que estamos creando una aplicación que requiere almacenar
información sobre distintas tarjetas de crédito. Podríamos crear un arreglo
de registros que tenga los siguientes campos: número de tarjeta, fecha de
vencimiento y nombre del titular. Luego, podríamos hacer uso de un arreglo
de punteros a registros para almacenar las direcciones de memoria de cada
registro de tarjeta de crédito.

Fecha de
Número de tarjeta Nombre del titular
vencimiento

1234 5678 9101 1121 12/23 John Doe

9876 5432 1098 7654 06/25 Jane Smith

aplicaciones de rutinas en seudocódigo

Aplicaciones del pseudocódigo
Después de haber revisado estas definiciones, puede que ciertamente
sea mucho más sencillo abordar una revisión sobre las distintas
aplicaciones que tiene el Pseudocódigo. A continuación, algunas de
ellas:

 Una de las primeras aplicaciones, o al menos una de las más

generales, es la de utilizar el Pseudocódigo dentro de los
libros de texto especializados en Ciencias, Computación o
informática. En estos textos, el Pseudocódigo es empleado
con el fin de explicar algoritmos de la forma más específica
posible, tanto para los programadores como para aquellos
usuarios en general.

 Por otro lado, el Pseudocódigo es empleado también por

aquellas personas que se están iniciando en la carrera de
programación, y que lo emplean como un lenguaje
intermedio, para lograr colocar un número de instrucciones
en un lenguaje preciso, para no cometer errores, y luego
poder traducirlo a un lenguaje de programación, para poder
introducirlo en el programa general, a que interactúe con los
otros comandos.