Diseño de programas, Aplicación Algorítmica y
Forms
Grupo 1 | Fundamentos de Programación- 16513
-Benites Yupanqui, Anderson Santiago N00342031
-Guevara Flores, Luis Miguel N00229225
- Santillan Elescano, Aaron Facundo Marcelo N00317620
-Vigo Vargas, Alonso Ramiro N00340370
Facultad de Ingeniería, Universidad Privada del
Norte
Fundamentos de Programación
Ing. Castro Javier, Marco Antonio
03 de julio de 2023
0
TABLA DE CONTENDIO
Introduccion………………………………………………………………………………..2
Desarrollo………………………………...……….....…………………………………….3
Pasos de la Solución del Enunciado 1………………………………………….….5
Analisis del problema…………………………………………………….5
Diseñar una alternativa de solución………………………………………5
Crear codigo…………………………………………………………….…6
Probar y depurar……………………………………………….…………..8
Pasos de la Solución del Enunciado 2……………………..………………….……9
Analisis del problema………………………………………………..…….9
Diseñar una alternativa de solución………………………………………10
Crear codigo…………………………………………………………...…12
Probar y depurar…………………………………..…………….………..15
Resumir los temas utilizados…………………………………………………….16
Enunicado 1……………………………………………………………...16
Enunciado 2……………………………………………………………..17
Documentar el código fuente…………………………………………………….18
Enunicado 1……………………………………………………………...18
Enunciado2………………………………………………………………..21
Conclusiones y Recomendaciones………………………………………………………..24
La utilidad del manejo de archivos……………………………………………….24
Cuándo aplicar recursividad……………………………………………………….25
Cuándo aplicar los métodos de ordenamiento…………………………………….25
Bibliografia……………………………………….………………………………………..26
1
Diseño de programas, Aplicación Algorítmica
Introducción
En el presente informe, nos enfocaremos en desarrollar y
presentar dos ejercicios de programación utilizando Forms,
con el objetivo de brindar una visión integral sobre las
capacidades y aplicaciones de esta herramienta en el ámbito
de la programación.
Exploraremos la utilidad de Forms como una poderosa
herramienta de programación, resaltando sus características
clave y su potencial para la creación de aplicaciones
interactivas, dinámicas y visualmente atractivas. A través de
los ejercicios prácticos, podremos ilustrar de manera
concreta cómo Forms puede ser utilizado en diferentes
contextos y abordar diversas problemáticas.
Es importante destacar que la programación con Forms
juega un papel fundamental en una amplia gama de campos,
abarcando desde el desarrollo web hasta la creación de
aplicaciones móviles. Su capacidad para adaptarse a
diferentes niveles de habilidad y su flexibilidad la
convierten en una alternativa atractiva tanto para
programadores principiantes como para aquellos con
experiencia en la materia. Además, ofrece una solución
versátil para abordar los casos que se presentarán en los
ejercicios.
2
Desarrollo
Presentación del grupo 1
Integrantes del grupo 1 de fundamentos de
programación:
-Benites Yupanqui, Anderson Santiago N00342031
-Guevara Flores, Luis Miguel N00229225
- Santillan Elescano, Aaron Facundo Marcelo N00317620
-Vigo Vargas, Alonso Ramiro N00340370
Una vez dicho nuestros nombres les presentare los
ejercicios para realizar en la aplicación en c# forms.
Enunciado 1. Requiere el uso de arrays
unidimensionales y recursividad para diseñar un
programa en C# con formularios de Windows. Este
programa debe permitir al usuario realizar las
siguientes acciones:
• Ingresar un array unidimensional de tipo string: El
usuario debe poder especificar el tamaño del array y
luego ingresar los elementos uno por uno.
• Mostrar el array desordenado: Una vez que el
usuario ha ingresado todos los elementos del array,
el programa debe mostrar los elementos en el orden
en que fueron ingresados, es decir, sin ningún tipo
de ordenamiento aplicado.
• Mostrar el array ordenado de forma ascendente
usando recursividad: Después de mostrar el array
desordenado, el programa debe utilizar una
implementación recursiva para ordenar los
elementos del array en forma ascendente. Esto
significa que los elementos deben mostrarse en
3
orden creciente, desde el más pequeño hasta el más
grande.
Enunciado 2. El problema que requiere el uso de
funciones, clases y manejo de archivos para diseñar
un programa en C# con formularios de Windows. A
continuación, se detallan los requisitos específicos:
• Registrar la actividad diaria de uso de videojuegos:
El usuario debe poder ingresar el nombre del
videojuego que ejecutó durante el día y especificar si
ganó o perdió. Si registra una victoria, se deben
generar 100 puntos, mientras que una derrota resta
20 puntos.
• Mostrar los datos del videojuego y los puntos
obtenidos en una tabla: Después de registrar cada
videojuego, el programa debe mostrar en una tabla
los detalles del videojuego, como el nombre y el
resultado (ganado o perdido), junto con los puntos
obtenidos en esa partida.
• Mostrar el total de puntos acumulados: Después de
cada registro de videojuego, el programa debe
mostrar en la parte inferior derecha del formulario el
total de puntos acumulados por todos los
videojuegos registrados hasta el momento.
• Uso de elementos gráficos: El programa debe
utilizar los elementos gráficos necesarios, como
tablas y campos de texto, para cumplir con los
requisitos solicitados y proporcionar una interfaz
visual intuitiva al usuario.
• Guardar los datos en un archivo: Todos los datos
registrados por el usuario, incluyendo los nombres
4
de los videojuegos, los resultados y los puntos
obtenidos, deben ser guardados en un archivo
llamado "base_de_informacion.txt". Este archivo
servirá como una base de datos para almacenar la
información y permitir su acceso posterior.
Pasos de la Solución del Enunciado 1
Análisis del problema.
Para la problemática leer cuidadosamente el
problema asegura una correcta comprensión y una
clara maniobra de cómo lograremos solucionar cada
punto pedido. Por ello, nuestro análisis consiste en
gestionar números ingresados por el usuario, con
acciones que se deben presentar por el sistema, tales
como mostrar un arreglo con los datos ingresados
por el usuario, este arreglo se debe mostrar de forma
desordenada, ya que luego se tendrá la opción de
mostrar el arreglo de forma ordenada recurriendo a
la recursividad.
• Ingresar los datos para el arreglo. La aplicación
debe permitir al usuario registrar los datos y mostrar
el arreglo de manera desordenada en pantalla.
• Mostrar el arreglo ingresado por el usuario y dar
la opción de ordenarlos de forma ascendente
implementando la recursividad.
Diseñar una Alternativa de Solución.
1. [Link] = new [Link]();
2. [Link] = new [Link]();
3. [Link] = new [Link]();
4. [Link] = new [Link]();
5. [Link] = new [Link]();
6. [Link] = new [Link]();
7. [Link] = new [Link]();
8. [Link] = new [Link]();
5
Figura 1.
Crear Código
using System;
using [Link];
namespace Arreglos
{
public partial class ARRAY : Form
{
private string[] arreglo;
public ARRAY()
{
InitializeComponent();
}
private void btnIngresar_Click(object sender, EventArgs e)
{
string entrada = [Link];
arreglo = [Link](new[] { ' ' },
[Link]);
MostrarArregloDesordenado();
}
private void MostrarArregloDesordenado()
{
[Link]();
[Link](arreglo);
}
private void btnOrdenar_Click(object sender, EventArgs e)
{
if (arreglo != null)
{
OrdenarArreglo(0, [Link] - 1);
MostrarArregloOrdenado();
}
else
{
[Link]("Por favor, ingresa un arreglo antes de
intentar ordenarlo.", "Error", [Link],
[Link]);
6
}
}
private void OrdenarArreglo(int izquierda, int derecha)
{
if (izquierda < derecha)
{
int indicePivote = Particionar(izquierda, derecha);
OrdenarArreglo(izquierda, indicePivote - 1);
OrdenarArreglo(indicePivote + 1, derecha);
}
}
private int Particionar(int izquierda, int derecha)
{
string pivote = arreglo[derecha];
int i = izquierda - 1;
for (int j = izquierda; j < derecha; j++)
{
if ([Link](arreglo[j], pivote,
[Link]) <= 0)
{
i++;
Intercambiar(i, j);
}
}
Intercambiar(i + 1, derecha);
return i + 1;
}
private void Intercambiar(int i, int j)
{
string temp = arreglo[i];
arreglo[i] = arreglo[j];
arreglo[j] = temp;
}
private void MostrarArregloOrdenado()
{
[Link]();
[Link](arreglo);
}
}
}
Utilizamos un TextBox “2” que se encarga de
mostrar números, símbolos o textos que se muestran
en pantalla para la visualización del usuario, también
implementamos, además del Label “1,5,6” para
mostrar mensajes tipo texto, luego ListBox “7,8”
7
para mostrar el arreglo de todos los datos ingresados
por el usuario, por último, para ejecutar cada acción,
Ingresar y Ordenar utilizamos Button “3,4” para
ejecutar las acciones ya mencionadas anteriormente.
Probar y Depurar
Una vez terminado el desarrollo del programa,
procedemos a documentar nuestros resultados.
Figura 2.
Se ingresan los datos para el arreglo en este caso
pueden ser alfanuméricos.
Figura 3.
Se ordena el arreglo de forma ascendente
implementando recursividad.
8
Pasos de la Solución del Enunciado 2
Análisis del problema.
El problema plantea la necesidad de diseñar un
programa utilizando Windows Forms en C# para
registrar una lista de actividades del uso de
videojuegos. A continuación, se realiza un análisis
del problema.
Registrar la lista de Videojuegos: Se debe permitir al
usuario ingresar el nombre del videojuego,
adicionalmente se le debe permitir al usuario indicar
sí perdió o gano en dicho videojuego, para ellos
utilizaremos la herramienta de Windows Forms
RadioButton. La fecha quedar establecida a través
de la herramienta DateTimePicker. Estos datos
deben almacenarse en una estructura de datos, como
una lista o un arreglo.
Se requiere una interfaz de usuario que permita
ingresar los datos y registrarlos en la lista de los
videojuegos. Pueden utilizarse controles de
Windows Forms como: TextBoxes, Buttons,
RadioButtons y DataGridView para capturar los
datos del usuario.
Registrar videojuegos: Se pide al usuario el nombre
del videojuego, indicar si perdió (lose, que significa
perder en inglés) o gano (win, ganar en inglés). Para
esto último solo hace falta hacer clic en Lose o Win.
En nuestro algoritmo creamos una clase llamada
Imputs (insumos en inglés) en la que le atribuimos
algunos datos del programa como nombre del
9
videojuego, fecha, puntos y el resultado (gano o
perdió). Todo esto con el fin de mantener nuestro
código más legible y posiblemente reutilizarlo en
otro proyecto.
Botones. En nuestra interfaz gráfica creamos 5
botones (guardar, quitar, quitar último, salir y
guardar datos) cada una con una funcionalidad
distinta que se explicara más a detalle en esta parte
del documento.
Diseñar una Alternativa de Solución
Primero diseñaremos la estructura grafica del
formulario para que respectivamente se coloque los
datos correspondientes. Para este proyecto
decidimos, al limón, utilizar
“Registro_de_videojuegos” como namespace.
Figura 4.
10
En el cuadro, emplear TextBoxes: Para ingresar
el nombre del videojuego.
Para la fecha emplear DateTimePicker.
Con RadioButton estableceremos si el usuario
perio o gano con la propiedad Checked del
RadioButton. para seleccionar la clase de la
mascota y Dueño, cona yuda del “Button” para
registrarlos.
Por cada Texbox emplear un “Name” que esté
deacuerdo a su uso:
Figura 5.
Para poder establecer una forma ordenada de
los datos se usará la herramienta, del cuadro
de herramientas, “DataGridView”para
registrar los datos correspondientes de la lista.
Figura 6.
11
Crear Código
using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using Microsoft.Win32;
namespace Registro_de_Videojuegos
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
List<Imputs> lista = new List<Imputs>();
public int puntaje = 0;
int totalpuntaje = 0;
private void pictureBox1_Click(object sender, EventArgs e)
{
private void dateTimePicker1_ValueChanged(object sender, EventArgs
e)
{
private void dataGridView2_CellContentClick(object sender,
DataGridViewCellEventArgs e)
{
private void label1_Click(object sender, EventArgs e)
{
private void label2_Click(object sender, EventArgs e)
{
private void textBox1_TextChanged(object sender, EventArgs e)
12
{
private void radioButton2_CheckedChanged(object sender, EventArgs e)
{
private void radioButton1_CheckedChanged(object sender, EventArgs e)
{
private void button1_Click(object sender, EventArgs e)
{
if ([Link] == "")
{
[Link](btn_agregar, "Por favor llene el campo nombre
de videojuego");
}
else
{
[Link](btn_agregar, "");
}
if (![Link] || ![Link])
{
[Link](btn_agregar, "De clic en uno de los
resultados");
}
Imputs imputs = new Imputs();
if ([Link])
{
puntaje = 100;
[Link] = "VICTORIA";
}
if ([Link])
{
puntaje = -20;
[Link] = "DERROTA";
}
else
{
puntaje += 0;
[Link] = "";
}
Puntajes puntajes = new Puntajes();
[Link] = [Link];
[Link] = [Link]();
[Link] = [Link];
13
[Link](imputs);
[Link] = null;
[Link] = lista;
limpiarData();
totalpuntaje = 0;
foreach (Imputs item in lista)
{
int puntos;
if ([Link]([Link], out puntos))
{
totalpuntaje += puntos;
}
}
if (totalpuntaje <= 0)
{
totalpuntaje= 0;
}
[Link] = [Link]();
}
private void button2_Click(object sender, EventArgs e)
{
if ([Link] > 0)
{
foreach (DataGridViewRow row in [Link])
{
// Obtener el índice de la fila seleccionada
int index = [Link];
// Obtener el elemento Imputs seleccionado
Imputs elemento = lista[index];
// Restar los puntos del elemento eliminado de
totalpuntaje
if ([Link]([Link], out int puntos))
{
totalpuntaje -= puntos;
}
// Eliminar el elemento de la lista
[Link](index);
}
// Actualizar la fuente de datos del DataGridView
[Link] = null;
[Link] = lista;
// Mostrar el nuevo totalpuntaje en el TextBox
[Link] = [Link]();
}
}
14
Probar y Depurar
En el momento de registrar para el nombre del
video juego, es importante que ingrese los
datos completos y no dejarlos vacíos ya que
sería absurdo,por ello se emplea la
herramienta ErrorProvider el cual nos
mostrara un mensaje indicando que faltan
completar los campos. De la misma forma
saltara un mensaje indicando que presione clic
en uno de los resultados (win o lose), caso
contrario los espacios se llenaran en blanco y
el puntaje será de cero.
Figura 7.
15
Resumir los temas utilizados
Enunciado 1
Espacios de nombres (Namespaces): El programa utiliza
el espacio de nombres [Link], que
proporciona clases para crear aplicaciones de Windows
Forms, como controles, formularios y cuadros de
diálogo.
Clase Form: La clase ARRAY es una clase derivada de la
clase Form de Windows Forms. Esta clase representa
una ventana de aplicación y contiene los controles y la
lógica asociados con ella.
Control TextBox: El programa utiliza el control TextBox
para permitir al usuario ingresar texto sin formato. El
TextBox se utiliza para editar texto en un formulario.
Control Button: Se utilizan botones (Button) para
realizar acciones específicas en el programa, como
insertar números, ordenar listas, encontrar números y
eliminar números.
Control Label: Los controles de etiqueta (Label) se
utilizan para mostrar texto en la interfaz de usuario.
Pueden mostrar el contenido de variables, campos o
mensajes en el programa.
Control Name: En el contexto del programa, el término
"control Name" parece referirse a una secuencia de
caracteres derivada del nombre de un contribuyente
utilizado por el IRS (Servicio de Impuestos Internos de
Estados Unidos) para procesar declaraciones de
impuestos.
Arreglos. El programa emplea esta herramienta para
manipular los datos proporcionados del usuario en c#.
16
Enunciado 2
Interfaz de usuario: Se utilizan controles de
interfaz de usuario como pictureBox,
dateTimePicker, dataGridView y label para mostrar
y capturar información del usuario.
Validación de entrada: Se verifica que el campo
txtnombre no esté vacío y que se haya seleccionado
una opción de resultado (rdbwin o rdblose) antes de
agregar un elemento a la lista.
Manipulación de objetos: Se crean instancias de la
clase Imputs y se asignan valores a sus propiedades
según las selecciones del usuario.
Cálculos y manipulación de datos: Se realiza un
cálculo de puntaje (puntaje) basado en la selección
del resultado (rdbwin o rdblose) y se suma/resta al
puntaje total (totalpuntaje). Se actualiza la propiedad
Puntos del objeto Imputs con el valor del puntaje.
Almacenamiento y visualización de datos: Se
utiliza un List<Imputs> para almacenar los objetos
Imputs y se muestra la lista en un dataGridView.
Además, se actualiza el campo txttotal con el puntaje
total.
Eliminación de elementos: Al hacer clic en button2,
se eliminan las filas seleccionadas en el dataGridView y
se actualiza el puntaje total y la lista de Imputs.
17
Documentar código fuente
Enunciado 1
Teniendo en cuenta lo anteriormente expuesto
pasamos a presentar la solución mediante un código
desarrollado en el entorno de programación
“VisualStudio” utilizando la clase “Windows
Forms”.
Se define una clase llamada ARRAY que hereda de la
clase Form, lo que significa que esta clase representa una
ventana de la aplicación.
Figura 8.
Se declara el arreglo de tipo string llamado arreglo como una variable de la
clase arreglo.
Figura 9.
Se define el constructor de la clase FormListaNumeros, que se llama cuando se
crea una nueva instancia del formulario. Dentro del constructor, se inicializa la
lista numeros creando un nuevo arreglo.
Figura 10.
El método “btnIngresar_Click” es el manejador de eventos para el evento Click del
botón "Ingresar". Este evento toma el texto ingresado en el cuadro de texto
“txtArreglo”, lo divide en partes separadas por espacios en blanco y lo almacena
18
en el arreglo. Luego, llama al método “MostrarArregloDesordenado” para
mostrar el arreglo en un “ListBox” llamado “listBoxDesordenado”.
Figura 11.
El método “MostrarArregloDesordenado” para mostrar el arreglo en el ListBox.
Este método borra los elementos existentes en el (“ListBox” &
“listBoxDesordenado”) y luego agrega cada elemento del arreglo a ese “ListBox”.
Figura 12.
El método “btnOrdenar_Click” es el manejador de eventos para el evento “Click”
del botón “Ordenar”. Al ser activado, este método realiza las siguientes acciones:
primero, verifica si el arreglo no es nulo. Si el arreglo no es nulo, procede a llamar
al método “OrdenarArreglo” para ordenarlo utilizando el algoritmo de ordenación
rápida (Quicksort). Una vez ordenado el arreglo, se invoca al método
“MostrarArregloOrdenado” para mostrar los elementos ordenados en un control
de tipo “ListBox” denominado “listBoxOrdenado”. Por otro lado, si el arreglo
resulta ser nulo, se muestra un mensaje de error mediante el uso de la función
“MessageBox”.
Figura 13.
19
El método “OrdenarArreglo” se utiliza para realizar una organización rápida del
arreglo. Este método emplea la recursión para dividir el arreglo en subarreglos
más pequeños y ordenarlos. Para lograrlo, utiliza el método “Particionar” para
determinar el índice del pivote y luego llama de forma recursiva a
"OrdenarArreglo" para ordenar los subarreglos izquierdo y derecho del pivote. De
esta manera, se logra ordenar el arreglo completo mediante la técnica de
ordenación rápida.
Figura 14.
El método “Particionar” se encarga de realizar la partición del arreglo. En este
método, se selecciona un elemento pivote del arreglo (en este caso, el último
elemento) y se reorganizan los elementos del arreglo de tal manera que los
elementos menores al pivote se encuentren a su izquierda y los elementos
mayores se sitúen a su derecha. Durante este proceso de partición, se utiliza el
método "Intercambiar" para intercambiar elementos dentro del arreglo.
Figura 15.
20
El método “Intercambiar” se utiliza para intercambiar elementos dentro de un
arreglo. Este método realiza el intercambio entre los elementos en las posiciones
“i” y “j” del arreglo.
Figura 16.
El método “MostrarArregloOrdenado” muestra el arreglo ordenado en un control
llamado “ListBox”. Este método elimina los elementos previos del control
“ListBox” denominado “listBoxOrdenado” y luego añade cada elemento del
arreglo ordenado a dicho control.
Figura 17.
Enunciado 2
Con este botón elimínanos la fila seleccionada que
queremos eliminar de la tabla.
Figura 18.
21
Como podemos notar la última fila seleccionada mediante el puntero Figura 19.
fue eliminada pulsando el botón quitar.
Con el botón “salir” cerramos la aplicación.
private void button3_Click(object sender, EventArgs e)
{
[Link]();
}
private void label4_Click(object sender, EventArgs e)}
{
private void rdbwin_MouseClick(object sender, MouseEventArgs e)
{
private void rdblose_MouseClick(object sender, MouseEventArgs e)
{
“Este método elimina los caracteres introducidos en el campo de nombre de
videojuego.
public void limpiarData()
{
[Link] = [Link];
22
private void button1_Click_1(object sender, EventArgs e)
{
if ([Link] > 0)
{
// Obtener el último elemento de la lista
Imputs ultimoElemento = lista[[Link] - 1];
// Restar los puntos del último elemento eliminado de
totalpuntaje
if ([Link]([Link], out int puntos))
{
totalpuntaje -= puntos;
}
// Eliminar el último elemento de la lista
[Link]([Link] - 1);
// Actualizar la fuente de datos del DataGridView
[Link] = null;
[Link] = lista;
// Mostrar el nuevo totalpuntaje en el TextBox
[Link] = [Link]();
}
Con el botón “quitar ultimo” eliminamos las ultima que se ingresó.
Figura 20.
23
Como se puede evidenciar la última se eliminó al pulsar clic en el
botón “quitar ultimo”.
El botón Guardar Datos nos permite guardar los datos de la tabla en
un archivo txt. La dirección la especificara el usuario final.
private void GuardarDatosEnArchivo()
{
using (StreamWriter writer = new
StreamWriter("base_de_informacion.txt"))
{
foreach (Imputs item in lista)
{
string linea =
$"{[Link]}\t{[Link]}\t{[Link]}\t{[Link]}";
[Link](linea);
}
}
}
private void button2_Click_1(object sender, EventArgs e)
{
GuardarDatosEnArchivo();
}
}
}
Conclusiones y Recomendaciones
La utilidad del manejo de archivos.
Su utilidad es para implementar el intercambio de datos (lectura y
escritura) entre fuentes externas (archivos y/o entrada y salida) y un
programa (en un lenguaje orientado a objetos).
Los programas necesitan comunicarse con su entorno, tanto para
obtener datos e información que deben procesar, como para devolver
los resultados obtenidos. El manejo de archivos se realiza a través de
streams o flujos de datos desde una fuente hacia un repositorio. La
fuente inicia el flujo de datos, por lo tanto, se conoce como flujo de
datos de entrada. El repositorio termina el flujo de datos, por lo
tanto, se conoce como flujo de datos de salida. Es decir, tanto la
fuente como el repositorio son nodos de flujos de datos.
Flujos de bytes: las clases derivadas de InputStream (para
lectura) y de OutputStream (para escritura), las cuales manejan
los flujos de datos como stream de bytes.
24
Flujos de caracteres: las clases derivadas de Reader (para
lectura) y Writer (para escritura), las cuales manejan stream de
caracteres.
(Angélica Nakayama C. & Jorge A. Solano Gálvez. (2020) pg1-2
ppt 1;3;8;9)
Cuándo aplicar recursividad.
La recursividad se debe usar cuando no exista una solución iterativa
simple. Muchas veces es posible dividir un problema en
subproblemas más pequeños, generalmente del mismo tamaño,
resolver los subproblemas y entonces combinar sus soluciones para
obtener la solución del problema original. (Autor anónimo. (2022).
pg 20 ppt 3, pg 21 ppt 1)
Si tenemos un problema de tamaño N y este puede ser dividido en
problemas de menor tamaño, pero cuya solución es similar a la del
problema original, conocidas las soluciones de estos problemas de
tamaño menor, podemos obtener la solución al problema de tamaño
N original a partir de estas soluciones más pequeñas. Los casos en
que el problema es tan pequeño que su solución es trivial se conocen
como casos base. (Pérez Peló, Sergio. (2021). pg 1 ppt 3)
Cuándo aplicar los métodos de ordenamiento.
Los métodos de ordenación son especialmente útiles para que los
datos que procesamos sean legibles por humanos y su procesamiento
se agilice. Para estructuras con pocos elementos, es más eficiente la
ordenación directa, ya que conlleva menor tiempo de ejecución.
(Autor anónimo. (2022). pg1 ppt 1)
Cuando se requiere hacer una cantidad considerable de búsquedas y
es importante el factor tiempo. (Escuela de Computación. (2021). pg
1-2 ppt 4; 8.)
Algoritmos de ordenamiento:
-Intercambio: El método “Intercambiar” se utiliza para intercambiar
elementos dentro de un arreglo. Este método realiza el intercambio
entre los elementos en las posiciones “i” y “j” del arreglo.
25
Figura 21.
-QuickSort: El método “btnOrdenar_Click” es el manejador de
eventos para el evento “Click” del botón “Ordenar”. Al ser activado,
este método realiza las siguientes acciones: primero, verifica si el
arreglo no es nulo. Si el arreglo no es nulo, procede a llamar al
método “OrdenarArreglo” para ordenarlo utilizando el algoritmo de
ordenación rápida (Quicksort). Una vez ordenado el arreglo, se
invoca al método “MostrarArregloOrdenado” para mostrar los
Figura 22.
elementos ordenados en un control de tipo “ListBox” denominado
“listBoxOrdenado”. Por otro lado, si el arreglo resulta ser nulo, se
muestra un mensaje de error mediante el uso de la función
“MessageBox”.
Bibliografía:
Angélica Nakayama C. & Jorge A. Solano Gálvez. (2020) Guía
práctica de estudio 11: Manejo de archivos. Archivo de
Investigación, pg1-2 ppt 1;3;8;9
[Link]
Autor aninimo. (2022) Análisis de algoritmos: Recursividad. Revista
de información, pg 20 ppt 3 ,pg 21 ppt 1
[Link]
Pérez Peló, Sergio. (2021) Recursividad: ¿Cuándo debo utilizarla?.
Articulo Informático, pg 1 ppt 3
[Link]
26
Autor anonimo. (2022) Métodos de ordenación. Revista de
información, pg1 ppt 1
[Link]
programacion-2/metodos-de-
ordenacion#:~:text=Los%20m%C3%A9todos%20de%20ordenaci%
C3%B3n%20son,maneras%20de%20realizar%20esta%20ordenaci%
C3%B3n.
Escuela de Computación. (2021) Métodos de Ordenamiento Parte 1.
Articulo de información, pg 1-2 ppt 4; 8.
[Link]
ingenieria/programacion-iv/2019/ii/[Link]
27