¡Hola de nuevo! En esta ocasión me gustaría compartir con ustedes este video tutorial acerca de MonoDevelop. No es nada avanzado, solo muestra algunas características de este IDE. El video en cuestión lo grabé hace más o menos siete meses, pero casualmente había olvidado que lo había grabado Y, aunque ya vamos en la versión 2 de MonoDevelop, no quiero perder el trabajo que alguna vez hice.

Como siempre, pueden encontrar el vídeo en Youtube o en Vimeo. Aunque creo que hay un pedazo que se ve feo y el sonido no es el mejor, espero que les guste y disculpen lo feo

Existen dos maneras de definir constantes en C Sharp: usando const o readonly. Cuando se usa const, es posible acceder a la variable directamente desde la clase (sin instanciar un objeto), como si se tratase de un atributo estático; mientras que con readonly, es un tipo de constantes que funciona como un atributo normal, y que una vez inicializada no se le puede cambiar el valor.

Veamos un ejemplo sencillo para aclararnos:

using System;
public class Constantes {
  // crear constante PI
  public const double PI = 3.14159;
  // radio es una constante esta sin iniciar
  public readonly int radio;
  public Constantes( int radioValue ) {
     radio = radioValue;
  }
}
// Clase UsarConstantes
public class UsarConstantes {
  // metodo Main crea un objeto de tipo 'Constantes'
  // y muestra los valores
  static void Main( string[] args ) {
     Random random = new Random();
     Constantes valoresConstantes =
        new Constantes( random.Next( 1, 20 ) );
     Console.WriteLine( "Radio = " + valoresConstantes.radio +
        "\nCircunferencia = " +
        2 * Constantes.PI * valoresConstantes.radio);
  }
}

Resultado…

Descargar código fuente

Las variables estáticas son atributos de una clase que están disponibles para todas las instancias de dicha clase, y a los cuales puedes acceder directamente (sin instanciar un objeto) de la forma Clase.Variable.

Los destructores son métodos que se ejecutan cuando se elimina un objeto; son especialmente útiles si deseamos hacer algo en particular, antes de eliminar la referencia al objeto. A continuación un sencillo ejercicio, en donde se ejemplifica el uso de las variables estáticas y de los destructores en C Sharp:

using System;
namespace Estatico{
   public class Clase {
      //un atributo normal
      private string variable;
      //esta variable esta disponible para todas
      //las instancias de esta clase
      private static int contador;
      //constructor
      public Clase(string x) {
         variable = x;
         //aumentar valor de la variable estatica
         ++contador;
         Console.WriteLine("Constructor de "+variable);
      }
      ~Clase(){
         --contador;
         Console.WriteLine("Se destruyo una de las instancias ("+variable+")"+contador);
      }
      public static int Contador{
         get{
            return contador;
         }
      }
   }
}

Clase que utiliza los valores estáticos de la clase anterior:

using System;
namespace Estatico{
   public class Principal{
      static void Main(string[] args){
         Console.WriteLine("Contador antes de crear objetos: "+Clase.Contador);
         //crear 2 instancias de la clase
         Clase objeto1 = new Clase("primero");
         Clase objeto2 = new Clase("segundo");
         Console.WriteLine("Contador despues de crear objetos: "+Clase.Contador);
         //eliminar referencias a los objetos
         objeto1 = null;
         objeto2 = null;
         //forzar al recolector de basura a ejecutarse
         System.GC.Collect();
         //esperar hasta que el recolector de basura termine su trabajo
         System.GC.WaitForPendingFinalizers();
         //despues de la recolecta de basura...
         Console.WriteLine("Despues de la recolecta de basura, contador: "+Clase.Contador);
      }
   }
}

Descargar código fuente

Al momento de acceder a los atributos de una clase, podemos usar métodos para asignar y obtener dichos datos (normalmente llamados getters y setters). En C Sharp podemos usar una caracterí­stica llamada ‘propiedades’, por medio de la cual declaramos un alias de acceso público para los atributos de acceso privado.

Me explico. Cuando declaramos atributos en una clase, lo más aconsejable es crearlos con el modificador de acceso private. Por tal motivo no es posible acceder a dichos atributos directamente desde el objeto (de la manera: objeto.atributo), porque como vimos en esta entrada nos arrojará errores de compilación.

Aquí­ es cuando las ‘propiedades’ son especialmente útiles. Una propiedad es como un alias que nos permite acceder a los atributos de manera segura, y con la que nos ahorramos tiempo y espacio en nuestro código. Vamos directamente con un ejemplo, y posteriormente una breve explicación del mismo.

Clase de ejemplo, que implementa una ‘propiedad’ para acceder al atributo:

public class Clase {
	//atributo
	private int variable;
	//constructor
	public Clase(int variable) {
		this.variable = variable;
	}
	//declaracion de la propiedad
	public int atributo{
		//get sirve para devolver el valor del atributo
		get{
			return variable;
		}
		//set sirve para cambiar el valor del atributo
		set{
			variable = value;
		}
	}
}

En la lí­nea 9 tenemos la declaración de la propiedad; en dicha declaración debemos especificar un nombre (diferente al del atributo al que vamos a acceder), y un tipo (en este caso int, entero). Dentro de la propiedad tenemos dos bloques: get y set. Dentro de get debemos poner los valores a retornar cuando se acceda a la propiedad; mientras que en set podemos usar la palabra clave value para asignar un valor al atributo.

En la siguiente clase se utiliza la propiedad de la clase anterior, para obtener y modificar los valores del atributo:

using System;
public class Propiedades {
	public Propiedades() {
		//declaracion del objeto
		Clase objeto = new Clase(5);
		//obteniendo el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa el bloque get)
		Console.WriteLine("El atributo del objeto es "+ objeto.atributo);
		Console.WriteLine("Cambiando el valor usando la propiedad 'atributo'...");
		//cambiando el valor de la variable 'variable'
		//usando la propiedad 'atributo' (se usa get)
		objeto.atributo = 10;
		Console.WriteLine("Ahora el atributo del objeto es "+ objeto.atributo);
	}
	static void Main(string[] args){
		new Propiedades();
	}
}

Como puedes observar, es posible obtener y modificar los datos de un atributo privado usando una ‘propiedad’ pública, y todo de una manera totalmente segura, puesto que dentro de la ‘propiedad’ podemos verificar la consistencia de los datos.

El resultado…

Descargar código fuente

Tal como veí­amos en el ejemplo anterior, en donde explicabamos las nociones básicas de la programación orientada a objetos en C Sharp, los objetos pueden tener uno o más constructores. El siguiente ejemplo es una modificación del anterior ejercicio, en donde declaramos y usamos varios constructores.

El código…

La clase Tiempo2 que declara 5 constructores; el primero de ellos (lí­nea 9) no recibe argumentos e inicia las variables a cero; el segundo recibe solo parámetro e inica solo una de los atributos de la clase; mientras que el quinto constructor (lí­nea 32) recibe como parámetro un objeto del mismo tipo de la clase, y usando los atributos de dicho objeto inicia los atributos propios:

using System;
public class Tiempo2
{
  private int hora;    // 0 -23
  private int minuto;  // 0-59
  private int segundo;  // 0-59
  // Constructor de la clase Tiempo que inicialize
  //las variables a cero para poner la hora en media noche
  public Tiempo2()
  {
     cambiarHora( 0, 0, 0 );
  }
  // Contructor que recibe unicamente la
  // hora, y lo demas lo inicia a 0
  public Tiempo2( int hora )
  {
     cambiarHora( hora, 0, 0 );
  }
  // Contructor que recibe la hora y el
  // minuto, y lo demas lo inicia a 0
  public Tiempo2( int hora, int minuto )
  {
     cambiarHora( hora, minuto, 0 );
  }
  // Contructor que recibe los tres atributos
  public Tiempo2( int hora, int minuto, int segundo )
  {
     cambiarHora( hora, minuto, segundo );
  }
  // Constructor que utiliza los datos de otro
  //metodo de tipo Tiempo2 para inciar los datos
  public Tiempo2( Tiempo2 hora )
  {
     cambiarHora( hora.hora, hora.minuto, hora.segundo );
  }
  // este metodo asigna una nueva hora en formato 24-horas.
  public void cambiarHora(
     int valorHora, int valorMinuto, int valorSegundo )
  {
     hora = ( valorHora >= 0 &amp;amp;&amp;amp; valorHora < 24 ) ?
        valorHora : 0;
     minuto = ( valorMinuto >= 0 &amp;amp;&amp;amp; valorMinuto < 60 ) ?
        valorMinuto : 0;
     segundo = ( valorSegundo >= 0 &amp;amp;&amp;amp; valorSegundo < 60 ) ?
        valorSegundo : 0;
  }
  // convertir a hora universal con el metodo format
  public string horaUniversal()
  {
     return String.Format(
        "{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo );
  }
  // convertir a tiempo estandar (12 horas) usando el metodo format
  public string horaEstandar()
  {
     return String.Format( "{0}:{1:D2}:{2:D2} {3}",
        ( ( hora == 12 || hora == 0 ) ? 12 : hora % 12 ),
        minuto, segundo, ( hora < 12 ? "AM" : "PM" ) );
  }
}

Clase en donde se utilizan los diferentes tipos de constructores:

using System;
class PruebaTiempo2 {
  static void Main( string[] args ) {
     Tiempo2 hora1, hora2, hora3, hora4, hora5, hora6;
     hora1 = new Tiempo2();               // 00:00:00
     hora2 = new Tiempo2( 2 );            // 02:00:00
     hora3 = new Tiempo2( 21, 34 );       // 21:34:00
     hora4 = new Tiempo2( 12, 25, 42 );   // 12:25:42
     hora5 = new Tiempo2( 27, 74, 99 );   // 00:00:00
     hora6 = new Tiempo2( hora4 );        // 12:25:42
     String salida = "Construido con: " +
        "\nhora1: todos los argumentos por defecto" +
        "\n\t" + hora1.horaUniversal() +
        "\n\t" + hora1.horaEstandar();
     salida += "\nhora2: hora especifica; minuto y segundo por defecto" +
        "\n\t" + hora2.horaUniversal() +
        "\n\t" + hora2.horaEstandar();
     salida += "\nhora3: hora y minuto especifico; segundo por defecto" +
        "\n\t" + hora3.horaUniversal() +
        "\n\t" + hora3.horaEstandar();
     salida += "\nhora4: los tres argumentos especificamente" +
        "\n\t" + hora4.horaUniversal() +
        "\n\t" + hora4.horaEstandar();
     salida += "\nhora5: los tres argumentos especificamente" +
        "\n\t" + hora5.horaUniversal() +
        "\n\t" + hora5.horaEstandar();
     salida += "\nhora6: otro objeto de tipo Tiempo2 (hora4)" +
        "\n\t" + hora6.horaUniversal() +
        "\n\t" + hora6.horaEstandar();
     Console.WriteLine( salida );
  }
}

El resultado del programa es el siguiente:

Descargar código fuente

La POO es un paradigma de programación que intenta abstraer los módulos de cada programa en objetos. Los objetos son instancias de clases, en las que se declaran/especifican al menos dos cosas: los atributos, los métodos y opcionalmente los constructores.

Los atributos son las variables que posee el objeto, mientras que los métodos son las funciones o procedimientos que podemos invocar para realizar operaciones especí­ficas sobre los atributos.

Como en Java, en C Sharp utilizamos siempre clases y objetos, aún cuando no tengamos claro el concepto. Por ejemplo, el simple hola mundo:

using System;
class Hola{
   static void Main(string[] args){
      Console.WriteLine("Hola parce!");
   }
}

En cada lí­nea de código estamos usando la programación orientada a objetos: lí­nea 1, creamos una clase (llamada Hola); lí­nea 2, declaramos un método (función) para nuestra clase; lí­nea 3, usando la clase Console invocamos el método WriteLine. Todo, programación orientada a objetos.

Ejemplo de POO en C Sharp

En el siguiente ejemplo tomado del libro Cómo programar en C Sharp de Deitel, se utiliza una clase llamada tiempo. Dicha clase posee tres atributos (hora, minuto, segundo; todos variables enteras), y tres métodos. Vamos con el código, y mí¡s abajo una explicación:

using System;
public class Tiempo
{
  private int hora;    // 0 -23
  private int minuto;  // 0-59
  private int segundo;  // 0-59
  // Constructor de la clase Tiempo que inicialize
  //las variables a cero para poner la hora en media noche
  public Tiempo()
  {
     cambiarHora( 0, 0, 0 );
  }
  // este metodo asigna una nueva hora en formato 24-horas.
  public void cambiarHora(
     int valorHora, int valorMinuto, int valorSegundo )
  {
     hora = ( valorHora >= 0 && valorHora < 24 ) ?
        valorHora : 0;
     minuto = ( valorMinuto >= 0 && valorMinuto < 60 ) ?
        valorMinuto : 0;
     segundo = ( valorSegundo >= 0 && valorSegundo < 60 ) ?
        valorSegundo : 0;
  }
  // convertir a hora universal con el metodo format
  public string horaUniversal()
  {
     return String.Format(
        "{0:D2}:{1:D2}:{2:D2}", hora, minuto, segundo );
  }
  // convertir a tiempo estandar (12 horas) usando el metodo format
  public string horaEstandar()
  {
     return String.Format( "{0}:{1:D2}:{2:D2} {3}",
        ( ( hora == 12 || hora == 0 ) ? 12 : hora % 12 ),
        minuto, segundo, ( hora < 12 ? "AM" : "PM" ) );
  }
}

• En la segunda lí­nea vemos la instrucción public class Tiempo; esto no es mí¡s que la declaración de nuestra clase. Las clases por lo general son de tipo public, aunque si usamos clases internas anónimas es recomendable que sean private, aunque eso es otro tema… sigamos.
• En las lí­neas 4, 5 y 6 tenemos la declaración de los atributos de nuestra clase. Fí­jate como todos ellos son private; es un buen tip de programación que los atributos de nuestras clases sean privados, lo que significa que sólamente serí¡n accesibles desde los métodos de la clase.
• En la lí­nea 9 tenemos la declaración de un constructor. Los constructores son los métodos invocados en el momento de crear objetos; su función es la darle valores a los atributos del objeto. Podemos tener cuantos constructores necesitemos, por supuesto con diferente tipo de argumentos. Ademí¡s, es necesario tener en cuenta que los constructores son métodos que NO tienen ningún valor de retorno, y que deben llevar el mismo nombre de la clase.
• En las lí­neas 14, 25 y 31 estí¡n declarados los métodos o funciones, que permiten realizar operaciones sobre nuestro objeto. Por ejemplo, el método cambiarHora recibe tres argumentos, con los cuales modifica los atributos. Por lo general, los métodos de las clases son de tipo public, lo que permite invocarlos directamente a través de una instancia de la clase (es decir, un objeto).

Con el siguiente código, utilizamos la clase Tiempo:

using System;
class PruebaTiempo {
  static void Main( string[] args ) {
     Tiempo tiempo = new Tiempo();  // llamada al constructor de Tiempo
     string salida;
     // mostrar datos iniciales
     salida = "Hora universal inicial es: " +
        tiempo.horaUniversal() +
        "\nHora estandar inicial es: " +
        tiempo.horaEstandar();
     // cambiar hora (valida)
     tiempo.cambiarHora( 13, 27, 6 );
     // aniadir nueva hora a la salida
     salida += "\n\nHora universal despues de cambiada: " +
        tiempo.horaUniversal() +
        "\nHora estandar despues de cambiada: " +
        tiempo.horaEstandar();
     // cambiar hora (invalida)
     tiempo.cambiarHora( 99, 99, 99 );
     salida += "\n\nDespues de poner valores invalidos: " +
        "\nHora universal: " + tiempo.horaUniversal() +
        "\nHora estandar: " + tiempo.horaEstandar();
     Console.WriteLine( salida );
  }
}

• En la lí­nea 3 creamos un objeto de tipo tiempo. Por lo general la sintaxis para crear objetos es la siguiente: Clase objeto = new Clase(). Es decir, el nombre de la clase, el nombre del objeto, y posteriormente se incia el objeto haciendo una invocación al constructor de la clase (anteponiendo la instrucción new).
• En la lí­nea 8, invocamos uno de los métodos de la clase (horaUniversal). La sintaxis para la invocación de los métodos es: objeto.nombreMetodo(arg1, arg2, ...). Así­, en la lí­nea 12 podemos ver otro ejemplo de invocación, en la que pasamos algunos argumentos al método.

El resultado del programa es el siguiente:

Descargar código fuente

Acceso a los atributos de un objeto

Si al momento de declarar los atributos de una clase utilizamos el modificador de acceso public, es posible acceder a dichos atributos directamente de la siguiente manera: objeto.variable; ó objeto.variable = unValor;. Esto por supuesto NO es recomendable, es decir, los atributos de una clase deberí­an ser SIEMPRE privados.

De igual forma, si hemos declarado atributos con el modificador de acceso private, NO es posible acceder directamente a ellos. Así­ que para modificarlos, debemos crear métodos de acceso público, algo por supuesto mí¡s seguro. Si intentamos acceder directamente a atributos que se han declarado como privados, obtendremos errores de compilación.

Las matrices o arreglos de dos dimensiones, son arrays bidimensionales cuyos elementos tienen dos indices. En C Sharp existen dos tipos de arreglos bidimensionales, los rectangulares y los dinámicos. Por lo general, cuando accedemos a arreglos bidimensionales utilizamos los términos filas y columnas.

En los arreglos bidimensionales rectangulares, cada fila tiene la misma cantidad de columnas. Por otro lado, las filas de los arreglos bidimensionales dinámicos pueden tener diferente cantidad de columnas. A continuación, una serie de ejemplos en donde se explica cómo se declara e inician los dos tipos de arreglos:

Declaración e iniciación de arreglos de dos dimensiones

using System;
public class ArregloDosDimensiones {
  static void Main() {
     // declaracion e iniciación de arreglos rectangulares
     int[,] arreglo1 = new int[,] { { 1, 2, 3 }, { 4, 5, 6 } };
     // declaración e iniciación de arreglos dinamicos
     int[][] arreglo2 = new int[ 3 ][];
     string salida = "";
     arreglo2[ 0 ] = new int[] { 1, 2 };
     arreglo2[ 1 ] = new int[] { 3 };
     arreglo2[ 2 ] = new int[] { 4, 5, 6 };
     salida = "Valores en arreglo1 por fila\n";
     // salida del arreglo1
     for ( int i = 0; i < arreglo1.GetLength( 0 ); i++ ) {
        for ( int j = 0; j < arreglo1.GetLength( 1 ); j++ )
           salida += arreglo1[ i, j ] + "  ";
        salida += "\n";
     }
     salida += "\nValores en arreglo2 por fila\n";
     // salida del arreglo2
     for ( int i = 0; i < arreglo2.Length; i++ ) {
        for ( int j = 0; j < arreglo2[ i ].Length; j++ )
           salida += arreglo2[ i ][ j ] + "  ";
        salida += "\n";
     }
     Console.WriteLine(salida);
  }
}

Salida…

Descargar código fuente

Ejemplo con arreglos bidimensionales

using System;
public class DoubleArray {
  static int[][] calificacion;
  static int estudiantes, examenes;
  static void Main() {
     string salida = "                   ";
     calificacion = new int[ 3 ][];
     calificacion[ 0 ] =  new int[]{ 77, 68, 86, 73 };
     calificacion[ 1 ] =  new int[]{ 96, 87, 89, 81 };
     calificacion[ 2 ] =  new int[]{ 70, 90, 86, 81 };
     estudiantes = calificacion.Length;      // numero de estudiantes
     examenes = calificacion[ 0 ].Length;    // numero de examenes
     // columnas
     for ( int i = 0; i < examenes; i++ )
        salida += "[" + i + "]  ";
     // filas
     for ( int i = 0; i < estudiantes; i++ ) {
        salida += "\ncalificaciones[" + i + "]   ";
        for ( int j = 0; j < examenes; j++ )
           salida += calificacion[ i ][ j ] + "   ";
     }
     salida += "\n\nCal. m&amp;amp;aacute;s baja: " + minimo() +
        "\nCal. m&amp;amp;aacute;s alta: " + maximo() + "\n";

     for ( int i = 0; i < estudiantes; i++ )
        salida += "\nEl promedio por estudiante " + i + " es " +
           promedio( calificacion[ i ] );
     Console.WriteLine(salida);
  }
  // buscar calificacion minima en el arreglo
  static public int minimo() {
     int baja = 100;
     for ( int i = 0; i < estudiantes; i++ )
        for ( int j = 0; j < examenes; j++ )
           if ( calificacion[ i ][ j ] < baja )
              baja = calificacion[ i ][ j ];
       return baja;
  }
  // buscar calificacion maxima en en arreglo
  static public int maximo() {
     int alta = 0;
     for ( int i = 0; i < estudiantes; i++ )
        for ( int j = 0; j < examenes; j++ )
           if ( calificacion[ i ][ j ] > alta )
              alta = calificacion[ i ][ j ];
       return alta;
  }
  // determinar el promedio de la calificacion
  static public double promedio( int[] calificaciones ) {
     int total = 0;
     for ( int i = 0; i < calificaciones.Length; i++ )
        total += calificaciones[ i ];
     return ( double ) total / calificaciones.Length;
  }
}

Salida…

Descargar código fuente

Bonus: sentencia foreach en C#

Cuando de recorrer arreglos se trata, existe una sentencia bastante útil: foreach. Foreach es similar a un for, solo que es un poco más simple. La sintaxis es foreach(VARIABLE in ARREGLO), y cada vez que ocurre una iteración, VARIABLE va tomando los valores del arreglo en orden:

using System;
class Foreach {
   // main entry point for the application
   static void Main(string[] args) {
      int[,] calificaciones = { { 77, 68, 86, 73 },
         { 98, 87, 89, 81 }, { 70, 90, 86, 81 } };
      int baja = 100;
      foreach ( int calificacion in calificaciones ) {
         if ( calificacion < baja )
            baja = calificacion;
      }
      Console.WriteLine( "La calificacion mas baja es: " + baja );
   }
}

Descargar código fuente

Hace unos dí­as y poní­a un ejemplo acerca de búsquedas lineales en arreglos, ésta vez hablaremos acerca de las búsquedas lineales, un método mucho más rápido para buscar elementos.

¿Cómo funciona este método? Para poder aplicar éste método de búsqueda es necesario que el arreglo esté ordenado; posteriormente, se aplica el siguiente algoritmo: se ubica el elemento de la mitad del arreglo, entonces, si el número que se está buscando dentro del arreglo es menor al número de la mitad, se busca el número de la mitad entre el inicio del y la mitad del mismo, y así­ hasta encontrar el elemento deseado.

Por ejemplo, suponiendo que tenemos un arreglo con los siguientes valores:

2, 4, 5 , 6, 8, 9, 10, 12, 24, 34, 46, 56, 60, 67, 78, 89, 90

…y queremos buscar el valor 10; tenemos que, el elemento de la mitad contiene el valor 24. Puesto que 24 > 10, buscamos el valor intermedio entre el principio del arreglo y la mitad del mismo, esto es 8. Puesto que 8 < 10, buscamos el valor intermedio entre 8 y la mitad del arreglo (24), esto es 10. Así­, con tan solo 3 bucles, hemos conseguido el valor buscado.

Vamos con el código del programa, que nos sacará de toda duda:

using System;
using System.Drawing;
using System.Windows.Forms;
public class EjemploBusquedaBinaria : Form
{
  private Label labelSolicitar;
  private TextBox cajaEntrada;
  private Label labelResultado;
  private Label labelMostrar;
  private Label labelSalida;
  private Button botonBuscar;
  int[] a = { 0, 2, 4, 6, 8, 10, 12, 14, 16,
              18, 20, 22, 24, 26, 28 };
  public EjemploBusquedaBinaria(){
     InitializeComponent();
  }
  private void InitializeComponent() {
     this.labelMostrar = new Label();
     this.labelResultado = new Label();
     this.cajaEntrada = new TextBox();
     this.labelSolicitar = new Label();
     this.botonBuscar = new Button();
     this.labelSalida = new Label();
     this.SuspendLayout();
     //
     // labelMostrar
     //
     this.labelMostrar.Location = new System.Drawing.Point(261, 8);
     this.labelMostrar.Name = "labelMostrar";
     this.labelMostrar.Size = new System.Drawing.Size(152, 20);
     this.labelMostrar.TabIndex = 3;
     //
     // labelResultado
     //
     this.labelResultado.Location = new System.Drawing.Point(213, 8);
     this.labelResultado.Name = "labelResultado";
     this.labelResultado.Size = new System.Drawing.Size(50, 16);
     this.labelResultado.TabIndex = 2;
     this.labelResultado.Text = "Resultado:";
     //
     // cajaEntrada
     //
     this.cajaEntrada.Location = new System.Drawing.Point(99, 8);
     this.cajaEntrada.Name = "cajaEntrada";
     this.cajaEntrada.TabIndex = 1;
     this.cajaEntrada.Text = "";
     //
     // labelSolicitar
     //
     this.labelSolicitar.Location = new System.Drawing.Point(27, 8);
     this.labelSolicitar.Name = "labelSolicitar";
     this.labelSolicitar.Size = new System.Drawing.Size(56, 16);
     this.labelSolicitar.TabIndex = 0;
     this.labelSolicitar.Text = "Digite el dato";
     //
     // botonBuscar
     //
     this.botonBuscar.Location = new System.Drawing.Point(152, 40);
     this.botonBuscar.Name = "botonBuscar";
     this.botonBuscar.Size = new System.Drawing.Size(136, 24);
     this.botonBuscar.TabIndex = 5;
     this.botonBuscar.Text = "Buscar dato";
     this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
     //
     // labelSalida
     //
     this.labelSalida.Font = new System.Drawing.Font("Courier New", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((System.Byte)(0)));
     this.labelSalida.Location = new System.Drawing.Point(10, 80);
     this.labelSalida.Name = "labelSalida";
     this.labelSalida.Size = new System.Drawing.Size(420, 72);
     this.labelSalida.TabIndex = 4;
     //
     // EjemploBusquedaBinaria
     //
     this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
     this.ClientSize = new System.Drawing.Size(440, 157);
     this.Controls.AddRange(new Control[] {
            this.botonBuscar,
            this.labelSalida,
            this.labelMostrar,
            this.labelResultado,
            this.cajaEntrada,
            this.labelSolicitar});
     this.Name = "EjemploBusquedaBinaria";
     this.Text = "Busqueda Binaria";
     this.ResumeLayout(false);
  }
  static void Main() {
     Application.Run( new EjemploBusquedaBinaria() );
  }
  private void botonBuscar_Click( object sender,
     System.EventArgs e )
  {
     int valorBuscar = Int32.Parse( cajaEntrada.Text );
     // iniciar los datos de salida
     labelSalida.Text = "Portions of array searched\n";
     // realizar busqueda binaria
     int elemento = Buscar( a, valorBuscar );
     if ( elemento != -1 )
        labelMostrar.Text = "Valor encontrado en indice " +
           elemento;
     else
        labelMostrar.Text = "Valor no encontrado";
  } // fin botonBuscar_Click
  // buscar mediante metodo binario
  public int Buscar( int[] array, int dato ) {
     int bajo = 0;
     int alto = array.Length - 1;
     int medio;
     while ( bajo <= alto ) {
        medio = ( bajo + alto ) / 2;
        // el siguiente método nos muestra la porción del
        // arreglo donde se está llevando a cabo la busqueda
        // del dato en cada iteración del bucle
        construirSalida( a, bajo, medio, alto );
        if ( dato == array[ medio ] )   // si se encuentra el valor
           return medio;
        else if ( dato < array[ medio ] )
           alto = medio - 1;   // buscar en la mitad más baja
        else
           bajo = medio + 1;   // buscar en la mitad más alta
     } // fin de la busqueda binaria
     return -1;  // dato no encontrado
  } // fin del metodo Buscar
  public void construirSalida(
     int[] array, int bajo, int mid, int alto ) {
     for ( int i = 0; i < array.Length; i++ ) {
        if ( i < bajo || i > alto )
           labelSalida.Text += "    ";
        // marcar el elemento de la mitad en la salida
        else if ( i == mid )
           labelSalida.Text +=
              array[ i ].ToString( "00" ) + "* ";
        else
           labelSalida.Text +=
              array[ i ].ToString( "00" ) + "  ";
     }
     labelSalida.Text += "\n";
  } // fin de construirSalida
} // fin de la clase EjemploBusquedaBinaria

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar búsquedas dentro de un arreglo de manera lineal.

Ejemplo…

using System;
using System.Drawing;
using System.Windows.Forms;
namespace BusquedaLineal
{
   public class BusquedaLineal : Form
   {
      private Button botonBuscar;
      private TextBox cajaEntrada;
      private Label labelSalida;
      int[] a = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26,
                  28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50 };
      public BusquedaLineal()
      {
         InitializeComponent();
      }
      private void InitializeComponent()
      {
         this.botonBuscar = new Button();
         this.cajaEntrada = new TextBox();
         this.labelSalida = new Label();
         this.SuspendLayout();
         //
         // botonBuscar
         //
         this.botonBuscar.Location = new System.Drawing.Point(8, 8);
         this.botonBuscar.Name = "botonBuscar";
         this.botonBuscar.TabIndex = 0;
         this.botonBuscar.Text = "Buscar";
         this.botonBuscar.Click += new System.EventHandler(this.botonBuscar_Click);
         //
         // cajaEntrada
         //
         this.cajaEntrada.Location = new System.Drawing.Point(96, 9);
         this.cajaEntrada.Name = "cajaEntrada";
         this.cajaEntrada.Size = new System.Drawing.Size(88, 20);
         this.cajaEntrada.TabIndex = 1;
         this.cajaEntrada.Text = "";
         //
         // labelSalida
         //
         this.labelSalida.Location = new System.Drawing.Point(8, 40);
         this.labelSalida.Name = "labelSalida";
         this.labelSalida.Size = new System.Drawing.Size(184, 23);
         this.labelSalida.TabIndex = 2;
         //
         // BusquedaLineal
         //
         this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
         this.ClientSize = new System.Drawing.Size(200, 69);
         this.Controls.AddRange(new Control[] {
                  this.labelSalida,
                  this.cajaEntrada,
                  this.botonBuscar});
         this.Name = "BusquedaLineal";
         this.Text = "BusquedaLineal";
         this.ResumeLayout(false);
      }
      static void Main()
      {
         Application.Run(new BusquedaLineal());
      }
      private void botonBuscar_Click( object sender,
         System.EventArgs e )
      {
         int datoBuscar = Int32.Parse( cajaEntrada.Text );
         int indiceElemento = BuscarLineal( a, datoBuscar );
         if ( indiceElemento != -1 )
            labelSalida.Text =
               "Encontrado en el indice " + indiceElemento;
         else
            labelSalida.Text = "Valor no encontrado";
      } // fin del metodo botonBuscar_Click
      // buscar valor dentro del array
      public int BuscarLineal( int[] array, int dato )
      {
         for ( int n = 0; n < array.Length; n++ )
         {
            if ( array[ n ] == dato )
               return n;
         }
         return -1;
      } // fin del metodo BusquedaLineal
   }
}

Descargar código fuente

En el siguiente ejemplo se muestra cómo realizar el ordenamiento de arreglos de enteros, usando el método burbuja en C#.

Ejemplo…

using System;
public class OrdenamientoBurbuja
{
  static void Main()
  {
     int[] a =  { 54, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
     string salida = "Valores de los items originales\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     // ordenar elementos del arreglo
     OrdenarBurbuja( a );
     salida += "\n\nValores de los items en orden descendente\n";
     for ( int i = 0; i < a.Length; i++ )
        salida += "   " + a[ i ];
     Console.WriteLine(salida);
  } // fin del metodo main
  // ordenar elementos de un arreglo con el metodo burbuja
  static public void OrdenarBurbuja( int[] b )
  {
     for ( int pasadas = 1; pasadas < b.Length; pasadas++ ) // pasadas
        for ( int i = 0; i < b.Length - 1; i++ )
           if ( b[ i ] > b[ i + 1 ] )      // comparar
              intercambio( b, i );         // intercambiar
  }
  // intercambio de dos elementos en un arreglo
  static public void intercambio( int[] c, int primero )
  {
     int temp;      // variable temporal para el intercambio
     temp = c[ primero ];
     c[ primero ] = c[ primero + 1 ];
     c[ primero + 1 ] = temp;
  }
}

Resultado…

Descargar código fuente