/// <summary>
 /// Constructor de la clase.
 /// </summary>
 /// <param name="orden">Criterio de ordenación.</param>
 public Ordenación(Orden orden)
 {
     nComparaciones = 0;
     nIntercambios = 0;
     this.orden = orden;
     tiempoEjecución = new NanoTemporizador();
 }
Example #2
0
 /// <summary>
 /// Ordena el vector recibido mediante Insercción.
 /// </summary>
 /// <param name="vector">Vector a ordenar por el método.</param>
 public override void Ordenar(int[] vector)
 {
     int temp;
     int i, sup = vector.Length - 1;
     tiempoEjecución = new NanoTemporizador();
     tiempoEjecución.Start();
     for (int outer = 1; outer <= sup; outer++)
     {
         temp = vector[outer];
         i = outer;
         if (orden.CompareTo(Orden.Ascendente) == 0)
         {
             bool intercambio = false;
             while (i > 0 && vector[i - 1].CompareTo(temp) >= 0)
             {
                 intercambio = true;
                 vector[i] = vector[i - 1];
                 i -= 1;
                 nComparaciones++;
             }
             vector[i] = temp;
             if(intercambio)
                 nIntercambios++;
         }
         else
         {
             bool intercambio = false;
             while (i > 0 && vector[i - 1].CompareTo(temp) <= 0)
             {
                 intercambio = true;
                 vector[i] = vector[i - 1];
                 i -= 1;
                 nComparaciones++;
             }
             vector[i] = temp;
             if(intercambio)
                 nIntercambios++;
         }
     }
     tiempoEjecución.Stop();
 }
Example #3
0
 /// <summary>
 /// Ordena el vector recibido mediante Selección.
 /// </summary>
 /// <param name="vector">Vector que se va a ordenar.</param>
 public override void Ordenar(int[] vector)
 {
     int min;
     int temp;
     int sup = vector.Length - 1;
     tiempoEjecución = new NanoTemporizador();
     tiempoEjecución.Start();
     for (int i = 0; i <= sup; i++)
     {
         min = i;
         for (int j = i + 1; j <= sup; j++)
         {
             if (orden.Equals(Orden.Ascendente))
             {
                 if (vector[j].CompareTo(vector[min]) < 0)
                 {
                     min = j;
                     nIntercambios++;
                 }
             }
             else
             {
                 if (vector[j].CompareTo(vector[min]) > 0)
                 {
                     min = j;
                     nIntercambios++;
                 }
             }
             nComparaciones++;
         }
         temp = vector[i];
         vector[i] = vector[min];
         vector[min] = temp;
     }
     tiempoEjecución.Stop();
 }
        /// <summary>
        /// Hilo para la ordenación en función de los criterios establecidos.
        /// </summary>
        public void HiloOrdena()
        {
            Ordenación ord;
            NanoTemporizador nano = new NanoTemporizador();
            
            if (datosOrdenar.Algoritmo.CompareTo(Algoritmo.Insercion)==0)
            {
                
                for (int i = 0; i < listas.Count; i++)
                {
                    if (listas.ElementAt(i).ordenado.CompareTo(Ordenado.No) == 0)
                    {
                        ord = new Inserción(datosOrdenar.Criterio);
                        nano.Start();
                        listas.ElementAt(i).vectorD.Vector.CopyTo(listas.ElementAt(i).vectorO.Vector, 0);
                        ord.Ordenar((int[])listas.ElementAt(i).vectorO.Vector);
                        nano.Stop();
                        //asignar los valores derivados de la ordenacion a la lista.
                        Lista aux = listas.ElementAt(i);
                        aux.nComparaciones = ord.NComparaciones;
                        aux.nIntercambios = ord.NIntercambios;
                        aux.tiempo = nano.ElapsedMilliseconds;
                        aux.ordenado = Ordenado.Si;
                        System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)delegate()
                        {
                            listas.RemoveAt(i);
                            listas.Insert(aux.id, aux);
                        });
                    }
                }
            }
            else if (datosOrdenar.Algoritmo.CompareTo(Algoritmo.Seleccion) == 0)
            {
                
                for (int i = 0; i < listas.Count; i++)
                {
                    if (listas.ElementAt(i).ordenado.CompareTo(Ordenado.No) == 0)
                    {
                        ord = new Selección(datosOrdenar.Criterio);
                        nano.Start();
                        listas.ElementAt(i).vectorD.Vector.CopyTo(listas.ElementAt(i).vectorO.Vector, 0);
                        ord.Ordenar((int[])listas.ElementAt(i).vectorO.Vector);
                        nano.Stop();
                        //falta capturar los tiempos de ordenacion
                        Lista aux = listas.ElementAt(i);
                        aux.nComparaciones = ord.NComparaciones;
                        aux.nIntercambios = ord.NIntercambios;
                        aux.tiempo = nano.ElapsedMilliseconds;
                        aux.ordenado = Ordenado.Si;
                        System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)delegate()
                        {
                            listas.RemoveAt(i);
                            listas.Insert(aux.id, aux);
                        });
                    }
                    
                }
            }
            else
            {
                
                for (int i = 0; i < listas.Count; i++)
                {
                    if (listas.ElementAt(i).ordenado.CompareTo(Ordenado.No) == 0)
                    {
                        ord = new QuickSort(datosOrdenar.Criterio);
                        nano.Start();
                        listas.ElementAt(i).vectorD.Vector.CopyTo(listas.ElementAt(i).vectorO.Vector, 0);
                        ord.Ordenar((int[])listas.ElementAt(i).vectorO.Vector);
                        nano.Stop();
                        //falta capturar los tiempos de ordenacion
                        Lista aux = listas.ElementAt(i);
                        aux.nComparaciones = ord.NComparaciones;
                        aux.nIntercambios = ord.NIntercambios;
                        aux.tiempo = nano.ElapsedMilliseconds;
                        aux.ordenado = Ordenado.Si;
                        System.Windows.Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action)delegate()
                        {
                            listas.RemoveAt(i);
                            listas.Insert(aux.id, aux);

                        });
                    }
                }
            }
            refreshGrid();
            visibilidadBarra_Final();
        }
Example #5
0
 /// <summary>
 /// Ordena el vector mediante QuickSort.
 /// </summary>
 /// <param name="vector">Vector a ordenar.</param>
 public override void Ordenar(int[] vector)
 {
     tiempoEjecución = new NanoTemporizador();
     tiempoEjecución.Start();
     OrdenarAux(vector, 0, vector.Length - 1);
 }