martes, 21 de junio de 2011

Ejercicios De Metodos De Ordenamiento [JAVA]

Primer Ejercicio
Implementar una aplicación que registre 10 números y que muestre posteriormente los números impares Ordenados En Forma Ascendente. Utilice Métodos De Ordenamiento.

Codigo Fuente:

import javax.swing.JOptionPane;
public class MetodosDeOrdenamiento {
    public static void main(String [] args){
        int vector[] = new int[10];
        for(int i=0;i < vector.length;i++){
            vector[i] = Integer.parseInt(JOptionPane.showInputDialog((i+1)+ "º Numero :",0));
        }
        String Cadena ="Numeros Sin Ordernar \n";
        for(int i=0;i < vector.length;i++){
            Cadena = Cadena + vector[i] + "    ";
        }
        Insercion(vector);
        Cadena = Cadena  + "\nNumeros Impares Ordenados De Forma Ascendente";
        for(int i=0;i < vector.length;i++){
            if(vector[i]%2!=0){
                Cadena = Cadena + "\n" +  vector[i] ;
            }
        }
        JOptionPane.showMessageDialog(null,Cadena);

    }
public static void Insercion (int[] vector) {
      for (int i=1; i < vector.length; i++) {
         int aux = vector[i];
         int j;
         for (j=i-1; j > =0 && vector[j] > aux; j--){
              vector[j+1] = vector[j];
          }
         vector[j+1] = aux;
      }
   }
}

Ejecucion Del Ejercicio!!

Segundo Ejercicio
Ingrese Nombres De Equipos de Futbol Con Su Respectivo Puntaje Visualizarlo Ordenados Por el Puntaje, Utilizando Métodos rápido Y Burbuja.
import javax.swing.JOptionPane;
public class MetodosDeOrdenamientoJugadores {
public static void main(String [] args){
    int x =Integer.parseInt(JOptionPane.showInputDialog("Ingrese Total De Equipos",0));
    int puntos[]= new int[x];
    String equipos[]= new String[x];
    for(int i =0;i < x;i++){
        equipos[i]= JOptionPane.showInputDialog("Ingrese Nombre De Equipo" );
        puntos[i]= Integer.parseInt(JOptionPane.showInputDialog("Ingrese Puntos",0));
    }
    Burbuja(puntos,equipos);
    String Cadena = "Equipos Y Sus Puntos \n";
    for(int i =0;i < x;i++){
        Cadena = Cadena + equipos[i] + "     " + puntos[i] + "\n";
    }
    JOptionPane.showMessageDialog(null, Cadena);

}
public static void Burbuja(int[]matrix,String[]equipos){
        int temp;
        String tempe;
        for(int i=1;i < matrix.length;i++){
            for (int j=0 ; j < matrix.length- 1; j++){
                if (matrix[j] < matrix[j+1]){
                    temp = matrix[j];
                    matrix[j] = matrix[j+1];
                    matrix[j+1] = temp;
                    tempe = equipos[j];
                    equipos[j] = equipos[j+1];
                    equipos[j+1] = tempe;

                }
            }
        }
    }
//a = Inicio ; b = Final
public static void Rapido(int matrix[], int a, int b){
    matrix = new int[matrix.length];
    int buf;
    int from = a;
    int to = b;
    int pivot = matrix[(from+to)/2];
    do{
        while(matrix[from] < pivot){
            from++;
        }
        while(matrix[to] > pivot){
            to--;
        }
        if(from < = to){
            buf = matrix[from];
            matrix[from] = matrix[to];
            matrix[to] = buf;
            from++; to--;
        }
    }while(from < = to);
    if(a < to){
        Rapido(matrix, a, to);
    }
    if(from < b){
        Rapido(matrix, from, b);
    }
}
}

Seguir Leyendo...

METODOS DE ORDENAMIENTO [JAVA]

Para poder ordenar una cantidad determinada de números almacenadas en un vector o matriz, existen distintos métodos (algoritmos) con distintas características y complejidad.
Existe desde el método más simple, como el Bubblesort (o Método Burbuja), que son Simples iteraciones, hasta el Quicksort (Método Rápido), que al estar optimizado usando recursión, su tiempo de ejecución es menor y es más efectivo.

METODOS ITERATIVOS

Estos métodos son simples de entender y de programar ya que son iterativos, simples ciclos y sentencias que hacen que el vector pueda ser ordenado.
Dentro de los Algoritmos iterativos encontramos:

  • ·         Burbuja
  • ·         Inserción
  • ·         Selección
  • ·         Shellsort

    METODOS RECURSIVOS

Estos métodos son aún más complejos, requieren de mayor atención y conocimiento para ser entendidos. Son rápidos y efectivos, utilizan generalmente la técnica Divide y vencerás, que consiste en dividir un problema grande en varios pequeños para que sea más fácil resolverlos.
Mediante llamadas recursivas a sí mismas, es posible que el tiempo de ejecución y de ordenación sea más óptimo.
Dentó de los algoritmos recursivos encontramos:

  • Ordenamiento por Mezclas (merge)
  • Ordenamiento Rápido (quick)

METODO BURBUJA

public static void burbuja(int[]matrix){
        int temp;
        for(int i=1;i < matrix.length;i++){
            for (int j=0 ; j < matrix.length- 1; j++){
                if (matrix[j] > matrix[j+1]){
                    temp = matrix[j];
                    matrix[j] = matrix[j+1];
                    matrix[j+1] = temp;
                }
            }
        }
    }

METODO INSERCION
public static void Insercion (int[] vector) {
      for (int i=1; i < vector.length; i++) {
         int aux = vector[i];
         int j;
         for (j=i-1; j > =0 && vector[j] > aux; j--){
              vector[j+1] = vector[j];
          }
         vector[j+1] = aux;
      }
   }

METODO SELECCIÓN
public static void Seleccion(int[]matrix){
        int i, j, k, p, buffer, limit = matrix.length-1;
        for(k = 0; k < limit; k++){
            p = k;
            for(i = k+1; i < = limit; i++){
                if(matrix[i] < matrix[p]) p = i;
                if(p != k){
                    buffer = matrix[p];
                    matrix[p] = matrix[k];
                    matrix[k] = buffer;
                }
            }
        }
    }

METODO SHELL SHORT
public static void shellSort(int[] matrix) {
    for ( int increment = matrix.length / 2;increment > 0;
          increment = (increment == 2 ? 1 : (int) Math.round(increment / 2.2))) {
        for (int i = increment; i < matrix.length; i++) {
            for (int j = i; j > = increment && matrix[j - increment] > matrix[j]; j -= increment) {
                int temp = matrix[j];
                matrix[j] = matrix[j - increment];
                matrix[j - increment] = temp;
            }
        }
    }
}

ORDENAMIENTO POR MEZCLAS (MERGE)
El algoritmo de ordenamiento por mezcla (Merge) se divide en dos procesos, primero se divide en partes iguales la lista:
public static void mergesort(int[ ] matrix, int init, int n){
    int n1;
    int n2;
    if (n > 1){
        n1 = n / 2;
        n2 = n - n1;
        mergesort(matrix, init, n1);
        mergesort(matrix, init + n1, n2);
        merge(matrix, init, n1, n2);
   }
}
Y el algoritmo que nos permite mezclar los elementos según corresponda:
private static void merge(int[ ] matrix, int init, int n1, int n2){
    int[ ] buffer = new int[n1+n2];
    int temp = 0;
    int temp1 = 0;
    int temp2 = 0;
    int i;
    while ((temp1 < n1) && (temp2 < n2)){
        if (matrix[init + temp1] < matrix[init + n1 + temp2]){
            buffer[temp++] = matrix[init + (temp1++)];
        }else{
            buffer[temp++] = matrix[init + n1 + (temp2++)];
        }
    }
    while (temp1 < n1){
        buffer[temp++] = matrix[init + (temp1++)];
    }
    while (temp2 < n2){
        buffer[temp++] = matrix[init + n1 + (temp2++)];
    }
    for (i = 0; i < n1+n2; i++){
        matrix[init + i] = buffer[i];
    }
}

ORDENAMIENTO RAPIDO
public static void Rapido(int matrix[], int a, int b){
    matrix = new int[matrix.length];
    int buf;
    int from = a;
    int to = b;
    int pivot = matrix[(from+to)/2];
    do{
        while(matrix[from] < pivot){
            from++;
        }
        while(matrix[to] > pivot){
            to--;
        }
        if(from < = to){
            buf = matrix[from];
            matrix[from] = matrix[to];
            matrix[to] = buf;
            from++; to--;
        }
    }while(from < = to);
    if(a < to){
        Rapido(matrix, a, to);
    }
    if(from < b){
        Rapido(matrix, from, b);
    }
} 

COMPLEJIDAD
Cada algoritmo de ordenamiento por definición tiene operaciones y cálculos mínimos y máximos que realiza (complejidad), a continuación una tabla que indica la cantidad de cálculos que corresponden a cada método de ordenamiento:

Algoritmo
Operaciones máximas
Burbuja
Ω(n2)
Inserción
Ω(n2/4)
Selección
Ω(n2)
Shell
Ω(n log2n)
Merge
Ω(n logn)
Quick
Ω(n2) en peor de los casos y Ω(n logn) en el promedio de los casos.
 Se puede decir que faltan metodos de ordenamiento pero estos son los mas usuales. Gracias.

Seguir Leyendo...

domingo, 19 de junio de 2011

Mini Calculadora [VB.net]

Descripción Del Ejemplo Es Una Calculadora Donde Nos Muestra 3 TextBox, Los Cuales 2 Serán Para Ingresar Los Números Y En Uno Se Mostrara El Resultado


Controles Y Sus Propiedades A Modificar 


Propiedades
1 label1Text = Numero 1
2 label2Text = Numero 2
3 TextBox1Name = TxtN1
4 TextBox2Name = TxtN2
5 Label3Text=
6 TextBox3Name = TxtResultado
7 Button1Name= BtnSuma

Text = +
8 Button2Name = BtnResta

Text = -
9 Button3Name = BtnMulti

Text = *
10 Button4Name = BtnDivi

Text = /
Para Realizar Este Ejemplo debemos tener en cuenta que Vb.net Tiene Operadores Aritméticos Para Cada Operación.

OperadorDescripción
+Suma
-Resta
*Multiplicación
/División Real
\División Entera
^Potenciación
ModResto De La División
Código Fuente De La Calculadora
Private Sub BtnSuma_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles BtnSuma.Click
Label3.Text = BtnSuma.Text
TxtResultado.Text = CInt(TxtN1.Text) + CInt(TxtN2.Text)
End Sub

Private Sub BtnResta_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles BtnResta.Click
Label3.Text = BtnResta.Text
TxtResultado.Text = CInt(TxtN1.Text) - CInt(TxtN2.Text)
End Sub

Private Sub BtnMulti_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles BtnMulti.Click
Label3.Text = BtnMulti.Text
TxtResultado.Text = CInt(TxtN1.Text) * CInt(TxtN2.Text)
End Sub

Private Sub BtnDivi_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles BtnDivi.Click
Label3.Text = BtnDivi.Text
TxtResultado.Text = CInt(TxtN1.Text) / CInt(TxtN2.Text)
End Sub
 
Resultado:



Seguir Leyendo...

sábado, 18 de junio de 2011

Formulario Simple Que Da Un Mensaje De Saludo [Vb.Net]

Hola Que Tal , Para Iniciarnos En El Mundo De la Programación. Debemos Comenzar Con Ejemplos Simples.

En Este Ejemplo Comenzaremos Con Un Programa Muy Simple.

  • Para Eso Debemos Iniciar Visual Studio 2008.net Que es En Mi Caso.

  • Crearemos Un Nuevo Proyecto.
    Menú Archivo/Nuevo Proyecto (Ctrl + N)



  • Seleccionamos El Lengua De Programación, Tipo De Aplicación y Colocamos El Nombre Del Proyecto
     
  • Diseñamos Un Formulario Simple Que Contenga Los Siguientes Controles.
    • 1 Label
    • 2 Button
    • 1 TextBox


      Para Cambiarle El Texto Que Se Muestra En Cada Uno, Solo Es Necesario Ir a La Propiedad Text De Cada Control Y Colocarle El Que Mejor Se Prefiera.

      Deben Seleccionar El Control Dándole Clic E ir A La Ficha De Propiedades Y Buscar La Propiedad Text.


      Y Nos Quedara Algo Así.
  • Ahora Comenzaremos Con La Programación. Para Este Ejemplo (Ingresaremos El Nombre Y Nos Devolverá Un Saludo) Simple No?
    Comenzaremos Con Darle Doble clic En Cada Button, Uno Para Saludar Y Otro Para Cerrar El Formulario.
Private Sub Button1_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button1.Click
MessageBox.Show("Hola " + TextBox1.Text + "!!!")
End Sub

Private Sub Button2_Click(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles Button2.Click
Me.Close()
End Sub



    • Ejecutamos El Formulario(Tecla F5)
        Este Fue Mi Primer Programa. Espero Les Sirva y Disculpen Si No lo Explico Muy Bien.

    Seguir Leyendo...

    viernes, 17 de junio de 2011

    Metodo De Ordenamiento Por Seleccion [C#]

    El ordenamiento por selección (Selection Sort en inglés ) es un algoritmo de ordenamiento que requiere operaciones para ordenar una lista de n elementos(Osea En Arreglos);

    Su funcionamiento es el siguiente:

    Buscar el mínimo elemento de la lísta
    Intercambiarlo con el primero
    Buscar el mínimo en el resto de la lista
    Intercambiarlo con el segundo

    Y en general:

    Buscar el mínimo elemento entre una posición i y el final de la lista
    Intercambiar el mínimo con el elemento de la posición i

    En Lo general El Algoritmo Es este:

    int minimo=0;
    for(i=0 ; i<n-1 ; i++)
    {
       minimo=i;
       for(j=i+1 ; j<n ; j++)
       {
          if (x[minimo] > x[j]) minimo=j;
       }
       temp=x[minimo];
       x[minimo]=x[i];
       x[i]=temp;
    }
    

    Ahora Aplicado En Un Problema Que tube En Modo Consola:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication1
    {
        class Program
        {
    
            static void Main(string[] args)
            {
                Console.Title = "Programa";
                Console.Write("Ingrese Numero De Alumnos: ");
                int num = int.Parse(Console.ReadLine());
                Console.WriteLine("\nNombre\t\t\tN1\tN2\tN3\tPromedio");
                Console.WriteLine("======\t\t\t==\t==\t==\t========");
                string[] nom = new string[15];
                double[] n1 = new double[15];
                double[] n2 = new double[15];
                double[] n3 = new double[15];
                double[] prom = new double[15];
                double x;
                for (int i = 0; i < num; i++)
                {
                    Console.Write("");
                    nom[i] = Console.ReadLine();
                    Console.SetCursorPosition(24, 4 + i);
                    Console.Write("");
                    n1[i] = int.Parse(Console.ReadLine());
                    Console.SetCursorPosition(32, 4 + i);
                    Console.Write("");
                    n2[i] = int.Parse(Console.ReadLine());
                    Console.SetCursorPosition(40, 4 + i);
                    Console.Write("");
                    n3[i] = int.Parse(Console.ReadLine());
                    Console.SetCursorPosition(48, 4 + i);
                    x = (n1[i] + n2[i] + n3[i]) / 3;
                    Console.Write(Math.Round(x, 2));
                    prom[i] = x;
                    Console.WriteLine();
                }
                Console.WriteLine("\nPrecione Una Tecla Para Comenzar...");
                Console.ReadKey();
                int n = num;
                for (int i = 0; i < n - 1; i++)
                 {
                 int posMin = i;
                  for (int j = i + 1; j < n; j++)
                   {
                        if (prom[j] [color=red]>[/color] prom[posMin])
                       {
                            posMin = j;
                        }
                   }
                    double iaux = prom[i];
                    prom[i] = prom[posMin];
                    prom[posMin] = iaux;
                    string naux = nom[i];
                    nom[i] = nom[posMin];
                    nom[posMin] = naux;
                    double n1aux = n1[i];
                    n1[i] = n1[posMin];
     
                    n1[posMin] = n1aux;
                    double n2aux = n2[i];
                    n2[i] = n2[posMin];
     
                    n2[posMin] = n2aux;
                    double n3aux = n3[i];
     
                    n3[i] = n3[posMin];
                    n3[posMin] = n3aux;
     
                }
                Console.WriteLine("\nNombre\t\t\tN1\tN2\tN3\tPromedio");
                Console.WriteLine("======\t\t\t==\t==\t==\t========");
                int lineas= num + 7;
                for (int i = 0; i < n; i++)
                {
                    Console.SetCursorPosition(0, lineas + i);
                    Console.Write(nom[i]);
                    Console.SetCursorPosition(24, lineas + i);
                    Console.Write(n1[i]);
                    Console.SetCursorPosition(32, lineas + i);
                    Console.Write(n2[i]);
                    Console.SetCursorPosition(40, lineas + i);
                    Console.Write(n3[i]);
                    Console.SetCursorPosition(48, lineas + i);
                    Console.Write(Math.Round(prom[i],2));
                    Console.WriteLine();
                }
                Console.ReadLine();
     
            }
        }
    }

    Lo Que Se realizo En Este Pequeño Programa Fue :
    Ingreso El Numero De Alumnos.
    Y Despues De Acabar Se Muestra Asi.
    Disculpen que no Trabajo Con Clases Es Que Soy Muy nuevo en Esto
    Ejecucion.
    Bueno Eso es en Orden Desendente Si Quieren En Acsendente Cambien Solo El Simbolo De "<" x ">"

    La Imagen De Muestra...

    Estoo

    Seguir Leyendo...