Arreglos

Los arreglos son las estructuras de datos más sencillas.

Definición: Los arreglos son un grupo de posiciones en memoria relacionadas entre sí por el hecho de que todas tienen el mismo nombre y los datos que contiene son todos del mismo tipo.

Son entidades estáticas ya que conservan el mismo tamaño durante toda la ejecución del programa.

Para poder referirnos a una posición en particular o al datos dentro de esa posición del arreglo, se especifica el nombre del arreg lo y el número de posición del elemento. Las posiciones generalmente se cuentan a partir del cero como primera posición.

Declaración de un arreglo:

Se le da un nombre y se de fine su tamaño y el tipo de datos que va a contener (caracteres, enteros, reales, etc.)

En C:

int arreglo[10]; /* un arreglo de 10 enteros */

float arreglo[10]; /* un arreglo de 1 0 reales */

char arreglo[10]; /* un arreglo de 10 caracteres */

 

 

Altas, Bajas y Cambios

Alta en un arreglo: Se verifica que haya espacio y se inserta el elemento en la posición disponible. Si el arreglo tiene un orden determinado hay que buscar la posición correcta primero, luego recorrer los elementos para generar un espacio y finalmente se inserta el dato.

Alta en un arreglo (secuencial)

/* dato es el elemento a dar de alta y pos indica la posición
disponible */

alta(int arr[], int dato, int *pos)
{
	if(*pos == MAX) /* Verifica si esta lleno */
		printf("Error: el arreglo esta lleno");
	else
	{
		arr[*pos] = dato; /* Inserta el dato */
		*pos++;  /* Incrementa la posición */
	}
}

Alta en un arreglo (ordenado)


/* dato es el elemento a dar de alta y cantidad indica el número de
datos existentes. Este procedimiento inserta un dato en un arreglo de enteros 
en orden ascendente */

alta_ordenada(int arr[], int dato, int *cantidad)
{
	int i, pos;

	if(*cantidad == MAX) /* Verifica si esta lleno */  
		printf("Error: el arreglo esta lleno");
	else
	{
		if(*cantidad == 0) /* El arreglo esta vacío */
		{
			arr[0] = dato; /* Inserta el dato */
			*cantidad++; /* Incrementa la cantidad */
		}
		else
		{
			pos = 0;
			for(i=0; i<MAX; i++) /* Busca la posición */
				if(dato >= arr[i]) 
					pos = ++;
			if(pos == *cantidad) /* Es el último */
				arr[pos] = dato; /* Inserta el dato */
			else
			{ /* Recorre los datos para hacer espacio para el nuevo*/
				for(i=cantidad; i>=pos; i--)
					arr[i] = arr[i-1];
				arr[pos] = dato; /* Inserta el dato */
				*cantidad++;/* Incrementa cantidad */
			}
		}
	}
}

Baja en un arreglo

Para eliminar un elemento de un arreglo primero se verifica que no esté vacío el arreglo, luego se busca el dato, se elimina y, de ser necesario, se recorren los demás para cubrir el espacio que quedó.

baja(int arr[], int dato, int *cantidad)
{
	int i, pos;
	if(*cantidad == 0) /* Verifica si hay datos */
		printf("Error: el arreglo esta vacío");
	else
	{
		pos = -1; /* Recorre el arreglo buscando dato */
		for(i=0; i<cant;i++)
			if(arr[i] == dato) /* Si lo encontró */
				pos = i;
		if(pos == -1) /* No lo encontró */
			printf("Error: No se encontró el dato %d", dato);
		else
		{ /* Recorre los datos eliminando el que se encontraba en pos*/
			for(i=pos; i<*cantidad-1; i++)
				arr[i] = arr[i+1];
			*cantidad--; /* Decrementa cantidad */
		}
	}
}

Cambio

Para modificar un elemento de un arreglo primero se verifica que no esté vacío el arreglo, luego se busca el dato, y se modifica.


cambio(int arr[], int dato, int cantidad, int nuevo)
{
	int i, pos;

	if(cantidad == 0) /* Verifica si hay datos */
		printf("Error: el arreglo esta vacío");
	else
	{
		pos = -1;
		for(i=0; i<MAX;i++) /* Recorre el arreglo buscando dato */
		if(arr[i] == dato) /* Si lo encontró */
			pos = i;
		if(pos == -1) /* No lo encontró */
			printf("Error: No se encontró el dato %d", dato);
		else
			arr[pos] = nuevo;
	}
}