UNIVERSIDAD NACIONAL AUTONOMA DE MÉXICO

FACULTAD DE ESTUDIOS SUPERIORES ARAGON

INGENIERIA EN COMPUTACION

SEMESTRE 2022-I

ESTRUCTURA DE DATOS

PORFESOR: SANCHEZ HERNANDEZ MIGUEL ANGEL

SEGUNDO EXAMEN PARCIAL

ALUMNO: CRUZ JUAREZ EZEQUIEL AMADO

GRUPO: 1307
Índice
Objetivo.............................................................................................................................................................2
Introducción......................................................................................................................................................2
Problema uno...................................................................................................................................................2
Variables.......................................................................................................................................................3
Botones.........................................................................................................................................................4
Salir............................................................................................................................................................4
Aleatorios..................................................................................................................................................4
Botón Iniciar..............................................................................................................................................5
Métodos de Ordenamiento.........................................................................................................................6
Sacudida...................................................................................................................................................6
Burbuja......................................................................................................................................................7
Inserción....................................................................................................................................................7
Selección..................................................................................................................................................8
QuickSort Recursivo................................................................................................................................9
QuickSort Iterativo.................................................................................................................................10
Ejecución del programa............................................................................................................................12
Problema dos y tres......................................................................................................................................13
Declaraciones.............................................................................................................................................14
Botón Conversión......................................................................................................................................15
Botón Evaluar.............................................................................................................................................19
Ejecución....................................................................................................................................................20
Problema cuatro.............................................................................................................................................21
Declaraciones.............................................................................................................................................21
Ratón...........................................................................................................................................................21
Recursivo....................................................................................................................................................22
Iterativo.......................................................................................................................................................22
Ejecución....................................................................................................................................................23
Conclusiones..................................................................................................................................................24
Referencias....................................................................................................................................................25

1
Objetivo
 Conocer distintos métodos de ordenamiento y su eficiencia
 Reconocer las ventajas de las pilas
 Reconocer las ventajas de la recursividad

Introducción
Este segundo parcial plantea 4 problemas, que involucran los temas vistos en este segundo parcial
(métodos de ordenamiento y pilas). Con lo visto en clase sobre la implementación de los distintos
métodos de ordenamiento y la parte teórica sobre estos. De igual forma conocer una nueva
herramienta para almacenar datos, la pila y las ventajas que representa para resolver distintos
problemas como lo es permitir volver iterativos los métodos recursivos. Justamente esto ultimo es
algo que forma parte de este segundo parcial.
Identificación y resolución de los problemas

Problema uno
El primer problema solicita mostrar de manera grafica varios algoritmos de ordenamiento para
poder analizar cuál es el más eficiente, los métodos de ordenamiento son los siguientes:
 Burbuja
 Selección
 Inserción
 Sacudida
 QuickSort iterativo
 QuickSort Recursivo
Lo primero a hacer fue crear en scene builder el diseño

Ya con todas las graficas con la que se iba a trabajar, con los elementos que se dieron en clase
hice algunas modificaciones y adiciones que veremos paso por paso.

2
Variables
Para poder mostrar y representar cada uno de los métodos de ordenamiento se hizo la declaración
del BarChart respectivo para cada método.

Los botones que realizaran las diferentes acciones según sea el seleccionado también son
declarados

De igual forma, se hizo la declaración de las variables que permiten la manipulación de las barras
que representan los datos de las listas

3
También se declaro el hilo con el que estará corriendo el programa

Botones
Salir

El botón salir lo que hace es revisar si el hilo es diferente de nulo para tener la información sobre si
se está ejecutando, en el caso de que se cumpla la condición corta el hilo y cierra la aplicación.

Aleatorios

El botón aleatorios utiliza una función secundaria llamada númerosAleatorios

Esta función lo que hace es limpiar las listas por si llegasen a tener elementos previos

Se declara un objeto de tipo Random y una variable para almacenar los valores aleatorios

Se entra en un ciclo iterativo en el cual se asignarán a cada lista 90 elementos con valores
aleatorios entre 0 y 199.
4
Cuando se terminó de ejecutar la función númerosAleatorios se limpian los datos de las series

Y se entra en un ciclo iterativo donde se asignará a cada elemento de la lista su barra

correspondiente en la grafica

Por ultimo se revisa una condición donde si el hilo es diferente de null para ejecutarlo

Botón Iniciar

El botón iniciar ejecuta el hilo

Después invoca a los métodos de ordenamiento como funciones

5
Esta ejecución la hace por cada segundo

Métodos de Ordenamiento
Sacudida
Se hace la declaración de las variables que se utilizaran

Se entra en un ciclo while donde se realizarán dos ciclos for que recorrerán toda la lista para ir
ordenando los elementos.
El primero recorre la lista de derecha a izquierda

Al concluir este ciclo se le asigna el valor de k + 1 a la variable izq y se empieza a recorrer la lista
de izquierda a derecha, al término de este segundo ciclo se asigna el valor de k – 1 a la variable
der

6
Burbuja
El método burbuja es mas sencillo utiliza dos ciclos for para recorrer la lista y hacer las
comparaciones para ordenar la lista

Inserción
El método de inserción utiliza variables auxiliares, entra en un ciclo for que recorrerá toda la lista,
se asignan los extremos de la lista y se guarda el estilo de la variable auxiliar

7
Se entra en un ciclo while que acercara cada vez mas los extremos mientras se compara el
elemento que se encuentra en la mitad de los extremos y al terminar este ciclo se le asigna el valor
de i -1 a la variable j

Después de eso se entra a otro ciclo while donde se recorrerá la lista de la posición j hasta el
extremo izquierdo

Concluido este ciclo se asigna el valor de aux al extremo izquierdo

Selección
El método de selección es menos extenso, utiliza dos ciclos for para buscar el elemento menor de
la lista e ir haciendo los intercambios correspondientes

8
QuickSort Recursivo
El método QuickSort Recursivo utiliza una función secundaria llamada reduceRecursivo

La función secundaria reduceRecursivo recibe por entrada los datos de los extremos de la lista,
utiliza una variable booleana para entrar en un ciclo while donde se empezarán a hacer las
comparaciones primero desde la variable pos hasta el extremo derecho de la lista.

9
Después hace las mismas comparaciones, pero esta vez desde la variable pos hasta el extremo
izquierdo de la lista

Con la lista dividida por la variable pos se repite el mismo proceso para ambos lados

QuickSort Iterativo
Para este método de ordenamiento algunas variables que tuve que declararlas estáticas para que
pudiera funcionar de manera correcta

El método comienza inicializando todas las variables en 0 por si estas tenían un dato previo,
además que se asignan los valores de los extremos de la lista

Se entra en un bucle while y se asignan los extremos de la lista, además de que se llama a una
función secundaria llamada reduceIterativo
10
Se comparan los extremos de la lista respecto a la variable posRI

La función secundaria reduceIterativo sigue el mismo proceso que la función de reduceRecursivo

en un ciclo while va evaluando desde la variable posRI a la izquierda y a la derecha

11
Ejecución del programa
Al ejecutar el programa se inicializan todas las graficas con los mismos valores para poder ser
ordenadas y poder comparar cual método es más eficiente.

Al darle al botón iniciar todas las graficas comienzan a ordenarse

12
Al presionar el botón de aleatorio las graficas se llenan con nuevos datos
Nota. Por una razón que desconozco en ocasiones al presionar el botón aleatorio no actualiza de
forma corriente todas las gráficas, solo se debe presionar el botón de aleatorio nuevamente

Problema dos y tres

El problema dos y tres los anexe en uno mismo, fue una sugerencia en la clase y la implemente en
mi proyecto.
El problema tres solicita convertir una expresión interfija en una posfija tomando en cuenta los
paréntesis y la jerarquía de operaciones. Lo primero fue crear la plantilla en sceneBuilder para
trabajar con ella

13
Declaraciones
Como se muestra en la imagen anterior se declaran dos Buttons, dos Labels, dos TextField y un
TextArea

Se declaran variables estáticas que serán utilizadas para la conversión de la expresión interfija a
posfija, en las primeras versiones token era un arreglo unidimensional, pero fue cambiado a un
objeto de ListaSimple debido a la propiedad dinámica que tiene, permitiendo almacenar mas o
menos elementos, quitando un limite aparente a la extensión de la expresión.

Botón Conversión
El botón Conversión lo primero que hace es revisar si la lista token está vacía si no es el caso la
limpia para que se llene con nuevos elementos sin afectar la expresión que ingreso el usuario
14
Se ingresa el contenido del TextField en la variable cadena, posteriormente se ingresa en un
arreglo unidimensional para ingresar los elementos en la lista token

Se entra en un ciclo while mientras no sea el fin de la cadena, se inserta el elemento en la posición
del contador en una variable símbolo para poder identificar posteriormente si se trata de un
operador o un operando, también se llama a una función secundaria llamada paréntesis que busca
los paréntesis que existen en la expresión. Después de la ejecución de la función secundaria se
revisa si el contador es igual a la longitud y es un paréntesis de cierre esto se hace debido a la
naturaleza de la función paréntesis, para el caso de que el paréntesis de cierre sea el ultimo
elemento de la expresión no arroje un error la aplicación, si se cumple la condición se hace un
break y se sale del ciclo debido a que el contador no es menor que la longitud de la expresión.

Posteriormente se asigna nuevamente a símbolo el valor que tiene la lista en la posición del
contador y se revisa si el símbolo es un operando, si no es un operando se inserta el elemento en
la cadena en caso contrario se inserta en la pila

Se incrementa el contador y se entra a un ciclo while en el que si la pila no se encuentra vacía se

insertan los elementos que contiene y por ultimo se inserta la cadena con la expresión posfija en el
TextField de posfija.

15
La función secundaria paréntesis utiliza como base el algoritmo visto en clase para verificar los
paréntesis correctos, se declaran nuevas variables que servirán para apoyarse al momento de
hacer todo el proceso

Se revisa si la pila está vacía en caso de contener elementos se almacena en la pila tmp

Se entra en un ciclo while que recorrerá toda la lista, la primera condición revisa si se encuentra un
paréntesis de apertura, en el caso de que se cumpla se asigna el valor siguiente a la variable
posición para que desde ahí comience la conversión sin tomar en cuenta el paréntesis

Después se revisa si el elemento es un paréntesis de cierre

Si es un paréntesis de cierre se revisa que tipo de paréntesis es para este primer caso se trata de
“)” y se realiza el mismo algoritmo para convertir la expresión en posfija

16
Con la variación de que se incrementa el contador una vez más para que al salir de la función el
contador no esté en la posición del paréntesis de cierre. Esto se repite con los otros dos tipos de
paréntesis

17
Por ultimo se revisa si la pila tmp no contiene ningún elemento, en caso de que si contenga
elementos se insertan en la pila

Otra función secundaria que se utiliza es la de prc esta retorna un valor booleano dependiendo de
la jerarquía de la operación en el caso de que val1 sea “*” o “/” retorna un true en el caso contrario
se hacen las evaluaciones correspondientes.

18
Botón Evaluar
Se declaran las variables con las que se va a ejecutar el programa para realizar las operaciones
correspondientes

Se empieza a recorrer la cadena, si la cadena contiene un operando se inserta el valor en la pila

En el caso contrario se extrae el contenido de la pila y se les asigna a los operandos para
posteriormente identificar cual es la operación por realizar el resultado de la operación se guarda
nuevamente en la pila
19
Al terminar el ciclo se extrae el valor de la pila y se asigna al TextArea

Ejecución
El usuario debe ingresar la expresión interfija en la caja de texto indicada y presionar el botón de
conversión para pasar la expresión interfija en una posfija, posteriormente presionar el botón
Evaluar para evaluar la operación posfija.

20
Problema cuatro
El cuarto problema solicitaba convertir un programa que utilizaba una función recursiva en uno
iterativo con el uso de pilas, este problema fue resuelto en clase.
La aplicación se inicializa para tener una imagen que pueda ser manipulable por nosotros para
poder pintar sobre ella.

Declaraciones
Se declaran todos los elementos que ser van a utilizar, para colocar la imagen que se va a pintar y
con lo que se va a rellenar

Ratón
Este programa no utiliza botones para funcionar por lo que tiene un oyente que esta revisando si se
da un clic en la imagen para poder llamar las funciones para pintar la imagen, revisa el color del
pixel que en el que se dio el clic y posteriormente llama a la función para rellenar la imagen.

Recursivo
La función recursiva es sencilla de entender, primero tiene el caso base para evitar desperdiciar memoria,
mientras no se llegue a el caso base se revisan los pixeles alrededor y se van pintando mientras se va
reduciendo el numero de llamadas que se indico
21
Iterativo
Lo que nos interesa es el iterativo, primero se declara una estructura de tipo Pila en la que se insertan
coordenadas para poder empezar a hacer las iteraciones

Se entra en un ciclo Do While en el que se extrae el valor de las coordenadas donde se hizo el clic, también
se obtiene el color del pixel que seleccionamos

Se revisa una condición para ver si los pixeles que se quieren pintar son blancos y de cumplirse se agregan
las coordenadas para 8 direcciones, arriba, abajo, derecha, izquierda, diagonal superior derecha, diagonal
superior izquierda, diagonal inferior derecha y diagonal inferior izquierda. Este ciclo se realiza mientras la
pila contenga elementos en su interior.

22
Ejecución
Al ejecutar el programa tenemos la imagen dispuesta a nosotros para que podamos comenzar a rellenarla

23
Al comenzar a clicar en los pixeles blancos la imagen se comienza a rellenar, rellena la superficie
solo que llega a tardar bastante dependiendo que tan grande sea lo que tiene que rellenar.

Conclusiones
El primer problema represento un gran desafío debido a que al ser mi primera vez utilizando
JavaFx me resulto bastante complicado comprender como estaban funcionando las cosas, realicé
primero cada uno de los métodos de ordenamiento en una clase aparte que mostraba los
resultados por consola antes de comenzar a trabajar de forma grafica de esta forma pude
concentrarme únicamente en la parte gráfica. De lo que pude apreciar los métodos más rápidos
son QuickSort iterativo y recursivo, el mas lento el de selección, la primera impresión es que el de
inserción es el más rápido debido a que pareciera que se ordena antes que todos, pero en realidad
todavía sigue manipulando algunos elementos.
Ver el uso que se pueden dar a las pilas incluso de esta forma un tanto especifica a un problema
de convertir y evaluar operaciones, en un punto donde para la conversión debía guardar los
elementos en una variable temporal, lo primero fue utilizar una variable string, después me percate
que en la pila podrían existir mas de un elemento en espera, entonces cambie de un string a una
ListaSimple pero me di cuenta de que con otra pila podía almacenar toda la información.
El problema de conversión me llevo demasiado tiempo debido a que la forma en la que planteé mi
solución podía a llegar a tener ciertos fallos, conforme hacia pruebas me di cuenta de que ciertas
expresiones rompían mi programa entonces fui creando validaciones para evitar errores en la
ejecución, lo mas probable es que existan soluciones y algoritmos mucho más eficientes que el
mío, pero eso ya será un reto personal.
Para el problema numero 4 solamente agregue otras 4 direcciones en las cuales pintar y cambiar la
condición del ciclo Do While esto debido a que la proporcionada estaba en que el ciclo se
cumpliera siempre y eso me marcaba errores con la pila vacía, con la condición nueva ya no
aparecen esos errores y luce idéntico a cómo funciona la función recursiva. Únicamente hice eso
porque no comprendí si se tenia que hacer algo más, lo que solicitaba el problema fue
proporcionado en clase.

Referencias
Cairo, O. (2001). Estructuras de Datos - 2b: Edición. MC Graw Hill.
D. (2016). Como Programar En Java (9.a ed.). Pearson Education.
Ford, T. H. W. W. R. (2021). Estructuras de datos con C ++ usando STL. Pearson.

24