miércoles, 27 de noviembre de 2013

Método de Ordenación Inserción Binaria en C++

Hola amig@s aquí esta otro de los métodos de ordenación interna en esta ocasión se trata de Inserción Binaria este método es una mejora del método de ordenación por  inserción directa.

La mejora consiste en realizar una búsqueda binaria en lugar de una  búsqueda secuencial,para insertar el elemento en la posición que le corresponde.

Imagen:


Codigo:

InsercionBinaria.cpp:

#include "InsercionBinaria.h"
void main(){
 InsercionBinaria IB;
 int n;
 do{cout<<"Cuantos elementos desea ingresar: ";cin>>n;}while(n<1||n>100);
 for(int i=0;i<n;i++){
  cout<<endl<<"Dato["<<i+1<<"]: ";cin>>IB.vector[i];
 }
 system("cls");
 cout<<endl<<endl<<"Vector original:"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<IB.vector[i]<<" ";
 }
 IB.insercionBinaria(IB.vector,n);
 cout<<endl<<endl<<"Vector Ordenado Con Metodo de Insercion Binaria:"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<IB.vector[i]<<" ";
 }
 system("pause>null");
}


InsercionBinaria.h

#include <iostream>
#include <windows.h>
using namespace std;
class InsercionBinaria{
public:
 int vector[100],i,j,aux,izq,der,m;
 void insercionBinaria(int[], int );
 void mostrar(int[], int );
};

void InsercionBinaria::insercionBinaria(int V[],int N){
 for(i=1;i<N;i++){
  aux = V[i];
  izq=0;
  der=i-1;
  while(izq<=der){
   m=((izq+der)/2);
   if (aux<V[m])
    der=m-1;
   else
    izq=m+1;              
  }
  j=i-1;
  while(j>=izq){
   V[j+1]=V[j];
   j=j-1;
  }
  V[izq]=aux;
 }  
}

void InsercionBinaria::mostrar(int V[],int N){
 for(int i=0;i<N;i++){
  cout<<V[i]<<" ";
 }
}

descarga el código fuente desde aquí.

Metodo de Ordenacion por Insercion Directa en C++

Hola amig@s en esta ocasión les traigo otro método de ordenación interna como lo es el de Inserción Directa es un algoritmo relativamente sencillo y se comporta razonablemente bien en gran cantidad de situaciones.

 Se basa en intentar construir una lista ordenada en el interior del array a ordenar.

 De estos tres algoritmos es el que mejor resultado da a efectos prácticos. Realiza una cantidad de comparaciones bastante equilibrada con respecto a los intercambios, y tiene un par de características que lo hacen aventajar a los otros dos en la mayor parte de las situaciones.

 Este algoritmo se basa en hacer comparaciones, así que para que realice su trabajo de ordenación son imprescindibles dos cosas: un array o estructura similar de elementos comparables y un criterio claro de comparación, tal que dados dos elementos nos diga si están en orden o no.


Imagen:


Código:

InsercionDirecta.cpp:

#include "InsercionDirecta.h" void main(){ InsercionDirecta ID; int n; do{cout<<"Cuantos elementos desea ingresar: ";cin>>n;}while(n<1||n>100); for(int i=0;i<n;i++){ cout<<endl<<"Dato["<<i+1<<"]: ";cin>>ID.vector[i]; } system("cls"); cout<<endl<<endl<<"Vector original:"<<endl<<endl; for(int i=0;i<n;i++){ cout<<ID.vector[i]<<" "; } ID.insercionDirecta(ID.vector,n); cout<<endl<<endl<<"Vector Ordenado Con Metodo de Insercion Directa:"<<endl<<endl; for(int i=0;i<n;i++){ cout<<ID.vector[i]<<" "; } system("pause>null"); }

InsercionDirecta.h

#include <iostream> #include <windows.h> using namespace std; class InsercionDirecta{ public: int vector[100],i,j; void insercionDirecta(int[], int ); void mostrar(int[], int ); }; void InsercionDirecta::insercionDirecta(int V[],int N){ int i,j,v; for (i = 1; i < N; i++){ v = V[i]; j = i - 1; while (j >= 0 && V[j] > v){ V[j + 1] = V[j]; j--; } V[j + 1] = v; } } void InsercionDirecta::mostrar(int V[],int N){ for(int i=0;i<N;i++){ cout<<V[i]<<" "; } }

Descarga el código fuente desde aquí.

martes, 26 de noviembre de 2013

Método de Ordenamiento Shell Sort en C++

Hola amig@s esta vez les traigo otro método de ordenación interna como lo es el Shell sort este método es una generalización del ordenamiento por inserción, teniendo en cuenta dos observaciones:

1- El ordenamiento por inserción es eficiente si la entrada está "casi ordenada".
2- El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez.

El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados.





Codigo:

ShellSort.cpp:


#include "ShellSort.h" void main(){ ShellSort SS; int n; do{cout<<"Cuantos elementos desea ingresar: ";cin>>n;}while(n<1||n>100); for(int i=0;i<n;i++){ cout<<endl<<"Dato["<<i+1<<"]: ";cin>>SS.vector[i]; } system("cls"); cout<<endl<<endl<<"Vector original:"<<endl<<endl; for(int i=0;i<n;i++){ cout<<SS.vector[i]<<" "; } SS.shellSort(SS.vector,n); cout<<endl<<endl<<"Vector Ordenado Con Metodo de ShellSort:"<<endl<<endl; for(int i=0;i<n;i++){ cout<<SS.vector[i]<<" "; } system("pause>null"); }


ShellSort.h:


#include <iostream> #include <windows.h> using namespace std; class ShellSort{ public: int vector[100],temp,inc,i,j; void shellSort(int[], int ); void mostrar(int[], int ); }; void ShellSort::shellSort(int V[], int N){ for(inc = 1 ; inc<N;inc=inc*3+1); while (inc > 0){ for ( i=inc; i < N; i++){ j = i; temp = V[i]; while ((j >= inc) && (V[j-inc] > temp)){ V[j] = V[j - inc]; j = j - inc; } V[j] = temp; } inc/= 2; } } void ShellSort::mostrar(int V[],int N){ for(int i=0;i<N;i++){ cout<<V[i]<<" "; } }

Descarga el código fuente desde aquí.

Metodo de Burbuja (Bubble Sort) en C++

Hola amig@s esta ves les traigo el Método de Ordenación de Burbuja o Bubble Sort (en ingles) este método funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.


Imagen:



Código:

BubbleSort.cpp:



#include "Bubblesort.h" void main(){ BubbleSort BS; int n; do{cout<<"Cuantos elementos desea ingresar: ";cin>>n;}while(n<1||n>100); for(int i=0;i<n;i++){ cout<<endl<<"Dato["<<i+1<<"]: ";cin>>BS.vector[i]; } system("cls"); cout<<endl<<endl<<"Vector original:"<<endl<<endl; for(int i=0;i<n;i++){ cout<<BS.vector[i]<<" "; } BS.bubbleSort(BS.vector,n); cout<<endl<<endl<<"Vector Ordenado Con Metodo de la burbuja:"<<endl<<endl; for(int i=0;i<n;i++){ cout<<BS.vector[i]<<" "; } system("pause>null"); }


BubbleSort.h:



#include <iostream> #include <windows.h> using namespace std; class BubbleSort{ public: int vector[100],tmp; void bubbleSort(int[],int); void mostrar(int[],int); }; void BubbleSort::bubbleSort(int V[],int N){ for(int i=0;i<N;i++){ for(int j=i+1;j<N;j++){ if(V[i]>V[j]){ tmp=V[i]; V[i]=V[j]; V[j]=tmp; } } } } void BubbleSort::mostrar(int V[],int N){ for(int i=0;i<N;i++){ cout<<V[i]<<" "; } }


Descarga el código fuente desde aquí.

domingo, 24 de noviembre de 2013

Quicksort en C++

Hola amig@s esta vez les traigo uno de los métodos de ordenación interna en esta ocasión se trata del Quicksort. este método se basa en dividir los n elementos de la lista a ordenar en dos partes o particiones separadas por un elemento.

La ordenación rápida implica la selección de un elemento de una lista y a continuación reordenar todos los elementos restantes de la sublista. De tal modo que todos los elementos que son más pequeños que el elemento dado se ponen en una sublista y todos los elementos que son más grandes que el elemento dado se ponen en una segunda sublista. Por consiguiente. El método elige un elemento denominado pivote pone en una sub lista todos los elementos mayores que el pivote y los elementos más pequeños en otra sublista.

El algoritmo trabaja de la siguiente forma:

- Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.
-Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que él, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementación deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.
-La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.
-Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.


Imagen:


Codigo:

Quicksort.cpp:

#include<iostream>
#include"Quicksort.h"
using namespace std;

void main(){
 int i;
 Quicksort q;
 int c;
 cout<<"cuantos datos: ";
 cin>>c;
 for(i=0;i<c;i++){
  system("cls");
  cout<<"dato["<<i+1<<"]: ";
  cin>>q.lista[i];  
 } system("cls");
 cout<<endl;
 q.quicksort(q.lista,0,c-1);
 /**/cout<<endl;
 cout<<endl<<"Arreglo ordenado"<<endl<<endl;
 for(i=0;i<c;i++){
  cout<< q.lista[i]<<"  ";
 }cout<<endl<<endl;
 system("pause>null");
}



Quicksort.h:


#include<iostream>
#include<windows.h>
using namespace std;
#define MAX 100
class Quicksort{
public:
 int i,j,pivote,centro,primero,ultimo,temp;
 int lista[MAX];
 void quicksort(int[] ,int ,int );
};

void Quicksort::quicksort(int lista[],int primero,int ultimo){
 centro=(primero+ultimo)/2;
 pivote=lista[centro];
 i=primero;
 j=ultimo;
 cout<<endl<<endl<<"****************************************************"<<endl<<endl<<"ARREGLO: "<<endl<<endl;
 for(int k=primero; k<=ultimo; k++){
  cout<<lista[k]<<"\t";
 }
 cout<<endl<<endl<<"pivote: "<<pivote<<endl<<"primero: "<<primero<<endl<<"ultimo: "<<ultimo<<endl;
 Sleep(1500);cout<<endl;
 do{
  while(lista[i]<pivote){i++;}
  while(lista[j]>pivote){j--;}
  if(i<=j){
   cout<<endl<<"Cambio de "<<lista[i]<<" por "<<lista[j]<<endl;
   temp=lista[i];
   lista[i]=lista[j];
   lista[j]=temp;
   i++;
   j--;
  }
 }while(i<=j);
 if(primero<j){
  quicksort(lista,primero,j);
 }
 if(i<ultimo){
  quicksort(lista,i,ultimo);
 }
}


Descarga el código fuente desde aquí.

sábado, 23 de noviembre de 2013

HeapSort en C++

Hola amig@s esta vez les traigo otro de los metodos de ordenacion interna en esta ocasion se trata del Heapsort este metodo es el mas eficiente de todos los metodos de ordenacion interna ya que consiste en almacenar todos los elementos del vector de N elementos a ordenar en un montículo (heap), y luego extraer el nodo que queda como nodo raíz del montículo (cima) en sucesivas iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento en una propiedad de los montículos, por la cual, la cima contiene siempre el menor elemento (o el mayor, según se haya definido el montículo) de todos los almacenados en él.

La estructura de un monticulo es similar a la de un arbol biario por lo que tendra un nodo padre y 2 nodo hijos en nuestro caso tomaremos nuestro monticulo como maximal esto quiere decir que para construir dicho monticulo  el nodo padre siempre tendra que ser mayor que sus hijos cuando se cumpla dicha condicion extraeremos el nodo raiz (al decir extraer es intercambiar el nodo raiz que se encuentra en la primera posicion del vector por el ultimo de dicho vector) y volveremos a reconstruir el monticulo esta vez con el vector de N-1 y asi sucesivamente hasta que quede completamente ordenado.


Imagen:


Codigo:

Heapsort.cpp

#include"Heapsort.h"
#include<iostream>
using namespace std;
void main(){
 Heapsort h;
 int c;
 cout<<"cuantos datos: ";
 cin>>c;
 for(int i=1;i<=c;i++){
  system("cls");
  cout<<"dato["<<i<<"]: ";
  cin>>h.lista[i];
 }
 system("cls");
 /**/cout<<"Lista Original"<<endl<<endl;
 for(int i=1;i<=c;i++){
  cout<< h.lista[i]<<"  ";
 }
 h.heapsort(h.lista,c);
 cout<<endl;
 cout<<endl<<"Lista Ordenada"<<endl<<endl;
 for(int i=1;i<=c;i++){
  cout<< h.lista[i]<<"  ";
 }cout<<endl<<endl;
 system("pause");
}


Heapsort.h:

#include<iostream>
#include<windows.h>
using namespace std;
#define MAX 100
class Heapsort{
public:
 int lista[MAX]; 
 int j,temp,hijo;
 bool esmonticulo;
 void heapsort(int[] ,int );
 void monticulo(int[] ,int ,int );
};
void Heapsort::monticulo(int lista[],int primero,int ultimo){
 cout<<endl<<endl<<"Nuevo Monticulo"<<endl<<endl;
 esmonticulo=false;
 for(int k=primero; k<=ultimo; k++){
  cout<<lista[k]<<"\t";
 }cout<<endl;
 while((primero<=ultimo/2)&&!esmonticulo){
  if(2*primero==ultimo){
   hijo=2*primero;
  }
  else{
   if(lista[2*primero]>lista[2*primero+1]){
    hijo=2*primero; 
   }else{
    hijo=2*primero+1;
   }
  }if(lista[primero]<lista[hijo]){
   cout<<endl<<endl<<"Cambio de "<<lista[primero]<<" por "<<lista[hijo]<<endl<<endl;
   temp=lista[primero];
   lista[primero]=lista[hijo];
   lista[hijo]=temp;
   primero=hijo;
  }else{
   esmonticulo=true;
  }
 }
}

void Heapsort::heapsort(int lista[],int n){
 for(j=n/2;j>=0;j--){
  monticulo(lista,j,n);
 }
 for(j=n;j>=1;j--){
  temp=lista[0];
  lista[0]=lista[j];
  lista[j]=temp;
  cout<<endl<<"Sacamos al dato "<<lista[j]<<" de la lista."<<endl<<endl;
  cout<<endl<<"************************************************************"<<endl<<"Nueva Lista: "<<endl<<endl;
  for(int k=0; k<j; k++){
  cout<<lista[k]<<"\t";
  }Sleep(2000);cout<<endl;
  monticulo(lista,0,j-1);
 }
 
}


Descarga el código fuente desde aquí:

miércoles, 6 de noviembre de 2013

SplashSreen en Java con Barra de Carga Utilizando Hilos (Threads)

Hola amig@s esta vez les les mostrare como hacer que sus aplicaciones parezcan un poco mas profesionales añadiendoles un SplashScreen para ello vamos a utilizar hilos para hacer que se complete una barra de progreso y utilizaremos una imagen .png con transparencia para utilizarla como un logo (No es necesario que la imagen sea con transparencia ni tiene que ser únicamente .png, todo queda al gusto de cada quien).

Capturas:





Descarga el código desde aquí.