Arreglos

Algoritmos y Estructura de Datos I Ing. Rolf Pinto López

Algoritmos
y
Estructura de Datos I

1


ESTRUCTURAS DE DATOS .............................................................................. 3
ESTRUCTURAS LINEALES - ARRAYS .............................................................. 4
Arreglos Unidimensionales - VECTORES ...................................................... 6
REPRESENTACIÓN EN MEMORIA ............................................................. 6
DECLARACIÓN DE ARRAYS ..................................................................... 7
Inicialización de ARRAYS ........................................................................ 7
Operaciones sobre las Estructuras Lineales (Arrays) .................................. 8
Operaciones de I/O ............................................................................... 8
Operaciones de Acceso .......................................................................... 8
Operaciones de Actualización .................................................................. 8
Otras OPERACIONES.............................................................................. 9
INSERCIÓN Y BORRADO ................................................................................ 12
INSERCIÓN ............................................................................................... 12
BORRADO ................................................................................................. 12
CLASIFICACIÓN ........................................................................................... 13
Selección Directa ....................................................................................... 13
Ordenación por Burbuja ..............................................................................15
Selección INSERCIÓN O BARAJA .................................................................. 15
Ordenación QUICKSORT ............................................................................. 16
Ejercicios de aplicación ............................................................................... 18

2


ESTRUCTURAS DE DATOS
Es una colección de datos cuya organización se define por las funciones
“algoritmos” que se usan para almacenar y acceder elementos individuales de datos
en ella; las estructuras de datos son también un modelo matemático o lógico de
una organización particular de datos. Los tipos de datos más frecuentes utilizados
en los diferentes lenguajes de programación son:

SIMPLES:

Ocupan sólo una posición de memoria.
Cada uno representa un único elemento.

ESTRUCTURADOS:

Ocupan un conjunto de posiciones en memoria.
Un solo identificador o nombre puede representar múltiples datos.

Generalmente para dar solución a un problema, se debe tratar con conjuntos de
datos y no con datos simples que por sí mismos no dicen mucho, por ello es
inevitable tratar con estructuras de datos adecuadas a cada requerimiento, la
elección del tipo de estructura de datos adecuada a cada aplicación dependerá del
tipo de aplicación y en segundo lugar del lenguaje que posteriormente se use para
implementar la solución.

Una estructura de datos tiene las siguientes características:

Pueden descomponerse en los elementos que la constituyen.
La manera en que se colocan los elementos dentro de la estructura afectará la
forma en que se realicen los accesos individuales a cada elemento.
La colocación de los elementos y la manera en que se accede a ellos puede ser
encapsulada.

3


ENTERO
REAL
ESTÁNDAR
CARACTER
DATOS SIMPLES LÓGICO

SUBRANGO
DEFINIDOS POR EL USUARIO
ENUMERADO

ARRAY
REGISTRO
SIMPLES O ESTÁTICOS ARCHIVO
CONJUNTO
CADENA
DATOS
ESTRUCTURADOS PILA
LISTA LINEAL COLA
COMPUESTOS O LISTA ENLAZADA
DINÁMICOS
LISTA NO ÁRBOL
LINEAL GRAFO

DATOS ESTRUCTURADOS SIMPLES O ESTÁTICOS:

El tamaño ocupado en memoria es definido antes de la ejecución del
programa.
Este tamaño no puede ser rectificado.
Estas estructuras están implementadas en casi todos los lenguajes de
programación: array, registro, archivo.

DATOS ESTRUCTURADOS COMPUESTOS O DINÁMICOS:

No tienen limitaciones respecto a la memoria que usan.
Mediante el uso de punteros, se puedo armar estructuras de datos
dinámicas soportadas por la mayoría de lenguajes: listas enlazadas,
pilas, colas, árboles, grafos.

ESTRUCTURAS LINEALES - ARRAYS
Un arreglo es una estructura que permite almacenar un conjunto de datos de un
mismo tipo, en forma continua, los datos almacenados se indexan desde la
posición 0 hasta la N-1.

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:
Una dimensión.
Dos dimensiones.
Tres o más dimensiones (multidimensionales).

Un arreglo es un conjunto de celdas de memoria relacionadas entre si; ya que
todas tienen el mismo nombre y almacenan el mismo tipo de datos, para

4


referirse a un elemento dentro del arreglo se usa los corchetes [] donde se
coloca el número de posición del elemento dentro del arreglo.
Ej.: ALUMNOS [96]

El primer elemento se almacena en la posición 0 del arreglo, es decir el primer
elemento del arreglo se conoce como a[0], el segundo como a[1], el séptimo
como a[6] y en general el elemento de orden N del arreglo a se conoce como
a[N-1].

Ej.: Array unidimensional de 5 elementos, el tipo de dato de los elementos es
caracter

[0] [1] [2] [3] [4]
Mark Harrison Carrie Billi Dee David
Hamill Ford Fisher Prowse

El número de posición que aparecen dentro de los corchetes se conoce como
índice y debe ser un número entero o una expresión entera, Ej.:

printf("%i", a[0] + a[5] + a[10]);
x = a[7] / 2;
x = a[4] = 12;
x = a[m+1];

Para declarar un arreglo se utiliza la siguiente sintaxis:
tipo_de_dato nombre_del_arreglo [número de elementos];

Ej.:
int h[7];
float notas[7];
char empleados[17];

Ej.:
#include<stdio.h>
#include<conio.h>
const int MAX 10
void main()
{
int a[MAX], b[MAX], c[MAX], i, j = 0, k = 0;
clrscr();

printf("programa que almacena 10 números en un arreglo.");
printf("luego los separa en dos arreglos de acuerdo a su valor.n");

for(i=0; i < MAX; i++)
{
printf("Introduce el valor %i: ", i+1);
scanf("%i", &a[i]);
}
for(i=0; i < MAX; i++)
{
if (a[i] < MAX)

5


{
b[j] = a[i];
j++;
}
else
{
c[k] = a[i];
k++;
}
}
printf ("los números quedan así:nn");
for(i=0; i < j; i++)
printf("%in", b[i]);
for(i=0; i < k; i++)
printf("t%in", c[i]);
getch();
}

ARREGLOS UNIDIMENSIONALES - VECTORES
Un arreglo unidimensional es un tipo de dato estructurado que está formado de
una colección finita y ordenada de N datos homogéneos (llamado tipo base).
Es la estructura natural para organizar listas de elementos del mismo tipo.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, o sea, se
puede acceder a cualquier elemento del arreglo sin tener que consultar a
elementos anteriores o posteriores, esto mediante el uso del índice que apunta
a cada elemento del arreglo.
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:
VOCALES: ARRAY [1 … 5] OF CHAR

DIRECCIÓN ARRAY CONTENIDO
707 VOCALES[0] A
708 VOCALES[1] E
709 VOCALES[2] I
710 VOCALES[3] O
711 VOCALES[4] U

Para establecer el rango del arreglo (número total de elementos) que componen el
arreglo se utiliza la siguiente formula:
Longitud = (LS – LI) + 1
LS = índice de mayor valor o limite superior.
LI = índice de menor valor o limite inferior.
Los elementos del array los denotaremos como: A[0], A[1], ..., A[N-1]

6


DECLARACIÓN DE ARRAYS
Cada lenguaje de programación tiene sus reglas para declarar un ARRAY. Pero cada
declaración debe incluir 3 clases de información acerca del ARRAY:
El nombre del ARRAY.
El tipo de los datos del ARRAY.
El conjunto de índices del ARRAY.

PASCAL X[1…16] of integer
C++ int X[16];
VISUAL BASIC Dim X(16) As Integer

La reserva de espacio o memoria del ARRAY puede ser:
ESTÁTICA: la longitud del ARRAY no puede variarse durante la ejecución.
DINÁMICA: se permite leer un número entero N y después declarar el ARRAY
con N elementos

Ej.: Declaración de ARRAYS unidimensionales:
ALGORITMOS C++
real nota[25] double nota[25];
real talla[30] double talla [30];
entero codigo[30] int codigo[30];
real unidades_compradas[10] double unidades_compradas[10];
caracter letras[45] char letras[45];
caracter estado_civil[50] char estado_civil[50];
caracter nombre[5] char nombre[5];

INICIALIZACIÓN DE ARRAYS
Al igual que con las variables simples (no estructurados), los vectores se pueden
inicializar al momento de declararse. Ej.:

ALGORITMOS C++
real nota[5] {12.07,15,12,10,20} double nota[5]={12.07,15,12,10,20};

real talla[3] {1.56,1.78,1.45} double talla[3]={1.56,1.78,1.45};

entero codigo[2] {11,12} int codigo[2]={11,12};

caracter letras[5] {'a','b','c','z','a'} char letras[5]={'a','b','c','z','a'};

caracter estado_civil [3] {'s','c','d'} char estado_civil[3]={'s','c','d'};

7


OPERACIONES SOBRE LAS ESTRUCTURAS LINEALES (ARRAYS)
OPERACIONES DE I/O

Asignación: Otorgar valor a uno o varios elementos de un vector.

ALGORITMOS C++
Asigna 45 al
A[10] 45 A[10] = 45; elemento 10 del
array A.
Asigna Carrie Fisher
nombre[2] "Carrie Fisher" nombre[2] = "Carrie Fisher"; al elemento 2 del
array nombre.
Asigna E al
vocales[3] 'E' vocales[3] = 'E'; elemento 3 del
array vocales.
Asigna 1.56 al
talla[2] 1.56 talla[2] = 1.56; elemento 2 del
array talla.

R/W: Permite dar valores o mostrar los valores de un array.

ALGORITMOS C++
PARA(i 1 ; HASTA i<=n; i i + 1) for(i = 1; i<= n ; i++)
{ {
LEER v[i]; cin>>v[i];
} }
PARA (i 1; HASTA i<= n; i i + 1) for (i = 1; i<= n ; i++)
{ {
MOSTAR peso[i]; cout<<peso[i];
} }

OPERACIONES DE ACCESO
Recorrido: Procesamiento de todos y cada uno de los elementos de la lista,
también llamado acceso secuencial.
Búsqueda: Búsqueda de la posición ocupada por un elemento con un
determinado valor o del elemento con un determinado valor de índice.

OPERACIONES DE ACTUALIZACIÓN
Inserción: Adición de un elemento al array, La inserción al final del array es
sencilla si el espacio de memoria reservado para el ARRAY es mayor que el
utilizado. Pero si es en una posición N – X donde X ≠ 0 y 1, entonces desde N–X
se deberá desplazarse hacia abajo todos los elementos para poder colocar el
nuevo elemento y que los demás conserven el orden relativo entre ellos.
Borrado: Eliminar un elemento del array.

8


OTRAS OPERACIONES
Ordenación: Distribución de los elementos del array de acuerdo con algún
criterio de orden. Ej.: de mayor a menor, en orden alfabético, etc.
Mezcla / Apareo: Combinar dos listas en una sola.

Ej.: Recorrido del array lineal A con límite inferior LI y límite superior LS conocidos.
El algoritmo recorre el array realizando la operación PROCESO a cada uno de los
elementos del array.

1. Usando la estructura repetitiva MIENTRAS

ALGORITMO RECORRIDO
INICIO
ENTERO LI, LS, I
REAL A[20]
LI 0
LS 19
I LI
MIENTRAS I <= LS
{
PROCESO A[I]
I I+1
}
FIN

2. Usando la estructura repetitiva PARA

ALGORITMO RECORRIDO
INICIO
ENTERO LI, LS, I
REAL A [20]
LI 0
LS 19
PARA (I LI; HASTA I <= LS; I I + 1)
{
PROCESO A[I]
}
FIN

Donde PROCESO puede ser:

LEER cada elemento del array
MOSTRAR cada elemento del array
SUMAR todos los elementos del Array A, lo cual implica estas dos instrucciones
SUM_DATO 0
SUM_DATO SUM_DATO + A[i]

MULTIPLICAR todos los elementos del array A por un valor X
A[i] A[i] * X

CONTAR los elementos del array A, que presenten una determinada propiedad o
característica

9


CONT 0
CONT CONT + 1

HALLAR un elemento en particular, ORDENAR el arreglo, COMBINAR el arreglo, etc.

Ej.: Una compañía de autos utiliza un ARRAY AutosVen para almacenar el número
de vehículos vendidos desde 1979 hasta 2004.

DETERMINACIÓN DE LAS VARIABLES.
AUTOSVEN[K] = NÚMERO DE VEHÍCULOS VENDIDOS EN EL AÑO K
LS = 2004
LI = 1979
LONGITUD = (2004 – 1979) + 1 = 26

ALGORITMO AUTOS VENDIDOS
INICIO

ENTERO AUTOSVEN[26], I, MIN, MAX, CA, AV, POS

PARA (I 1, HASTA I<= 26, I I + 1)
{

LEER AUTOSVEN[I]

}

//MOSTRAR LOS DATOS DEL ARRAY AUTOSVEN Y EL AÑO RESPECTIVO EN QUE SE
//VENDIERON

PARA (I 1, HASTA <= 26, I I + 1)
{

MOSTRAR AUTOSVEN[I], I + 1978 //VISITA AL ELEMENTO

}

//CUANTOS VEHÍCULOS SE HAN VENDIDO DESDE 1979 HASTA 2004

AV 0
PARA (I 1, HASTA I <= 26, I I + 1)
{

AV AV + AUTOSVEN[I] //VISITA AL ELEMENTO

}

//CUANTOS AÑOS HAN TRANSCURRIDO DESDE 1979 HASTA 2004

CA 0
PARA (I 1, HASTA <= 26, I I + 1)
{

10


CA CA + 1

}

//EN QUE AÑOS SE VENDIERON MAS DE 1000 VEHÍCULOS Y CUANTOS SE
//VENDIERON EN CADA UNO DE ESOS AÑOS

PARA (I 1, HASTA <= 26, I I + 1)
{
SI (AUTOSVEN [I] > 1000)
{

MOSTRAR I + 1978, AUTOSVEN[I]

}
}

//EN QUE AÑO SE VENDIERON MENOS VEHÍCULOS Y CUANTOS FUERON

MIN AUTOSVEN[1]
PARA (I 1, HASTA <= 26, I I + 1)
{
SI (AUTOSVEN[I] < MEN)
{

MEN AUTOSVEN[I]
POS I

}
}

MOSTRAR MEN
MOSTRAR POS + 1978

//EN QUE AÑO SE VENDIERON MAS VEHÍCULOS Y CUANTOS FUERON

MAX AUTOSVEN[1]
PARA (I 1, HASTA <= 26, I I + 1)
{
SI (AUTOSVEN[I] > MAX)
{

MAX AUTOSVEN[I]
POS I

}
}

MOSTRAR MAX
MOSTRAR POS + 1978
FIN

11


INSERCIÓN Y BORRADO

INSERCIÓN
Sea A el conjunto de datos almacenados en la memoria del computador. El Array A
tiene tamaño 100, de los cuales esta lleno N elementos y k es un entero positivo
(k<=N), el algoritmo inserta un dato ELEM en la posición k-esima del Array A.

ALGORITMO INSERCION
INICIO
ENTERO J, K, N, ELEM
REAL A[100]
LEER N //NÚMERO DE ELEMENTOS LLENOS
J N //INICIALIZA EL CONTADOR
LEER K //LEE POSICIÓN K-ESIMA, DONDE SE INSERTA
LEER ELEM
MIENTRAS (J >= K)
{
A[J + 1] A[J] // MOVEMOS EL ELEMENTO J-ESIMO HACIA ABAJO
J J–1 // DISMINUIMOS EL CONTADOR
}
A[K] ELEM // INSERTAMOS EL ELEMENTO ELEM
N N+1 // ACTUALIZAMOS N
FIN

ALGORITMO INSERCION
INICIO
ENTERO J, K, N
REAL A[100]

LEER N //NÚMERO DE ELEMENTOS LLENOS
J N //INICIALIZA EL CONTADOR
LEER K //LEE POSICIÓN K-ESIMA, DONDE SE INSERTA
LEER ELEM
PARA (J N, HASTA K; J J - 1)
{
A[J + 1] A[ J ] // MOVEMOS EL ELEMENTO J-ESIMO HACIA ABAJO
}
A[K] ELEM // INSERTAMOS EL ELEMENTO ELEM
N N+1 // ACTUALIZAMOS N
FIN

BORRADO
Sea el array a que tiene 100 elementos de tipo real, de los cuales n elementos
están llenos, y sea k un entero positivo (k<= n). El algoritmo borra el k-esimo
elemento ELEM del array.

ALGORITMO BORRADO
INICIO
ENTERO K, J, N
REAL A[N] , A[100]

12


//LEE EL ÍNDICE DEL ELEMENTO A SER BORRADO Y EL NÚMERO DE ELEMENTOS
LLENOS
LEER K, N
PARA (J K HASTA N - 1; J J + 1)
{
A[ J ] A [J + 1] // SE MUEVE EL ELEMENTO J-ESIMO HACIA ARRIBA
}
A[N] 0;
N N-1 // SE ACTUALIZA EL NUMERO DE ELEMENTOS N
FIN

CLASIFICACIÓN
Proceso que permite ordenar un conjunto de objetos en un orden específico. Esto
se hace por lo general para facilitar la búsqueda de los elementos del array, por
ejemplo los elementos de un diccionario, agendas telefónicas, etc.

La importancia de mantener 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, enseguida
veremos algunos de ellos.

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.

ALGORITMO SELECCIÓN DIRECTA
INICIO
ENTERO I, MIN, J, ARREGLO[N]
I 1
MIENTRAS (I <= N)
{
MIN I
J I+1
MIENTRAS (J <= N)
{
SI (ARREGLO[J] < ARREGLO[I])
{
MIN J
INTERCAMBIA(ARREGLO[MIN],ARREGLO[I])}
J J+1

I I+1
}

13


}
FIN

14


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.

ALGORITMO SELECCIÓN DIRECTA
INICIO
ENTERO I, J, ARREGLO[N]
I 1
MIENTRAS (I < N)
{
J N
MIENTRAS (J > I)
{
SI (ARREGLO[J] < ARREGLO[J-1])
{
INTERCAMBIA(ARREGLO[J],ARREGLO[J-1])
}
J J–1
}
I I +1
}

SELECCIÓN INSERCIÓN O BARAJA

Este método consiste en insertar un elemento en una parte ya ordenada del este
vector y comenzar de nuevo con los elementos restantes:

ALGORITMO INSERCIÓN
INICIO
ENTERO I, K, AUX, ARREGLO[N]
LOGICO B
PARA (I 1, HASTA N, I I + 1){
AUX ARRAY[I]
K I-1
B FALSO
MIENTRAS ((B = FALSO) Y (K >= 0))
{
SI AUX < ARREGLO[K]
{
ARREGLO[K + 1] ARREGLO[K]
K K–1
}
SI NO
{
SW VERDAD

15


}
}
ARREGLO[K + 1] AUX
}
FIN

ORDENACIÓN QUICKSORT
Este algoritmo consiste en partir el arreglo original por la mitad usando un valor
pivote del mismo array, 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.

ALGORITMO PARTICIÓN
INCIO
LLAMAR QUICKSORT(0, N-1)
FIN

PROCEDIMIENTO QUICKSORT(ENTERO PRIMERO, ENTERO ULTIMO)
INICIO
ENTERO CENTRAL, I, D, AUX
I PRIMERO
D ULTIMO;
CENTRAL (ARRAY[PRIMERO + ULTIMO] DIV 2)

MIENTRAS (I <= D)
{
MIENTRAS (ARRAY [I] < CENTRAL)
{
I I+1
}
MIENTRAS(ARRAY[D] > CENTRAL)
{
D D - 1;
}

SI (I <= D)
{
AUX ARRAY [I]
ARRAY [I] ARRAY [D]
ARRAY [D] = AUX
I I+1
D D-1
}
}

SI(D > PRIMERO)
{
LLAMAR QUICKSORT(PRIMERO, J)
}

16


SI(I < ULTIMO)
{
LLAMAR QUICKSORT(I, ULTIMO)
}
FIN

17


EJERCICIOS DE APLICACIÓN

Objetivos:
1. Fijar los conocimientos sobre arrays unidimensionales.
2. Construir los algoritmos planteados con su respectivo diagrama de flujo.
3. Implementar o codificar estos algoritmos en lenguaje c.

Ejercicio 1:
El administrador de una tienda utiliza los arrays UVMan y UVTar para guardar las
unidades vendidas en la mañana y en la tarde respectivamente y en el array PreUni
se almacenan el precio de venta de cada unidad de producto. Hacer un algoritmo
para calcular las unidades vendidas en el día y a cuanto asciende la venta de cada
producto. Se comercializan 20 productos.

Ejercicio 2:
Sea A un conjunto de números reales almacenados en la memoria del computador,
el array A tiene 100 elementos, de los cuales esta lleno en X elementos y k es un
entero positivo (k<=X). Diseñar el algoritmo para insertar un dato ELEM en la
posición k-esima del Array A.

Ejercicio 3:
Sea el array A que tiene 100 elementos de tipo real, de los cuales X elementos
están llenos, y sea k un entero positivo (k<=X). Construir el algoritmo que borre el
k-esimo elemento ELEM del Array.

Ejercicio 4:
Sea el Array A que tiene 100 elementos de tipo real, que almacena las calificaciones
de 100 alumnos, calcular el promedio de las calificaciones, deducir cuantos estas
por debajo del promedio y cuantos están por encima del promedio inclusive.
Construir el algoritmo que realice el trabajo.

Ejercicio 5:
Sea el Array MARCAS de 10 elementos que contiene 7 marcas de automóviles, en
orden alfabético, (Alfa Romeo, De Lorian, Fiat, Ford, LandRobert, Nissan, Renault),
se desea insertar 2 nuevas marcas Opel y Citroën. Construir el algoritmo que
realice el trabajo.

ROLFPINTO@HOTMAIL.COM

18

Arreglos

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (18)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Arreglos

Ähnlich wie Arreglos (20)

Mehr von Rolf Pinto

Mehr von Rolf Pinto (6)

Arreglos