Propsito:

Practicar la programacin y uso de mtodos que devuelven resultado en C# .NET, para ello, tu docente en lnea 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 implementacin de mtodos resuelve los algoritmos de ordenamientos llamado Burbuja y
Quick sort.

Debers de ordenar por lo menos 20 elementos guardndolos ya ordenados en un archivo de texto

1. Analiza el problema correspondiente e identifica las clases, objetos y estructuras de control requeridos para su
resolucin.

2. Crea un nuevo proyecto en el entorno consola de C# .NET, gurdalo 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 mtodos que devuelven resultado indicados por tu docente en lnea as como las variables,
operaciones estructuras de control e instrucciones adecuadas para que funcione correctamente.
o Nota: El cdigo debe contener el (los) mtodo(s) por lo menos uno por algoritmo de ordenamiento ms otro para
guardar los valores ordenados, estos deben devolver valores, lo que indica que el resultado se debe imprimir dentro
del mtodo y debe utilizarse en su declaracin el tipo de dato a regresar.

5. Ejecuta tu cdigo 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
seccin.

7. Incluye en un documento de texto por lo menos 3 ventanas de ejecucin 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 ejecucin (integra en este documento tus datos de identificacin 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 mtodo de ordenamiento se van comparando cada uno de los elementos del arreglo e ir
moviendo el mayor elemento, hasta la ltima posicin. Comenzando desde la posicin cero. Ya
acomodado el mayor elemento, continua encontrando y acomodando el segundo ms 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 mtodos ms usados en todos los lenguajes de programacin.
Algoritmo:
INICIO
ESCRIBIR = "M T O D O S D E O R D E N A C I N";
ESCRIBIR ("Mtodo Burbuja");
ESCRIBIR ("Escriba el nmero 20 para continuar: ");
LEER n
llenar b = llenar(n);
FIN
INICIO
//mtodo 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 nmero entero {0}: ", i + 1);

LEER vector[i]
FINPARA
FIN
//llamada a mtodos
burbujaa();
mostrar();

FIN
//mtodo de ordenacin
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
//mtodo 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
//mtodo 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 solucin:
Ordenamiento Quick Sort.
Actualmente es el mtodo de ordenamiento ms eficiente comparado con otros mtodos de
ordenamiento interno, tiene sus bases en el mtodo de intercambio directo. Su autor C.A. Hoare lo
nombro Quick sort.

Consiste en lo siguiente:

Tomar un elemento cualquiera, de una posicin cualquiera del arreglo.

Trata de ubicar a el elemento x en la posicin 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 posicin 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 ("Mtodo Quick Sort");
ESCRIBIR ("Escriba el nmero 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 nmero 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 solucin:
 Conclusiones:

Al estudiar los diferentes metodos de ordenacin me di cuenta que todos son similares, sin embargo
creo que se podrian encontrar un sinfn de ocaciones para usarlos, pero dentro de estos mtodos
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.). Espaa: Ed.
Alfaomega Ra-Ma.
MSDN Microsoft (2012), Gua de programacin en C#, recuperado de la siguiente
Direccin http://msdn.microsoft.com/es-es/library/67ef8sbd(v=vs.80).aspx
Ramrez, F (2007). Introduccin a la programacin. Algoritmos y su implementacin
En VB. NET, Java y C++, (2da. Ed). Espaa: Alfaomega.