arreglos

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

1

Algoritmos

y

Estructura de Datos I


2

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


3

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.


4

� DATOS SIMPLES

� ESTÁNDAR

� ENTERO

� REAL

� CARACTER

� LÓGICO

� DEFINIDOS POR EL USUARIO � SUBRANGO

� ENUMERADO

� DATOS ESTRUCTURADOS

� SIMPLES O ESTÁTICOS

� ARRAY

� REGISTRO

� ARCHIVO

� CONJUNTO

� CADENA

� COMPUESTOS O DINÁMICOS

� LISTA LINEAL

� PILA

� COLA

� LISTA ENLAZADA

� LISTA NO LINEAL

� ÁRBOL

� 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


5

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 Hamill

Harrison Ford

Carrie Fisher

Billi Dee David 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)


6

{ b[j] = a[i]; j++; } else { c[k] = a[i]; k++; }

} printf ("\los números quedan así:\n\n"); for(i=0; i < j; i++) printf("%i\n", b[i]); for(i=0; i < k; i++) printf("\t%i\n", 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]


7

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'};


8

OPERACIONES SOBRE LAS ESTRUCTURAS LINEALES (ARRAYS)

OPERACIONES DE I/O

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

ALGORITMOS C++

A[10] � 45 A[10] = 45; Asigna 45 al elemento 10 del array A.

nombre[2] � "Carrie Fisher" nombre[2] = "Carrie Fisher"; Asigna Carrie Fisher al elemento 2 del array nombre.

vocales[3] � 'E' vocales[3] = 'E'; Asigna E al elemento 3 del array vocales.

talla[2] � 1.56 talla[2] = 1.56; Asigna 1.56 al 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) { LEER v[i]; }

for(i = 1; i<= n ; i++) { cin>>v[i]; }

PARA (i � 1; HASTA i<= n; i � i + 1) { MOSTAR peso[i]; }

for (i = 1; i<= n ; 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.


9

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


10

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) {


11

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


12

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]


13

//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 }


14

} FIN


15

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


16

} } 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) }


17

SI(I < ULTIMO) {

LLAMAR QUICKSORT(I, ULTIMO) } FIN


18

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.

[email protected]

arreglos

Documents