• Lunes 21 de Junio de 2021, 03:25

Autor Tema:  Quicksort C#  (Leído 13738 veces)

Schakal

  • Nuevo Miembro
  • *
  • Mensajes: 2
    • Ver Perfil
Quicksort C#
« en: Domingo 8 de Agosto de 2004, 05:34 »
0
:hola:  hola amigos quisiera saber si alguien me puede ayudar, soy nuevo en lo que es programacion y me gustaria ver un ejemplo de quicksort en c# solo quiero ver algo simple, un ejemplo en el que se ordenden 5 numeros de mayor a menor, el problema esque no se como codificar correctamente el algoritmo, espero que me puedan ayudar. GRACIAS  :ph34r:

What_s_up

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Quicksort C#
« Respuesta #1 en: Domingo 29 de Mayo de 2005, 07:24 »
0
Espero que este ejemplo te sirva de ayuda :
Saludos ...  ;)

Código: Text
  1.  
  2. //////////////////////////////////////////////////////////////////////////////
  3. // Administración de una Lista de Alumnos
  4. // ======================================
  5. // Ejemplo de uso de 2 algoritmos de búsqueda y 2 de ordenamiento, incluyendo QuickSort
  6. //
  7. //////////////////////////////////////////////////////////////////////////////
  8. using System;
  9.  
  10.  
  11. namespace OrdyBusqueda1
  12. {
  13.  
  14.   class Alumno
  15.   {
  16.     string nombre;
  17.     float nota;
  18.  
  19.     public Alumno(string v1, float v2) { nombre = v1; nota = v2; }
  20.  
  21.     public float Nota { get { return (nota); } }
  22.     public string Nombre { get { return (nombre); } }
  23.  
  24.     // Se reemplaza el método ToString para luego usar directamente el objecto Alumno en un WriteLine.
  25.     public override string ToString()
  26.     {
  27.       return (nombre + ": " + nota.ToString());
  28.     }
  29.   }
  30.  
  31.   class ListaAlumnos
  32.   {
  33.     Alumno[] lista;
  34.  
  35.     public ListaAlumnos(int cantidad)
  36.     {
  37.       // Listas de nombres y aplellidos para armar los nombres aleatoriamente
  38.       string[] nombres = { "Juan", "Pedro", "Jorge", "Oscar", "Manuel", "Humberto", "Cecilia", "Andrea", "Alejandra", "Paula" };
  39.       string[] apellidos = { "Pérez", "Soto", "González", "Ahumada", "Muñoz", "Cáceres", "Araneda" };
  40.       Random rn = new Random(DateTime.Now.Millisecond);
  41.  
  42.       lista = new Alumno[cantidad];  // Se dimensiona de acuerdo a la cantidad indicada
  43.       for (int i = 0; i < cantidad; i++)
  44.       {
  45.         // Se crea un nuevo alumno generándole un nombre completo aleatorio y una nota también aleatoria
  46.         string nomcompleto = nombres[rn.Next(0, nombres.Length)] + " " + apellidos[rn.Next(0, apellidos.Length)];
  47.         lista[i] = new Alumno(nomcompleto, (float)rn.Next(10, 71) / 10);
  48.       }
  49.     }
  50.  
  51.     //////////////////////////////////////////////////////////////////////////////////
  52.     // ALGORITMO: Ordenamiento Recursivo por Selección (ordenado por nota)
  53.     public void OrdenarRecursivo(int cantidad)
  54.     {
  55.       if (cantidad <= 1) return;
  56.       int mayor = 0;
  57.  
  58.       // Busca el mayor de todos
  59.       for (int i = 1; i < cantidad; i++)
  60.         if (lista[i].Nota > lista[mayor].Nota)
  61.           mayor = i;
  62.  
  63.       if (mayor < cantidad - 1)
  64.       {
  65.         Alumno aux = lista[cantidad - 1];
  66.         lista[cantidad - 1] = lista[mayor];
  67.         lista[mayor] = aux;
  68.       }
  69.       OrdenarRecursivo(cantidad - 1);
  70.     }
  71.  
  72.  
  73.     //////////////////////////////////////////////////////////////////////////////////
  74.     // ALGORITMO: Ordenamiento Recursivo QuickSort, que utiliza método auxiliar: Particionar()
  75.     int Particionar(int desde, int hasta)
  76.     {
  77.       int izq = desde-1; // Se comienza de uno menos, para asegurar el do-while()
  78.       int der = hasta+1; // Idem
  79.       Alumno pivote = lista[(desde + hasta) / 2];
  80.  
  81.       Console.WriteLine("Particionando: {0} {1}", desde, hasta);
  82.       while (izq < der)
  83.       {
  84.         do izq++; while (pivote.Nota > lista[izq].Nota);
  85.         do der--; while (pivote.Nota < lista[der].Nota);
  86.         if (izq < der)
  87.         {
  88.           Alumno aux = lista[der];
  89.           lista[der] = lista[izq];
  90.           lista[izq] = aux;
  91.         }
  92.         Console.WriteLine(".{0}/{1}.{2} y {3},{4}", izq, der, pivote.Nota, lista[izq].Nota, lista[der].Nota);
  93.       }
  94.       Console.WriteLine(".");
  95.       return (der);
  96.     }
  97.  
  98.  
  99.     void QuickSort(int desde, int hasta)
  100.     {
  101.       if (desde < hasta)
  102.       {
  103.         int p = Particionar(desde, hasta);
  104.         QuickSort(desde, p);
  105.         QuickSort(p + 1, hasta);
  106.       }
  107.     }
  108.  
  109.  
  110.     //////////////////////////////////////////////////////////////////////////////////
  111.     // ALGORITMO: Búsqueda Lineal Recursiva
  112.     int BuscarRec(string nombre, int cantidad)
  113.     {
  114.       if (cantidad == 0) return (-1);
  115.       if (lista[cantidad - 1].Nombre == nombre) return (cantidad - 1);
  116.       else return (BuscarRec(nombre, cantidad - 1));
  117.     }
  118.  
  119.     //////////////////////////////////////////////////////////////////////////////////
  120.     // ALGORITMO: Búsqueda Binaria Recursiva - asume que la lista está ordenada alfabéticamente
  121.     int BuscarBin(string nombre, int desde, int hasta)
  122.     {
  123.       if (desde > hasta) return (-1);
  124.       int pm = (desde + hasta) / 2;
  125.       if (lista[pm].Nombre == nombre) return (pm);
  126.       if (lista[pm].Nombre.CompareTo(nombre) < 0) return (BuscarBin(nombre, pm + 1, hasta));
  127.       else return (BuscarBin(nombre, desde, pm - 1));
  128.     }
  129.  
  130.     //////////////////////////////////////////////////////////////////////////////////
  131.     // ALGORITMO: Búsqueda Binaria Recursiva - asume que la lista está ordenada por nota
  132.     int BuscarBin(float nota, int desde, int hasta)
  133.     {
  134.       if (desde > hasta) return (-1);
  135.       int pm = (desde + hasta) / 2;
  136.       if (lista[pm].Nota == nota) return (pm);
  137.       if (lista[pm].Nota < nota) return (BuscarBin(nota, pm + 1, hasta));
  138.       else return (BuscarBin(nota, desde, pm - 1));
  139.     }
  140.  
  141.     // Métodos genéricos de Búsqueda y Ordenamiento: PUBLICOS
  142.     // En ellos se puede reemplazar por el algoritmo que se seleccione
  143.     public int Buscar(string nombre) { return (BuscarBin(nombre, 0, lista.Length - 1)); }
  144.     public int Buscar(float nota) { return (BuscarBin(nota, 0, lista.Length - 1)); }
  145.  
  146.     public void Ordenar() { QuickSort(0, lista.Length - 1); }
  147.  
  148.     public void Mostrar()
  149.     {
  150.       for (int i = 0; i < lista.Length; i++)
  151.         Console.WriteLine(lista[i]);
  152.     }
  153.   }
  154.  
  155.  
  156.   class MainApp
  157.   {
  158.     static void Main()
  159.     {
  160.       ListaAlumnos l = new ListaAlumnos(30);
  161.       l.Mostrar(); Console.WriteLine("--------------------");
  162.  
  163.  
  164.       l.Ordenar();
  165.       l.Mostrar();
  166.  
  167.       // Se implementa búsqueda por nota, ya que la lista está ordenada por nota
  168.       Console.Write("Ingrese nota a buscar: ");
  169.       float nota = float.Parse(Console.ReadLine());
  170.       int pos = l.Buscar(nota);
  171.       if (pos >= 0) Console.WriteLine("LO ENCONTRE");
  172.       else Console.WriteLine("NO");
  173.       Console.ReadLine();
  174.     }
  175.   }
  176.  
  177. }
  178.  
  179.  

kota

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Quicksort C#
« Respuesta #2 en: Miércoles 18 de Octubre de 2006, 08:33 »
0
Cita de: "Schakal"
:hola:  hola amigos quisiera saber si alguien me puede ayudar, soy nuevo en lo que es programacion y me gustaria ver un ejemplo de quicksort en c# solo quiero ver algo simple, un ejemplo en el que se ordenden 5 numeros de mayor a menor, el problema esque no se como codificar correctamente el algoritmo, espero que me puedan ayudar. GRACIAS  :ph34r:
te puedo ayudar pero yo programo en visual basic 6, ahy tu diras si te puedo ayudar

JuanK

  • Miembro de ORO
  • ******
  • Mensajes: 5393
  • Nacionalidad: co
    • Ver Perfil
    • http://juank.io
Re: Quicksort C#
« Respuesta #3 en: Miércoles 18 de Octubre de 2006, 14:22 »
0
Este post es de ahce mas de dos años, no vale la pena revivirlo.
[size=109]Juan Carlos Ruiz Pacheco
[/size]
Microsoft Technical Evangelist
@JuanKRuiz
http://juank.io