Propósito: Practicar la programación y uso de métodos que devuelven resultado en C# .NET, para ello, tu docente en línea te hará llegar las instrucciones necesarias, una vez que cuentes con ellas, sigue estos pasos Indicaciones: Analiza y resuelve el problema siguiente Por medio de arreglos e implementación de métodos resuelve los algoritmos de ordenamientos llamado Burbuja y Quick sort. Deberás de ordenar por lo menos 20 elementos guardándolos ya ordenados en un archivo de texto 1. Analiza el problema correspondiente e identifica las clases, objetos y estructuras de control requeridos para su resolución. 2. Crea un nuevo proyecto en el entorno consola de C# .NET, guárdalo con la nomenclatura Actividad4U3. 3. Declara la clase o las clases con la estructura indicada y crea los objetos asociados 4. Integra en tu programa los métodos que devuelven resultado indicados por tu docente en línea así como las variables, operaciones estructuras de control e instrucciones adecuadas para que funcione correctamente.
o Nota: El código debe contener el (los) método(s) por lo menos uno por algoritmo de ordenamiento más otro para guardar los valores ordenados, estos deben devolver valores, lo que indica que el resultado se debe imprimir dentro del método y debe utilizarse en su declaración el tipo de dato a regresar. 5. Ejecuta tu código de forma que muestre los resultados deseados y no contenga errores. 6. Documenta el programa con base en comentarios, indicando brevemente el procedimiento que se realiza en cada sección. 7. Incluye en un documento de texto por lo menos 3 ventanas de ejecución del programa con diferentes valores asignados a las variables declaradas y sus resultados. 8. Guarda la actividad en un archivo comprimido que contenga tanto el proyecto en C# como el documento de texto con las pantallas de ejecución (integra en este documento tus datos de identificación completos), con la nomenclatura DPRN1_U3_A4_XXYZ. Sustituye las XX por las dos primeras letras de tu primer nombre, la Y por la inicial de tu primer apellido y la Z por la inicial de tu segundo apellido.
Ordenamiento BURBUJA. En este método de ordenamiento se van comparando cada uno de los elementos del arreglo e ir moviendo el mayor elemento, hasta la última posición. Comenzando desde la posición cero. Ya acomodado el mayor elemento, continua encontrando y acomodando el segundo más grande comparando de nuevo a los elementos desde el inicio de la lista y así en ese orden hasta ordenar todos los elementos del arreglo, al hacer este procedimiento se vuelve menos eficiente, sin embargo es una de los métodos más usados en todos los lenguajes de programación. Algoritmo: INICIO ESCRIBIR = "M É T O D O S D E O R D E N A C I Ó N"; ESCRIBIR ("Método Burbuja"); ESCRIBIR ("Escriba el número 20 para continuar: "); LEER n llenar b = llenar(n); FIN INICIO //método llenar METODO llenar(int n) INICIO h = n; LEER vector //creando el archivo using (StreamWriter writer = new StreamWriter("D:\\Burbujas.txt", false)) INICIO
//recorrido del archivo PARA (int i = 0; i < vector.Length; i++)
ESCRIBIR ("ingrese valor número entero {0}: ", i + 1); LEER vector[i] FINPARA FIN //llamada a métodos burbujaa(); mostrar();
FIN //método de ordenación METODO burbujaa() INICIO PARA (int a = 1; a < vector.Length; a++)
PARA (int b = vector.Length - 1; b >= a; b--)
SI (vector[b - 1] > vector[b]),ENTONCES
t = vector[b - 1]; vector[b - 1] = vector[b]; vector[b] = t; FINSI FINPARA FINPARA FIN //método mostrar METODO mostrar() INICIO ESCRIBIR ("Vector ordenados en forma ascendente"); using (StreamWriter writer = new StreamWriter("D:\\Burbujas.txt", false))
INICIO PARA (int i = 0; i < vector.Length; i++)
ESCRIBIR (" " + "-"); ESCRIBIR (" " + vector[i]); ESCRIBIR (vector[i].ToString()); FINPARA Salida(); FIN LEERCONSOLA FIN //método salida METODO Salida() INICIO
ESCRIBIR ("\t ******************************************************************************"); ESCRIBIR ("\t ******* P R E S I O N E U N A T E C L A P A R A S A L I R ********"); ESCRIBIR ("\t *******************************************************************************");
FIN
FIN FIN FIN
Ventanas solución:
Ordenamiento Quick Sort. Actualmente es el método de ordenamiento más eficiente comparado con otros métodos de ordenamiento interno, tiene sus bases en el método de intercambio directo. Su autor C.A. Hoare lo nombro Quick sort.
Consiste en lo siguiente:
Tomar un elemento cualquiera, de una posición cualquiera del arreglo. Trata de ubicar a el elemento x en la posición correcta del arreglo, de tal manera que todos los elementos que se encuentren a la izquierda sean menores o iguales a el elemento x y todos los elementos que se encuentran a su derecha sean mayores o iguales a el elemento x.
Se repiten los pasos anteriores, pero ahora para los conjuntos de datos que se encuentran a la izquierda ya la derecha de la posición correcta del elemento x en el arreglo. Algoritmo:
INICIO
ESCRIBIR = "M É T O D O S D E O R D E N A C I O N"; ESCRIBIR ("Método Quick Sort"); ESCRIBIR ("Escriba el número 20 para continuar: “ ); LERR n llenar b = llenar(n);
CLASE llenar h = n; vector = int [h]; using (StreamWriter writer = new StreamWriter("D:\\QuickS.txt", false)) PARA (int i = 0; i < vector.Length; i++)
ESCRIBIR ("ingrese valor número entero {0}: ", i + 1); LEER vector[i]
quicksort(vector, 0, h - 1); mostrar(); private void quicksort(int[] vector, int primero, int ultimo) INICIO central = (primero + ultimo) / 2; pivote = vector[central]; i = primero; j = ultimo; HACER
MIENTRAS (vector[i] < pivote) i++; MIENTRAS (vector[j] > pivote) j--; SI (i <= j), ENTONCE int temp; temp = vector[i]; vector[i] = vector[j]; vector[j] = temp; i++; j--;
MIENTRAS (i <= j);
SI (primero < j), ENTONCES
quicksort(vector, primero, j);
SI (i < ultimo), ENTONCES
quicksort(vector, i, ultimo);
FIN private void mostrar() INICIO
ESCRIBIR ("Vector ordenados en forma ascendente"); using (StreamWriter writer = new StreamWriter("D:\\QuickS.txt", false)) INICIO PARA (int i = 0; i < vector.Length; i++)
ESCRIBIR (" " + "-"); ESCRIBIR (" " + vector[i]); ESCRIBIR (vector[i].ToString());
Salida();
LERR FIN FIN public static void Salida() INICIO
ESCRIBIR ("\t *******************************************************************************"); ESCRIBIR ("\t ******* P R E S I O N E U N A T E C L A P A R A S A L I R ********"); ESCRIBIR ("\t *******************************************************************************");
FIN FIN FIN
Ventanas solución:
Conclusiones:
Al estudiar los diferentes metodos de ordenación me di cuenta que todos son similares, sin embargo creo que se podrian encontrar un sinfín de ocaciones para usarlos, pero dentro de estos métodos se me facilito el metodo de busqueda de burbuja, aunque leyendo encuentro que es el menos practico, pues es el menos eficiente.
Fuentes de consulta: Ceballos, F (2007). Enciclopedia de Microsoft Visual C#, (2da Ed.). España: Ed. Alfaomega Ra-Ma. MSDN Microsoft (2012), Guía de programación en C#, recuperado de la siguiente Dirección http://msdn.microsoft.com/es-es/library/67ef8sbd(v=vs.80).aspx Ramírez, F (2007). Introducción a la programación. Algoritmos y su implementación En VB. NET, Java y C++, (2da. Ed). España: Alfaomega.
