Ensayo fina EDA.

Sebastian Fernandez 1102556.

TRABAJO FINAL DE ESTRUCTURA DE DATOS Y ALGORITMO I (VALIDO POR 30

PUNTOS)
• 20 PUNTOS TEORIA
• 10 PUNTOS HACER EXPOSICION Y SUBIRLA EN UN VIDEO EN YOUTUBE
• INTRODUCCION
• DESARROLLO (MINIMO 15 PAGINAS, INCLUIR EJEMPLOS DEMOSTRATIVOS)
• CONCLUSION

TEMAS A DESARROLLAR
1) Algoritmos de búsqueda.
• Búsqueda Secuencial.
• Búsqueda Binaria.
• Inserción en una lista ordenada.
2) Algoritmos de Ordenamiento.
• Ordenamiento por selección.
• Ordenamiento por inserción.
• Ordenamiento por inserción listas ligadas basadas en listas.
• Ordenamiento rápido: Listas basadas en arreglos.
• Ordenamiento por Mezcla.
• Límite inferior de algoritmos de ordenamiento basados en la comparación.
• Ordenamiento por Montículos, Listas basadas en arreglos.
 Introduccion.

Ensayo final de estructura de datos y algoritmos, vamos a desglosar una

serie de subtemas ateriormente dados relacionados con; los algoritmos de
busqueda, y los algoritmos de ordenamiento.
En primer lugar, que son.
1.los algoritmos de busqueda?
Un algoritmo de búsqueda es un conjunto de instrucciones que están diseñadas para
localizar un elemento con ciertas propiedades dentro de una estructura de datos; por
ejemplo, ubicar el registro correspondiente a cierta persona en una base de datos, o el
mejor movimiento en una partida de ajedrez.

2.Los algoritmos de ordenamiento?

En computación y matemáticas un algoritmo de ordenamiento es un algoritmo que
pone elementos de una lista o un vector en una secuencia dada por una relación de
orden, es decir, el resultado de salida ha de ser una permutación —o reordenamiento—
de la entrada que satisfaga la relación de orden dada.
 Desarrollo.
Los algoritmos de busqueda se subdesarrollan en busqueda secuencial y
busqueda binaria.
La busqueda secuencial es La búsqueda secuencial consiste en
comparar secuencialmente el elemento
deseado con los valores contenidos en las
posiciones 1,....,n.
El proceso termina cuando o bien
encontramos el elemento o bien se alcanza
el final del vector.

-Un primer nivel de diseño:

ind:=0

buscar elemento en vector

si vector[ind]=elemento entonces
busquedasecuencial:=ind

sino
busquedasecuencial:=0
BÚSQUEDA SECUENCIAL,
IMPLEMENTACIÓN EN PASCAL
FUNCTION
Busquedasec(v:tvector ; elem:telem):tIntervalo;
{Dev. 0 si el elemento no está en ‘v’ o i si v[ì]=elem}
VAR
i:tIntervalo;
BEGIN
i:=0;
repeat
i:=i+1;
until (v[i]=elem) or (i=N);
if v[i]=elem then
busquedasec:=i
else
busquedasec:=0
END; {busquedasec}
Este algoritmo en el peor de los casos es de orden O(n).
BÚSQUEDA SECUENCIAL
ORDENADA

-El algoritmo anterior puede ser mejorado si

el vector ‘v’ esta ordenado (i.e. Creciente).

-De esta forma si durante la búsqueda se

alcanza una componente con mayor valor
que ‘elem’, podremos asegurar que no se
encuentra dentro de la colección.
BÚSQUEDA SECUENCIAL

ORDENADA, IMPLEMENTACIÓN EN PASCAL FUNCTION.

Busquedasecord(v:tvector ; elem:telem):tIntervalo;
{Dev. 0 si el elemento no está en ‘v’ o i si v[ì]=elem}
VAR
i:tIntervalo;
BEGIN
i:=0;
repeat
i:=i+1;
until (v[i]≥elem) or (i=N);
if v[i]=elem then
busquedasecord:=i
else
busquedasecord:=0
END; {Busquedasecord}
Este algoritmo en el peor de los casos es de orden O(n).
-------------------------------------------------------------------------------------------------------------

• La busqueda binaria.
Es un algoritmo eficiente para encontrar un elemento en una lista ordenada de
elementos. Funciona al dividir repetidamente a la mitad la porción de la lista que podría
contener al elemento, hasta reducir las ubicaciones posibles a solo una. Usamos la
búsqueda binaria en el juego de adivinar en la lección introductoria.
Una de las maneras más comunes de usar la búsqueda binaria es para encontrar un
elemento en un arreglo. Por ejemplo, el catálogo estelar Tycho-2 contiene información
acerca de las 2,539,913 estrellas más brillantes en nuestra galaxia. Supón que quieres
buscar en el catálogo una estrella en particular, con base en el nombre de la estrella.
Si el programa examinara cada estrella en el catálogo estelar en orden empezando con
la primera, un algoritmo llamado búsqueda lineal, la computadora podría, en el peor de
los casos, tener que examinar todas las 2,539,913 de estrellas para encontrar la estrella
que estás buscando. Si el catálogo estuviera ordenado alfabéticamente por nombres de
estrellas, la búsqueda binaria no tendría que examinar más de 22 estrellas, incluso en el
peor de los casos.

Los siguientes artículos discuten cómo describir cuidadosamente el algoritmo, cómo

implementar el algoritmo en JavaScript y cómo analizar su eficiencia.

Describir la búsqueda binaria Al describir un algoritmo para un ser humano, a menudo

es suficiente una descripción incompleta. Algunos detalles pueden quedar fuera de una
receta de un pastel; la receta supone que sabes cómo abrir el refrigerador para sacar los
huevos y que sabes cómo romper los huevos. La gente puede saber intuitivamente
cómo completar los detalles faltantes, pero los programas de computadora no.
Es por eso que necesitamos describir completamente los algoritmos computacionales.
Para poder implementar un algoritmo en un lenguaje de programación, necesitarás
entender un algoritmo hasta sus últimos detalles.
¿Cuáles son las entradas del problema?
¿Las salidas?
¿Qué variables deben crearse, y qué valores iniciales deben tener?
¿Qué pasos intermedios deben tomarse para calcular otros valores y calcular en última
instancia la salida?
¿Estos pasos repiten instrucciones que se pueden escribir en forma simplificada al usar
un bucle?
Veamos cómo describir cuidadosamente la búsqueda binaria. La idea principal de la
búsqueda binaria es llevar un registro del rango actual de intentos razonables. Digamos
que estoy pensando en un número entre uno y 100, justo como en el juego de adivinar.
Si ya intentaste decir 25 y te dije que mi número es más grande, y ya intentaste decir 81
y te dije que mi número es más chico, entonces los números en el rango de 26 a 80 son
los únicos intentos razonables. Aquí, la sección roja de la recta numérica contiene los
intentos razonables, y la sección negra muestra los intentos que hemos descartado: En
cada turno, haces un intento que divide el conjunto de intentos razonables en dos
rangos de aproximadamente el mismo tamaño. Si tu intento no es correcto, entonces te
digo si es muy alto o muy bajo, y puedes eliminar aproximadamente la mitad de los
intentos razonables.
Por ejemplo, si el rango actual de los intentos razonables es de 26 a 80, intentarías
adivinar a la mitad del camino.
(26+80)/2 (26 + 80) / 2 (26+80)/2left parenthesis, 26, plus, 80, right parenthesis, slash, 2,
o 53.
Si después te digo que 53 es demasiado alto, puedes eliminar todos los números de 53 a
80, dejando 26 a 52 como el nuevo rango de intentos razonables, reduciendo a la mitad
el tamaño del rango. Para el juego de adivinar, podemos llevar un registro del conjunto
de intentos razonables al usar unas cuantas variables. Sea la variable min min minm, i,
en el intento razonable mínimo actual para esta ronda, y sea la variable max max maxm,
a, x el intento razonable máximo actual. La entrada (o input en inglés) al problema es el
número n, el mayor número posible que tu oponente está pensando. Suponemos que el
menor número posible es uno, pero sería fácil modificar el algoritmo para tener el
menor número posible como una segunda entrada. Aquí está una descripción paso a
paso de cómo usar la búsqueda binaria para jugar el juego de adivinar sea:
min=1min = 1 min=1m, i, n, equals, 1 y max=n max = nmax=nm, a, x, equals, n. Adivina
el promedio de maxmaxmaxm, a, x y minminminm, i, n, redondeado hacia abajo de
modo que sea un entero. Si adivinaste el número, detente.
¡Lo encontraste! Si el intento fue demasiado bajo, haz que minminminm, i, n sea uno
más grande que el intento. Si el intento fue demasiado alto, haz que maxmaxmaxm, a, x
sea uno menos que el intento. Regresa al paso dos.
Podríamos hacer que la descripción fuera todavía más precisa al describir claramente las
entradas y las salidas del algoritmo y al clarificar qué queremos decir con instrucciones
como "adivina un número" y "detente". Pero esto es suficiente detalle por ahora. A
continuación, vamos a ver cómo podemos utilizar la búsqueda binaria en un arreglo, y
discutir cómo convertir las descripciones de los algoritmos a código real que funcione.

Los algoritmos de Ordenamiento se dividen en:

• Ordenamiento por selección.

El ordenamiento por selección es un algoritmo de ordenamiento que requiere O ( n 2 )
{\displaystyle (n^{2})} {\displaystyle (n^{2})} operaciones para ordenar una lista de n
elementos.

Su funcionamiento es el siguiente:

• Buscar el mínimo elemento de la lista

• Intercambiarlo con el primero
• Buscar el siguiente mínimo en el resto de la lista
• Intercambiarlo con el segundo

Y en general:

• 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

De esta manera se puede escribir el siguiente pseudocódigo para ordenar una lista de n
elementos indexados desde el 0:
para i=0 hasta n-2
mínimo = i;
para j=i+1 hasta n-1
si lista[j] < lista[mínimo] entonces
mínimo = j /* (!) */
fin si
fin para
intercambiar(lista[i], lista[mínimo])
fin para

Ejemplo del algoritmo en C++

for(int i = 0; i < n-1 ; i++){

int minimo = i;
for(int j = i + 1 ; j < n ; j++){
if(lista[j] < lista[minimo]){
minimo = j;
}
}
intercambiar(lista , i , minimo);
}
• 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. Requiere O(n2) operaciones para ordenar una lista de n elementos.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto

ordenado.Después,cuando hay k elementos ordenados de menor a mayor, se toma el
element k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando
se encuentra un elemento menor (todos los elementos mayores han sido desplazados
una posición a la derecha) o cuando ya no se encuentran elementos (todos los
elementos fueron desplazados y este es el más pequeño). En este punto se inserta el
elemento k+1 debiendo desplazarse los demás elementos.
• Ordenamiento por inserción listas ligadas basadas en listas.
El método insert() es utilizado para insertar un elemento en un índice (una posición)
particular de la lista. Para que insert() sea equivalente a append() : El valor del índice
debe ser el tamaño de la lista ( len(<lista>) ) porque queremos agregar el nuevo
elemento al final de la lista.

• Ordenamiento rápido: Listas basadas en arreglos.

Los arreglos son estructuras de datos estáticas, ya que hay que declarar su tamaño
antes de utilizarlos. A diferencia de los arreglos, las listas son estructuras de datos que
pueden ir creciendo conforme se vaya requiriendo, por eso se considera que es una
estructura de datos dinámica que veremos a continuación.
• Ordenamiento por Mezcla.
El algoritmo de ordenamiento por mezcla es un algoritmo de ordenamiento externo
estable basado en la técnica divide y vencerás. Es de complejidad O(n log n).
• Límite inferior de algoritmos de ordenamiento basados en la comparación.
Las relaciones de orden más usadas son el orden numérico y el orden lexicográfico.
Ordenamientos eficientes son importantes para optimizar el uso de otros algoritmos
(como los de búsqueda y fusión) que requieren listas ordenadas para una ejecución
rápida.
También es útil para poner datos en forma canónica y para generar resultados legibles
por humanos. Desde los comienzos de la computación, el problema del ordenamiento
ha atraído gran cantidad de investigación, tal vez debido a la complejidad de resolverlo
eficientemente a pesar de su planteamiento simple y familiar. Por ejemplo, BubbleSort
fue analizado desde 1956.1 Aunque muchos puedan considerarlo un problema resuelto,
nuevos y útiles algoritmos de ordenamiento se siguen inventado hasta el día de hoy (por
ejemplo, el ordenamiento de biblioteca se publicó por primera vez en el 2004).
Los algoritmos de ordenamiento son comunes en las clases introductorias a la
computación, donde la abundancia de algoritmos para el problema proporciona una
gentil introducción a la variedad de conceptos núcleo de los algoritmos, como notación
de O mayúscula, algoritmos divide y vencerás, estructuras de datos, análisis de los casos
peor, mejor, y promedio, y límites inferiores.
• Ordenamiento por Montículos, Listas basadas en arreglos.
En una sección anterior, describimos el algoritmo de clasificación rápida para listas
contiguas, es decir, listas basadas en matrices. Observamos que, en promedio, una
ordenación rápida es del orden de O(nlog2n). Sin embargo, en el peor de los casos, la
ordenación rápida es del orden de O(n2). Esta sección describe otro algoritmo, la
clasificación de montones, para listas basadas en matrices. Este algoritmo es del orden
de O(n log2n), incluso en el peor de los casos, superando así al peor de los casos de
clasificación rápida.
Definición: un montón es una lista en la que cada elemento contiene una clave tal que la
clave en el elemento en la posición k de la lista es al menos tan grande como la clave del
elemento en la posición 2k+1 (si existe) y 2k+2 ( si existe). Recuerde que en C++ el índice
de la matriz comienza en 0, por lo que el elemento en la posición k es, de hecho, el
k+1esimo elemento de la lista.
En la figura 10-42, el primer elemento de la lista, que es 85, es el nodo raíz del árbol. El
segundo elemento de la lista, que es 70, es el hijo izquierdo del nodo raíz; el tercer
elemento de la lista, que es 80, es el hijo derecho del nodo raíz, por lo que, en general,
para el nodo k, que es el elemento k – 1 de la lista, su hijo izquierdo es el elemento 2k
de la lista (si lo hay), que está en la posición 2k – 1 de la lista, y el elemento secundario
derecho es el 1° elemento 2k de la lista (si lo hay), que está en la posición 2k de la lista.
Observe que la figura 10-42 muestra claramente que la lista de la figura 10-41 está en
un montón. Observe también que en la figura 10-42, los elementos 20, 10, 35, 15, 62, 58
y 30 se denominan hojas, ya que no tienen hijos.