Investigación:

Arreglos

Presentado por:
David Núñez - 21521086

Asignatura:
Programación III

Catedrático:
Ing. Juan Carlos Zepeda

San Pedro Sula, 26 de Julio de 2018

1
Contenido

1. ¿Qué es un arreglo? ................................................................................................ 3

2. Declaración arreglos en C++ ................................................................................. 3
3. ¿Cómo inicializar un arreglo en C++? ................................................................... 4
4. Algoritmos de ordenamiento en arreglos(Iterativa) ............................................... 5
A. Ordenamiento por inserción ........................................................................... 5
B. Ordenamiento por selección ........................................................................... 5
C. Ordenamiento burbuja..................................................................................... 6
5. Algoritmos de búsqueda en arreglos(Iterativa)...................................................... 7
A. Búsqueda Lineal ............................................................................................. 7
B. Búsqueda Binaria ............................................................................................ 7
6. Eficiencia de algoritmos: Notación Big O ............................................................. 9
7. Ejercicio ............................................................................................................... 10
8. Bibliografía .......................................................................................................... 11

2
 1. ¿Qué es un arreglo?

Los arrays, arreglos o vectores forman parte de la amplia variedad de estructuras de

datos que nos ofrece C++, siendo además una de las principales y más útiles
estructuras que podremos tener como herramienta de programación. Los arrays,
arreglos o vectores (como los quieras llamar), son utilizados para almacenar
múltiples valores en una única variable. En un aspecto más profundo, los arrays,
permiten almacenar muchos valores en posiciones de memoria continuas, lo cual
permite acceder a un valor u otro de manera rápida y sencilla. Estos valores pueden
ser números, letras o cualquier tipo de variable que deseemos incluso tipos de datos
propios.

En múltiples ocasiones es necesario almacenar gran cantidad de información en una

variable y a menudo sucede que no conocemos con exactitud la cantidad de datos
que debemos almacenar, pero sabemos que sí sería más de uno, como por ejemplo
almacenar las identificaciones de las personas ingresadas al sistema. Los arrays,
arreglos o vectores son una estructura que nos permite solucionar este tipo de
problemas.

2. Declaración de arreglos en C++

En C++ para declarar un array se emplea la sintaxis:

tipo identificador [tamaño] = { lista de inicialización } ;

donde, tipo se refiere al tipo de datos que contendrá el array. El tipo puede ser
cualquiera de los tipos estándar (char, int, float, etc.) o un tipo definido por el
usuario. Es más, el tipo del array puede ser de una estructura creada con: struct,
union y class. identificador se refiere al nombre que le daremos al array. tamaño es
opcional e indica el número de elementos que contendrá el array. Si un array se
declara sin tamaño, el mismo no podrá contener elemento alguno a menos que en la
declaración se emplee una lista de inicialización. lista de inicialización es opcional
y se usa para establecer valores para cada uno de los componentes del array. Si el
array es declarado con un tamaño específico, el número de valores inicializados no
podrá ser mayor a dicho tamaño.

3
 3. ¿Cómo inicializar un arreglo en C++?

Los arrays pueden ser inicializados en la declaración.

Ejemplo:

float R[10] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};

float S[] = {2, 32, 4.6, 2, 1, 0.5, 3, 8, 0, 12};
int N[] = {1, 2, 3, 6};
int M[][3] = { 213, 32, 32, 32, 43, 32, 3, 43, 21};
char Mensaje[] = "Error de lectura";
char Saludo[] = {'H', 'o', 'l', 'a', 0};

Cuando se inicializan los arrays en la declaración no es obligatorio especificar el

tamaño para la primera dimensión, como ocurre en los ejemplos de las líneas 2, 3,
4, 5 y 6. En estos casos la dimensión que queda indefinida se calcula a partir del
número de elementos en la lista de valores iniciales. El compilador sabe contar y
puede calcular el tamaño necesario de la dimensión para contener el número de
elementos especificados.

4
 4. Algoritmos de ordenamiento en arreglos (iterativa)

a. Ordenamiento por inserción

El ordenamiento por inserción es una manera muy natural de ordenar para un ser
humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas
en forma arbitraria.
La idea de este algoritmo de ordenamiento consiste en ir insertando un elemento
de la lista o un arreglo en la parte ordenada de la misma, asumiendo que el primer
elemento es la parte ordenada, el algoritmo ira comparando un elemento de la
parte desordenada de la lista con los elementos de la parte ordenada, insertando
el elemento en la posición correcta dentro de la parte ordenada, y asi
sucesivamente hasta obtener la lista ordenada.

b. Ordenamiento por selección

Consiste en encontrar el menor de todos los elementos del arreglo o vector e

intercambiarlo con el que está en la primera posición. Luego el segundo mas
pequeño, y así sucesivamente hasta ordenarlo todo. Su implementación requiere
O(n2) comparaciones e intercambios para ordenar una secuencia de elementos.
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener
que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando
hay que ordenar un vector de estructuras más complejas, la operación de
intercambiar los elementos sería más costosa en este caso. Su funcionamiento se
puede definir de forma general como:

 Buscar el mínimo elemento entre una posición i y el final de la lista

 Intercambiar el mínimo con el elemento de la posición i

5
c. Ordenamiento burbuja

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo

de ordenamiento. Funciona revisando cada elemento de la lista que va a ser
ordenada con el siguiente, intercambiándolos de posición si están en el orden
equivocado. Es necesario revisar varias veces toda la lista hasta que no se
necesiten más intercambios, lo cual significa que la lista está ordenada.
Este algoritmo obtiene su nombre de la forma con la que suben por la lista los
elementos durante los intercambios, como si fueran pequeñas "burbujas".
También es conocido como el método del intercambio directo. Dado que
solo usa comparaciones para operar elementos, se lo considera un algoritmo de
comparación, siendo uno de los más sencillo de implementar.

6
6. Algoritmos de búsqueda en arreglos (iterativa)
a. Búsqueda lineal

La búsqueda lineal probablemente es sencilla de implementar e intuitiva.

Básicamente consiste en buscar de manera secuencial un elemento, es decir,
preguntar si el elemento buscado es igual al primero, segundo, tercero y así
sucesivamente hasta encontrar el deseado.
Entonces este algoritmo tiene una complejidad de O(n).
La búsqueda binaria al igual que otros algoritmos como el quicksort utiliza la
técnica divide y vencerás. Uno de los requisitos antes de ejecutar la búsqueda
binaria, es que el conjunto de elementos debe de estar ordenado. Supongamos
que tenemos el siguiente array.
57 53 21 37 17 36 22 3 44 97 89 26 31 47 8 17
Debemos ordenarlos

3 8 17 17 21 22 26 31 36 37 44 47 53 57 89 97

b. Búsqueda binaria

La búsqueda binaria sólo se puede implementar si el arreglo está ordenado. La

idea consiste en ir dividiendo el arreglo en mitades. Por ejemplo supongamos
que tenemos este vector:
int vector[10] = {2,4,6,8,10,12,14,16,18,20};
La clave que queremos buscar es 6. El algoritmo funciona de la siguien manera
1. Se determinan un indice arriba y un indice abajo, Iarriba=0 e Iabajo=9
respectivamente.
2. Se determina un indice central, Icentro = (Iarriba + Iabajo)/2, en este caso
quedaría Icentro = 4.
3. Evaluamos si vector[Icentro] es igual a la clave de busqueda, si es igual ya
encontramos la clave y devolvemos Icentro.

7
4. Si son distintos, evaluamos si vector[Icentro] es mayor o menos que la
clave, como el arreglo está ordenado al hacer esto ya podemos descartar
una mitad del arreglo asegurandonos que en esa mitad no está la clave que
buscamos. En nuestro caso vector[Icentro] = 4 < 6, entonces la parte del
arreglo vector[0...4] ya puede descartarse.
5. Reasignamos Iarriba o Iabajo para obtener la nueva parte del arreglo en
donde queremos buscar. Iarriba, queda igual ya que sigue siendo el tope.
Iabajo lo tenemos subir hasta 5, entonces quedaria Iarriba = 9, Iabajo = 5.
Y volvemos al paso 2.

8
7. Eficiencia de algoritmos: Notación Big O
En programación el rendimiento o la complejidad de un algoritmo se suele medir
utilizando una notación denominada Big-O, y también conocida como Notación
Asintótica o Notación Landau (en honor a uno de sus inventores, a principios del
siglo pasado, Edmund Landau).

La notación Big-O nos proporciona una manera de saber cómo se va a comportar un

algoritmo en función de los argumentos que le pasemos y la escala de los mismos.

Por ejemplo, imagínate una función que se utiliza para localizar un elemento dentro
de una lista de elementos previamente guardados. Si la documentación de la misma
nos dice que es una operación de tipo O(1), quiere decir que da igual cuántos
elementos haya en la lista, la operación siempre tarda lo mismo. Para ser más exactos
deberíamos decir que el esfuerzo de cómputo necesario es el mismo.

Por eso, por ejemplo, que en la documentación el indizador Item de un ArrayList

que vimos antes, tenga complejidad O(1) quiere decir que da exactamente igual que
la colección tenga uno o un millón de elementos: insertar o recuperar un elemento
siempre tarda más o menos lo mismo.

Ahora supongamos que tenemos una función que dibuja en una gráfica los puntos
que le pasemos en una matriz. Su documentación nos dice que su complejidad
es O(n). Esto quiere decir, para entendernos, que si pintar 1 punto implica, por
ejemplo, 10ms, pintar 2 implicaría 20ms, 3 puntos serían 30ms, etc... O sea, el
tiempo necesario para ejecutar la función es función directa y lineal del número de
elementos que le pasemos.

Atendiendo a su complejidad, las notaciones Big-O más comunes para todo tipo de
algoritmos y funciones son las que se muestran en esta lista:

 O(1): constante.
 O(n): lineal.
 O(log n): logarítmica.
 O(n2): cuadrática.
 O(2n): exponencial.
 O(n!); explosión combinatoria.

9
Ejercicio:
a. Crear un programa donde el usuario ingrese 20 números desordenados, y luego
el programa debe ordenarlo haciendo uso del algoritmo Ordenamiento burbuja.
Una vez ordenado el arreglo, realizar la búsqueda de un número, mediante el
algoritmo de búsqueda binaria.

10
Bibliografía

https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Arrays_y_ca
denas_de_texto
http://lwh.free.fr/pages/algo/tri/tri_insertion_es.html
https://es.wikipedia.org/wiki/Ordenamiento_de_burbuja
https://ronnyml.wordpress.com/2009/07/09/busqueda-lineal-y-busqueda-binaria/
http://codigomaldito.blogspot.com/2005/11/busqueda-binaria.html

11