• Jueves 2 de Mayo de 2024, 08:16

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - The_Reaper22

Páginas: [1]
1
C# / Animación para métodos de ordenación
« en: Viernes 15 de Octubre de 2010, 12:47 »
Tengo que desarrollar una aplicación que visualice cómo se comportan los diferentes algoritmos de ordenación, y ando un poco perdido, porque no sé me ocurre el modo de realizar esto. La idea sería realizar una animación con gráficos de barras animadas; de modo que se visualicen los intercambios, comparaciones... Tenía idea de trabajar con WPF, no sé si alguien podría orientarme sobre el modo de poder conseguirlo con WPF.

Muchas gracias. Un saludo.

2
C# / Re: Trabajar con arrays de distintos tipos de datos(C#)
« en: Viernes 24 de Septiembre de 2010, 20:40 »
He conseguido hacer funcionar el programa, combinando vuestras ideas, mil gracias. Pero pienso que no está demasiado optimizado... Mi idea sería no utilizar los métodos estáticos en cada algoritmo de ordenación como en el código que me adjuntó tannke, y hacer una clase Ordenación<Tip> que sea clase ancestro de burbuja, inserción, selección.... de modo que no tenga que hacer una llamada distinta para cada algoritmo, y mediante polimorfismo con objeto tipo Ordenación<Tip> pueda instanciar cualquiera de sus descendientes; burbuja, inserción....Las clases que contienen los métodos de ordenación están implementadas tal y como está en el ejemplo de tannke.  Mi main tiene el siguiente aspecto de momento:

Código: C#
  1. static void Main(string[] args)
  2.         {
  3.             int opcAlgoritmo,tam;
  4.             string tipo;            
  5.             ProcesadorDatos datosAOrdenar;
  6.             int[] vectorInt=null;
  7.             double[] vectorDouble=null;
  8.             char[] vectorChar=null;
  9.             char función;
  10.             do
  11.             {
  12.                 NanoTemporizador temporizador = new NanoTemporizador();
  13.                 opcAlgoritmo = MenúAlgoritmo();
  14.                 if (opcAlgoritmo != 8)
  15.                 {
  16.                     tipo = MenúTipo();
  17.                     tam = MenúTamaño();
  18.                     datosAOrdenar = new ProcesadorDatos(tam, tipo);
  19.                     datosAOrdenar = MenúModo(tipo, tam);
  20.                     función = MenúFunción();
  21.                     //creamos el array en función del tipo
  22.                     if (tipo.CompareTo("int") == 0)
  23.                     {
  24.                         vectorInt = new int[tam];
  25.                         datosAOrdenar.listaToArray(vectorInt);
  26.                     }
  27.                     else if (tipo.CompareTo("char") == 0)
  28.                     {
  29.                         vectorChar = new char[tam];
  30.                         datosAOrdenar.listaToArray(vectorChar);
  31.                     }
  32.                     else
  33.                     {
  34.                         vectorDouble = new double[tam];
  35.                         datosAOrdenar.listaToArray(vectorDouble);
  36.                     }
  37.                     switch (opcAlgoritmo)
  38.                     {
  39.                         //Caso de la burbuja
  40.                         case 1:
  41.                             if (tipo.CompareTo("int") == 0)
  42.                             {
  43.                                 temporizador.Start();
  44.                                 if (función.CompareTo('A') == 0)
  45.                                     Burbuja<int>.Ordenar(vectorInt, Gener.IntAscendente);
  46.                                 else
  47.                                     Burbuja<int>.Ordenar(vectorInt, Gener.IntDescendente);
  48.                                 temporizador.Stop();
  49.                                 Burbuja<int>.Mostrar(vectorInt);
  50.                             }
  51.                             else if (tipo.CompareTo("char") == 0)
  52.                             {
  53.                                 temporizador.Start();
  54.                                 if (función.CompareTo('A') == 0)
  55.                                     Burbuja<char>.Ordenar(vectorChar, Gener.CharAscendente);
  56.                                 else
  57.                                     Burbuja<char>.Ordenar(vectorChar, Gener.CharDescendente);
  58.                                 temporizador.Stop();
  59.                                 Burbuja<char>.Mostrar(vectorChar);
  60.                             }
  61.                             else
  62.                             {
  63.                                 temporizador.Start();
  64.                                 if (función.CompareTo('A') == 0)
  65.                                     Burbuja<double>.Ordenar(vectorDouble, Gener.DoubleAscendente);
  66.                                 else
  67.                                     Burbuja<double>.Ordenar(vectorDouble, Gener.DoubleDescendente);
  68.                                 temporizador.Stop();
  69.                                 Burbuja<double>.Mostrar(vectorDouble);
  70.                             }
  71.                             break;
  72.  
  73.                         //Caso de la burbuja bidireccional
  74.                         case 2:
  75.                             if (tipo.CompareTo("int") == 0)
  76.                             {
  77.                                 temporizador.Start();
  78.                                 if (función.CompareTo('A') == 0)
  79.                                     BurbujaBidireccional<int>.Ordenar(vectorInt, Gener.IntAscendente);
  80.                                 else
  81.                                     BurbujaBidireccional<int>.Ordenar(vectorInt, Gener.IntDescendente);
  82.                                 temporizador.Stop();
  83.                                 BurbujaBidireccional<int>.Mostrar(vectorInt);
  84.                             }
  85.                             else if (tipo.CompareTo("char") == 0)
  86.                             {
  87.                                 temporizador.Start();
  88.                                 if (función.CompareTo('A') == 0)
  89.                                     BurbujaBidireccional<char>.Ordenar(vectorChar, Gener.CharAscendente);
  90.                                 else
  91.                                     BurbujaBidireccional<char>.Ordenar(vectorChar, Gener.CharDescendente);
  92.                                 temporizador.Stop();
  93.                                 BurbujaBidireccional<char>.Mostrar(vectorChar);
  94.                             }
  95.                             else
  96.                             {
  97.                                 temporizador.Start();
  98.                                 if (función.CompareTo('A') == 0)
  99.                                     BurbujaBidireccional<double>.Ordenar(vectorDouble, Gener.DoubleAscendente);
  100.                                 else
  101.                                     BurbujaBidireccional<double>.Ordenar(vectorDouble, Gener.DoubleDescendente);
  102.                                 temporizador.Stop();
  103.                                 BurbujaBidireccional<double>.Mostrar(vectorDouble);
  104.                             }
  105.                             break;
  106.  
  107.  

La clase ProcesadorDatos la utilizo para insertar elementos en los arrays y para transformar los ArrayList en los arrays del tipo que corresponda. Adjunto algo de código de dicha clase:

Código: C#
  1. namespace MétodosOrdenación
  2. {
  3.     class ProcesadorDatos
  4.     {
  5.         private ArrayList lista;
  6.         private string tipo;
  7.         private int tamaño;
  8.  
  9.         public ProcesadorDatos(int tamaño, string tipo)
  10.         {
  11.             lista = new ArrayList(tamaño);
  12.             this.tipo = tipo;
  13.             this.tamaño = tamaño;
  14.         }
  15.  
  16.         public void insertaAleatorio()
  17.         {
  18.             int semilla = System.Convert.ToInt32(DateTime.Now.Millisecond);
  19.             if (this.tipo == "int")
  20.             {
  21.                 Console.WriteLine("Introduciendo elementos aleatorios...");
  22.                 Random rnd = new Random(semilla);
  23.                 for (int i = 0; i < this.tamaño; i++)
  24.                     lista.Add((int)(rnd.NextDouble() * 1000));    
  25.                
  26.             }            
  27.             else if (this.tipo == "double")
  28.             {
  29.                 Console.WriteLine("Introduciendo elementos aleatorios...");
  30.                 Random rnd = new Random(semilla);
  31.                 for (int i = 0; i < this.tamaño; i++)
  32.                     lista.Add((double)(rnd.NextDouble() * 1000));
  33.             }
  34.             else
  35.             {
  36.                
  37.                 Random prRand = new Random(semilla);
  38.                 Console.WriteLine("Introduciendo elementos aleatorios...");
  39.                 Random rnd = new Random(semilla);
  40.                 for (int i = 0; i < this.tamaño; i++)
  41.                     lista.Add((char)(prRand.Next(97, 123)));
  42.             }
  43.         }
  44.  
  45.  
  46.         public void listaToArray(int[] vectorInt)
  47.         {
  48.             int posicion = 0;
  49.             foreach (Object obj in this.Lista)
  50.             {
  51.                 vectorInt[posicion] = Convert.ToInt32(obj);
  52.                 posicion++;
  53.             }
  54.  
  55.         }
  56.  
  57.         public void listaToArray(double[] vectorDouble)
  58.         {
  59.             int posicion = 0;
  60.             foreach (Object obj in this.Lista)
  61.             {
  62.                 vectorDouble[posicion] = Convert.ToDouble(obj);
  63.                 posicion++;
  64.             }
  65.  
  66.         }
  67.  
  68.         public void listaToArray(char[] vectorChar)
  69.         {
  70.             int posicion = 0;
  71.             foreach (Object obj in this.Lista)
  72.             {
  73.                 vectorChar[posicion] = Convert.ToChar(obj);
  74.                 posicion++;
  75.             }
  76.  
  77.         }
  78.  
  79.  
Pienso que tengo bastantes "apaños" en el código y que podría estar más depurado apoyándome en la genericidad utilizando la clase Ordenación<Tip> mencionada y creo que podría también implementar la interfaz IComparable, pero no me desenvuelvo muy bien con la genericidad, agradecería alguna idea.

3
C# / Re: Trabajar con arrays de distintos tipos de datos(C#)
« en: Lunes 20 de Septiembre de 2010, 14:17 »
Eso es justamente lo que quería hacer yo... mil millones de gracias, probaré a adaptar esa idea al código que tengo. Gracias!!

4
C# / Re: Trabajar con arrays de distintos tipos de datos(C#)
« en: Lunes 20 de Septiembre de 2010, 09:25 »
Muchas gracias compi!!, la verdad es que me será de mucha ayuda, no conocía ese modo de validar el tipo de datos introducido, me parece muy interesante... Seguiré intentando avanzar con el programa. Mil gracias de nuevo!!

5
C# / Re: Trabajar con arrays de distintos tipos de datos(C#)
« en: Domingo 19 de Septiembre de 2010, 21:05 »
Muchas gracias!!, la idea sería pedir el tipo de datos con el que trabajar(char,double,float), y una vez seleccionado utilizar sólo ese tipo de dato. El problema lo tendría a la hora de declarar las cabeceras de los métodos, por ejemplo; public void Burbuja(int[] vector), es este caso especifico el tipo, pero la idea que yo tenía era declarar una sola cabecera de forma que para cualquier array pasado como argumento sea del tipo que sea, pudiera trabajar con el, y en este caso pudiera ordenarlo. No obstante me sirven las ideas, quizás utilizar un ArrayList sea la solución... Lo probaré estos días.. muchas gracias por tu ayuda.

6
C# / Trabajar con arrays de distintos tipos de datos(C#)
« en: Sábado 18 de Septiembre de 2010, 12:13 »
Antes de nada saludaros a todos ya que soy nuevo en el foro  :): . Mi duda es la siguiente; toy programando una aplicación que trabaje con distintos algoritmos de ordenación, y estoy planteandome la posibilidad de que pueda trabajar con datos int, double o incluso char, pero no se me ocurre el modo de hacerlo, os comento un poco por encima la estructura del programa que estoy realizando para ver si es posible añadir esta funcionalidad:

De momento mi programa consta de una clase "Ordenación", que tiene los métodos "Insertar", "Insertar aleatorio", "Mostrar", "Ordenar"... de la cual heredan una serie de clases que serán los distintos algoritmos de ordenación; "Burbuja", "QuickSort", "Inserción"...Luego tengo el main, desde el cual por medio de menús, selecciono el tipo de algoritmo a utilizar y las operaciones que se quieran realizar con ellos, todo esto instanciando objetos de tipo "Ordenación" ya que por medio del poliformismo se ejecutará en cada caso el método ordenar requerido. Pues bien, el caso es que no veo el modo de poder trabajar con arrays de distintos tipos...Si teneis alguna idea o sugerencia.. Os adjunto algo de código que tengo hecho:


Código: Text
  1.  
  2. /// método llamado desde otro menú del main una vez hayamos elegido ///el tipo de algoritmo con el que vamos a trabajar
  3. /// el objeto algoritmo es de tipo Ordenación
  4.  
  5. public static void MenúModo(Ordenación algoritmo,int tamaño)
  6.         {
  7.             int modo;
  8.             int[] vector = new int[tamaño];
  9.             do
  10.             {
  11.                 Console.Clear();
  12.                 Console.WriteLine(".- SELECCIONA UNA OPCIÓN");
  13.                 Console.WriteLine("1.- INTRODOCIR VECTOR MANUALMENTE");
  14.                 Console.WriteLine("2.- GENERAR VECTOR ALEATORIO");
  15.                 Console.WriteLine("3.- ORDENAR VECTOR: ORDEN ASCENDENTE");
  16.                 Console.WriteLine("4.- ORDENAR VECTOR: ORDEN DESCENDENTE");
  17.                 Console.WriteLine("5.- MOSTRAR VECTOR");
  18.                 Console.WriteLine("6.- BORRAR VECTOR");
  19.                 Console.WriteLine("7.- VOLVER AL MENÚ");
  20.                 Console.Write("Elija opción(1-7): ");
  21.                 modo = Convert.ToInt32(Console.ReadLine());
  22.                 switch (modo)
  23.                 {
  24.                     case 1:
  25.                         algoritmo.Insertar(vector);
  26.                         Console.WriteLine("Pulse entrar para continuar");
  27.                         Console.ReadLine();    
  28.                         break;
  29.  
  30.                     case 2:
  31.                         algoritmo.InsertarAleatorio(vector);
  32.                         Console.WriteLine("Pulse entrar para continuar");
  33.                         Console.ReadLine();
  34.                         break;
  35.  
  36.                     case 3:
  37.                         Console.WriteLine("Ordenando....");
  38.                         algoritmo.Ordenar(vector);
  39.                         Console.WriteLine("¡Vector ordenado en orden ascendente!");
  40.                         Console.WriteLine("Tiempo empleado"+algoritmo.TiempoEjecución);
  41.                         Console.WriteLine("nº comparaciones:" + algoritmo.NumComparaciones);
  42.                         Console.WriteLine("nº intercambios" + algoritmo.NumIntercambios);
  43.                         Console.WriteLine("Pulse entrar para continuar");
  44.                         Console.ReadLine();
  45.                         break;
  46.  
  47.  
  48. ///Clase ancestro de clases; "Burbuja", "Selección"..., cada cual con su propio método ordenar
  49.  
  50. public class Ordenación
  51.     {
  52.         protected long tiempoEjecución;
  53.         protected int numComparaciones;
  54.         protected int numIntercambios;
  55.  
  56.         public void Insertar(int[] vector)
  57.         {
  58.             for (int i = 0; i < vector.Length; i++)
  59.             {
  60.                 Console.Write("Introduzca elemento["+i+"]");
  61.                 try
  62.                 {
  63.                     int elemento = Convert.ToInt32(Console.ReadLine());
  64.                    
  65.                     vector[i] = elemento;
  66.                 }
  67.                 catch (FormatException )
  68.                 {
  69.                     Console.WriteLine("Elemento incorrecto");
  70.                 }
  71.                
  72.             }
  73.            
  74.         }
  75.  
  76.  
  77. ///Clase Burbuja
  78.  
  79. public class Burbuja: Ordenación
  80.     {
  81.         private int nComparaciones = 0;
  82.         private int nIntercambios = 0;
  83.  
  84.         public override void Ordenar(int[] vector)
  85.         {
  86.             Stopwatch temporizador = new Stopwatch();
  87.             temporizador.Start();
  88.             int sup = vector.Length - 1;
  89.             int temp;
  90.             for (int i = sup; i >= 1; i--)
  91.             {
  92.                 for (int j = 0; j <= i - 1; j++)
  93.                     if (vector[j] > vector[j + 1])
  94.                     {
  95.                         temp = vector[j];
  96.                         vector[j] = vector[j + 1];
  97.                         vector[j + 1] = temp;
  98.                         nIntercambios++;
  99.                     }
  100.                     nComparaciones ++;
  101.             }
  102.             temporizador.Stop();
  103.             TiempoEjecución = temporizador.ElapsedMilliseconds;
  104.             NumComparaciones = nComparaciones;
  105.             NumIntercambios = nIntercambios;
  106.         }
  107.  
  108.  
  109.  

Páginas: [1]