miércoles, 18 de diciembre de 2013

Método de Ordenación Radix en C++

Hola amig@s para terminar la entrega de Métodos de ordenación lo haremos con el método Radix. En informática, el ordenamiento Radix (radix sort en inglés) es un algoritmo de ordenamiento que ordena enteros procesando sus dígitos de forma individual. Como los enteros pueden representar cadenas de caracteres (por ejemplo, nombres o fechas) y, especialmente, números en punto flotante especialmente formateados, radix sort no está limitado sólo a los enteros.

La mayor parte de los ordenadores digitales representan internamente todos sus datos como representaciones electrónicas de números binarios, por lo que procesar los dígitos de las representaciones de enteros por representaciones de grupos de dígitos binarios es lo más conveniente. Existen dos clasificaciones de radix sort: el de dígito menos significativo (LSD) y el de dígito más significativo (MSD). Radix sort LSD procesa las representaciones de enteros empezando por el dígito menos significativo y moviéndose hacia el dígito más significativo. Radix sort MSD trabaja en sentido contrario.

Las representaciones de enteros que son procesadas por los algoritmos de ordenamiento se les llama a menudo "claves", que pueden existir por sí mismas o asociadas a otros datos. Radix sort LSD usa típicamente el siguiente orden: claves cortas aparecen antes que las claves largas, y claves de la misma longitud son ordenadas de forma léxica. Esto coincide con el orden normal de las representaciones de enteros, como la secuencia "1, 2, 3, 4, 5, 6, 7, 8, 9, 10". Radix sorts MSD usa orden léxico, que es ideal para la ordenación de cadenas de caracteres, como las palabras o representaciones de enteros de longitud fija. Una secuencia como "b, c, d, e, f, g, h, i, j, ba" será ordenada léxicamente como "b, ba, c, d, e, f, g, h, i, j". Si se usa orden léxico para ordenar representaciones de enteros de longitud variable, entonces la ordenación de las representaciones de los números del 1 al 10 será "1, 10, 2, 3, 4, 5, 6, 7, 8, 9", como si las claves más cortas estuvieran justificadas a la izquierda y rellenadas a la derecha con espacios en blanco, para hacerlas tan largas como la clave más larga, para el propósito de este ordenamiento.



Imagen:



Código:

RadixSort.cpp:

#include "RadixSort.h"
void main(){
 RadixSort RS;
 RS.inicia();
}


RadixSort.h:
#include <iostream>
#include <windows.h>
#include <math.h>
using namespace std;
#define MAX 100

struct{
 int inf;
 int sig;
}nodo[MAX];

class RadixSort{
public:
 int vector[MAX], post[MAX],frente[MAX];
 void inicia(void);
 void radixSort(int[] ,int);
};

void RadixSort::inicia(){
 int n;
 cout<<"Ingrese el numeo de elementos que desea insertar: ";cin>>n;
 for(int i=0;i<n;i++){
  cout<<endl<<"Elemento["<<i+1<<"]: ";cin>>vector[i];
 }
 system("cls");
 cout<<endl<<endl<<"Elementos desordenados:"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<endl<<vector[i];
 }
 radixSort(vector,n);
 cout<<endl<<endl<<"Elementos ordenados por metodo Radix Sort:"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<endl<<vector[i];
 }
 system("pause>null");
}

void RadixSort::radixSort(int V[], int N){
 int exp, primero, p, q, y,j,i,k;
 for (int i = 0; i < N-1; i++) {
  nodo[i].inf = V[i];
  nodo[i].sig = i+1;
 }
 nodo[N-1].inf = V[N-1];
 nodo[N-1].sig = -1;
 primero = 0;
 for ( k = 1; k < 5; k++) {
  for ( i = 0; i < 10; i++) {
   post[i] = -1;
   frente[i] = -1;
  }

  while (primero != -1) {
   p = primero;
   primero = nodo[primero].sig;
   y = nodo[p].inf;
   exp = pow((double)10, k-1);
   j = (y/exp) % 10;
   q = post[j];
   if (q == -1)
    frente[j] = p;
   else
    nodo[q].sig = p;
   post[j] = p;
  }

  for (j = 0; j < 10 && frente[j] == -1; j++);
  ;//no hacemos nada unicamente nos desplazamos x el vector hasta q salga del ciclo
  primero = frente[j];
  while (j <= 9) {
   for ( i = j+1; i < 10 && frente[i] == -1; i++);
   ;//no hacemos nada unicamente nos desplazamos x el vector hasta q salga del ciclo
   if (i <= 9){
    p = i;
    nodo[post[j]].sig = frente[i];
   }
   j = i;
  }
  nodo[post[p]].sig = -1;
 }
 for ( i = 0; i < N; i++) {
  V[i] = nodo[primero].inf;
  primero = nodo[primero].sig;
 }
}

Descarga el código desde aquí.

miércoles, 4 de diciembre de 2013

Metódo de Ordenación Comb Sort en C++

Hola amig@s continuando con la entrega de los metodós de ordenación esta vez es el turno de el metodo de Comb Sort este metódo en ciencias de la computación, el comb sort (comb=peine) es un algoritmo de ordenamiento relativamente simple diseñado por Wlodzimierz Dobosiewicz en 1980. Posteriormente fue redescubierto y popularizado por Stephen Lacey y Richard Box en un artículo publicado por la revista Byte en abril de 1991. El algoritmo comb sort mejora el algoritmo de ordenamiento de burbuja y rivaliza en velocidad con algoritmos más complejos como el Quicksort. La idea básica es eliminar tortugas, o pequeños valores cerca del final de la lista, ya que en el algoritmo de ordenamiento de burbuja esto reduce la velocidad de ordenamiento tremendamente. (Los conejos, grandes valores alrededor del inicio de la lista, no plantean un problema en el algoritmo de ordenamiento de burbuja.)
En el ordenamiento de burbuja, cuando dos elementos cualquiera se comparan, siempre tienen un espacio (distancia entre ellos) de 1. La idea básica del algoritmo comb sort es que el espacio pueda ser mucho mayor de uno. El ordenamiento Shell también se basa en esta idea, pero es una modificación del algoritmo de ordenamiento por inserción más que del algoritmo de ordenamiento de burbuja.
El espacio se inicia como la longitud de la lista a ordenar dividida por el factor de encogimiento (generalmente 1,3 o 1.3), y la lista se ordena con este valor (redondeado a la baja a un entero si es necesario) para el espacio. Después el espacio se divide por el factor de encogimiento de nuevo, la lista se ordena con este nuevo espacio, y el proceso se repite hasta que el espacio es 1. En este momento, el algoritmo comb sort continua usando un espacio de 1 hasta que la lista está completamente ordenada. La etapa final del ordenamiento es así equivalente al algoritmo de ordenamiento de burbuja, pero en este momento la mayoría de las tortugas ya han sido tratadas, de manera que un algoritmo de ordenamiento de burbuja será eficiente.




Imagen:



Código:

CombSort.cpp:
#include "CombSort.h"
void main(){
 CombSort CS;
 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>>CS.Vector[i];
 }
 system("cls");
 cout<<endl<<endl<<"Vector original:"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<CS.Vector[i]<<" ";
 }
 CS.combSort(CS.Vector,n);
 cout<<endl<<endl<<"Vector Ordenado Con El Metodo Comb Sort :"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<CS.Vector[i]<<" ";
 }
 system("pause>null");
}

CombSort.h:
#include <iostream>
#include <windows.h>
using namespace std;
class CombSort{
public:
 int Vector[100];
 void combSort(int[], int );
};
void CombSort::combSort(int v[], int N){
    const float reducir = 1.3f;
    int aux;
    int i, brecha = N;
    bool intercambiado = false;
 
    while ((brecha > 1) || intercambiado) {
        if (brecha > 1) {
            brecha = (int)((float)brecha / reducir);
        }
 
        intercambiado = false;
 
        for (i = 0; brecha + i < N; ++i) {
            if (v[i] - v[i + brecha] > 0) {
                aux = v[i];
                v[i] = v[i + brecha];
                v[i + brecha] = aux;
                intercambiado = true;
            }
        }
    }
}

descarga el código fuente desde aquí.

Metodo de Ordenacion Shaker Sort en C++

Hola amig@s en esta ocasión y continuando con los métodos de ordenación les mostare el Shaker sort es también, y mejor, conocido como Cocktail Sort y en castellano como Burbuja Didireccional o Sacudida es la mejora del método de burbuja en el que el proceso se realiza desde la primera posición a la última de la disposición en la dirección opuesta, impidiendo así artículos más pequeños se lleva más tiempo para "subir" a las primeras posiciones.






Imagen:



Código:

ShakerSort.cpp:
#include "ShakerSort.h"
void main(){
 ShakerSort SK;
 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>>SK.vector[i];
 }
 system("cls");
 cout<<endl<<endl<<"Vector original:"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<SK.vector[i]<<" ";
 }
 SK.shakerSort(SK.vector,n);
 cout<<endl<<endl<<"Vector Ordenado Con El Metodo Shaker Sort (Sacudida):"<<endl<<endl;
 for(int i=0;i<n;i++){
  cout<<SK.vector[i]<<" ";
 }
 system("pause>null");
}

ShakerSort.h:
#include <iostream>
#include <windows.h>
using namespace std;
class ShakerSort{
public:
 int vector[100];
 void shakerSort(int[] ,int );
};
void ShakerSort::shakerSort(int v[],int N){
 int i = 0 , izq = 1 , der = N-1 , k = N-1 , aux = 0;
 while( der >= izq ){      
  for( i = der ; i>= izq ; i-- )          
   if( v[i-1] > v[i]){
    aux = v[i-1];      
    v[i-1]=v[i];
    v[i]=aux;
    k=i;
   }
   izq = k + 1;
   for( i = izq ; i <= der ; i++)
    if( v[i-1] > v[i] ){
     aux = v[i-1];
     v[i-1]=v[i];
     v[i]=aux;
     k=i;
   }
    der = k-1;
 }
}

Descarga el código fuente desde aquí.

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í.

domingo, 13 de octubre de 2013

Libreria Console.h v1.0 C++

Hola amig@s esta vez les traigo algo distinto que solo subir código de programas. En esta ocasión quiero compartir con ustedes un conjunto de funciones que he recopilado y otras que de alguna forma he escrito a mi conveniencia y decidí crear una librería estática pero esto no quiere decir que solo subiré el .h y el .lib y que ustedes tengan que linkear la librería para poder utilizar las funciones contenidas en dicha librería sino que pondré 3 diferentes formas de descarga la primera sera descargar todo el proyecto que por el momento esta en VS2010 express; la segunda el .lib con sus respectivos archivos fuentes y la tercera forma son únicamente los archivos fuentes.

Archivos Contenidos:

- CONSOLE.h : contiene todos los prototipos de las funciones de la librería.

- CONSOLE.cpp : contiene todas las definiciones de las funciones.

- Keyboard.h : contiene las definiciones de los códigos de algunas teclas. En la próxima versión espero poder completado esta cabecera ya que solo resta incluir las teclas especiales (alt,ctrl,f1,etc), también símbolos entre otras.

- testLIB.cpp : contiene un pequeño ejemplo de como utilizar el mouse en consola y del teclado.

Funciones:


void initConsole( void );//iniciamos los manejadores de entrada y salida de la consola 
void Color( int );//Cambiamos el color de la fuente 
void OcultaCursor( void );//Ocultamos el cursor
void gotoxy( int , int );//Posicionamos el cursor en las cordenadas x y
void clearToColor( int );//Borramos la consola por un color de 0 a 15 (0 = Negro, 15 = Blanco Brillante)
void textOut(int, int, char*, int );//Mostramos texto en las cordenada x y 
void ErrorExit ( char*, char* );//Si ocurre un error Mostramos un mensaje y salimos de la aplicacion
void drawRect( int[2], int[2], int );//Dibuja un un rectangulo del color que querramos
void drawRect( int[2], int[2], char*, int );//Dibuja un un rectangulo del color que querramos y le enviamos el caracter que queremos de muestre  
void drawFillRect( int[2], int[2], int );//Dibuja un un rectangulo relleno del color que querramos
void drawFillRect( int[2], int[2], char*, int );//Dibuja un un rectangulo relleno del color que querramos y le enviamos el caracter que queremos de muestre
void drawLineH( int[2], int, int );//Dibuja una linea horizontal del color que querramos
void drawLineH( int[2], int, char*, int );//Dibuja una linea horizontal del color y caracter que querramos
void drawLineV( int, int[2], int );//Dibuja una linea vertical del color que querramos
void drawLineV( int, int[2], char*, int );//Dibuja una linea vertical del color y caracter que querramos
COORD CoordMouse( void );//obtiene las coordenadas del mouse
void readConsole( void );//leemos los eventos que estan ocurriendo en la consola
bool keypressed( void );//vemos si se ha presionado una tecla
int readKey( void );//leemos el codigo de la tecla presionada
bool dobleClick( void );//vemos si se ha hecho doble click
int click( void );//vemos si se ha hecho click izq retorna 1 y si es derch retorna 2



Capturas:








Codigo:


#include
#include"CONSOLE.h"
using namespace std; 
int main(){
	int x[]={3,15},y[]={3,20},x2[]={20,32},y2[]={3,20};
	int f=0;
	COORD cr;
	/**/textOut(10,0,"Dibujando rectangulos",6);
	drawRect(x,y,7);
	drawRect(x2,y2,"*",9);
	Sleep(3000);
	clearToColor(1);
	textOut(10,0,"Dibujando rectangulos rellenos",6);
	drawFillRect(x,y,7);
	drawFillRect(x2,y2,"*",9);
	Sleep(3000);
	clearToColor(1);
	textOut(10,0,"Dibujando Lineas Horizontales",6);
	drawLineH(x,3,9);
	drawLineH(x2,3,"M",7);
	Sleep(3000);
	clearToColor(1);
	textOut(10,0,"Dibujando Lineas Verticales",6);
	drawLineV(3,y,9);
	drawLineV(6,y,"N",8);
	Sleep(2000);
	clearToColor(1);
	textOut(10,10,"Uso del mouse y teclado",6);
	Sleep(4000);
	clearToColor(1);
	fflush(stdin);
	fflush(stdout);
	/*Libera la vieja consola y comienza con una nueva ya 
	que por el momento hay conflicto la funcion clearToColor() con el uso del mouse dentro
	de la consola*/
	FreeConsole();
	AllocConsole();
	initConsole();
	do{
		Color(7);
		readConsole();
		cr=CoordMouse();
		gotoxy(1,0);cout<<"x: "<<(int)cr.X<<"Y: "<<(int)cr.Y;
		gotoxy(1,1);cout<<"tecla: "<<(char)f;
		textOut(1,2,"Para salir presione enter",8);
		
		if(click() == 1){
			cr=CoordMouse();
			gotoxy(cr.X,cr.Y);cout<<"CLICK IZQ";
		}else
			if(click() == 2){
				cr=CoordMouse();
				gotoxy(cr.X,cr.Y);cout<<"CLICK DER";
			}
		/* Reporta si se dio un doble click */
		if (dobleClick()){
			cr=CoordMouse();
			gotoxy(cr.X,cr.Y);cout<<"DOBLE CLICK ";
		}

		
		if(keypressed())
			f=readKey();
		Sleep(60);
	}while(f!=KEY_ENTER);
	ErrorExit("Saliendo del programa","TEST");
	return 0;
}



Descarga:

- Proyecto VS2010.

- Librería estática mas fuentes.

- Archivos Fuentes.

miércoles, 25 de septiembre de 2013

Recorrido por Niveles En Arboles

Hola amig@s en esta ocacion les mostrare la funcion de recorrido por niveles (anchura) en arboles.
Como funciona este recorrido pues como su nombre lo dice va por niveles comenzando por la raiz hasta llegar al ultimo nodo del arbol; primeramente ingresamos el nodo raiz en una cola, luego sacamos este valor de la cola y mostramos su contenido y ahora vemos si hay valores en los nodos izquerdo y derecho respectivamente si no son nulos insertamos sus valores en la cola repetimos esto hasta que la cola quede vacia.

Seudocodigo:

recorrido_nivel(Tarbol a)
nodo aux;
si (a != NULL)
encolar(a);
mientras (!colavacia()) hacer
aux=desencolar();
   mostrar aux
si (aux->izq != NULL) encolar(aux->izq);
si (aux->der != NULL) encolar(aux->der);
fin mientras
fin si


Capturas:



Codigo:

Recorrido por nivel:

void arbol::Recorrido_Nivel(TREE aux){
	if(aux){
	Cola cola;
	TREE a;
		cola.insertar(aux);
		while(!cola.colavacia()){
			a=cola.quitar();
			cout<valor<Izdo!=NULL){
				cola.insertar(a->Izdo);
			}
			if(a->Dcho!=NULL){
				cola.insertar(a->Dcho);
			}
		}
	}
}


Cola.h
#include 
#include 
using namespace std;

////////////////////////cola
class nodoc{
public:
	Tarbol dato;
	nodoc *siguiente;
	nodoc(Tarbol n, nodoc *sig=NULL){
		dato=n;
		siguiente=sig;
	}
};
typedef nodoc *pnodo;

class Cola{
//private:
public:
	pnodo frente;
	pnodo final;

	Cola(){
		frente=NULL;
		final=NULL;
	}
	bool colavacia();
	void insertar(int v);
	int quitar();
};


bool Cola::colavacia(){return frente==NULL;}

void Cola::insertar(int v){
	if(colavacia()){
		frente=new nodoc(v);
		final=frente;
	}else{
		final->siguiente=new nodoc(v);
		final=final->siguiente;
	}
}
Tarbol Cola::quitar(){
	pnodo aux;
	Tarbol x;
	if(colavacia())
		return 0;
	aux=frente;
	x=aux->dato;
	frente=frente->siguiente;
	delete(aux);
	return x;
}

descarga el código aquí.

lunes, 23 de septiembre de 2013

Mínimo Común Múltiplo (MCM) en C

Hola amig@s  esta vez les mostrare el código de Mínimo Común Múltiplo (MCM) en C con funciones.

Captura:


Código:

#include
#include
#include
int MCM(int x,int z);
int main(void){
      int a, b,respuesta;
 printf("\nMINIMO COMUN MULTIPLO...mcm(A,B)=\n\n");
    printf("\nA: ");
    scanf("%d",&a);
    printf("\nB: ");
            scanf("%d",&b);
            if (anull");
 return 0;
}
int MCM(int x,int z){
 int y=1, i=2;
  do{
            if (x%i==0){
                if(z%i==0){
     y=y*i;
     x=x/i; z=z/i;   
     i=2;
                }
                else i++;
            }
            else i++;
        } while(i<=x);
 return y=y*z*x;
}

Descarga el código desde aquí.

Máximo Común Divisor (MCD) en C

Hola amig@s en esta ocasión les mostrare el código para conocer el Máximo Común Divisor (MCD) en C utilizando funciones (módulos)

Captura:


Código:

#include
#include
#include
int mcd(int a,int b);
int main(void){
 int A,B,respuesta;
 printf("\nMAXIMO COMUN DIVISOR...mcd(A,B)=\n\n");
 printf("A= ");scanf("%i",&A);
 printf("\nB= ");scanf("%i",&B);
 if(B>A)
  respuesta=mcd(B,A);
 else
  respuesta=mcd(A,B);
 printf("\n\nmcd(%i,%i)=%i\n",A,B,respuesta);
 system("pause>null");
 return 0;
}
int mcd( int a, int b){
 int r;
 r=a-b*(a/b);
 if(r!=0){
  while(r!=0){
   a=r;
   r=b-r*(b/r);
  }
  return(a);
 }
 return(b);
}


Descarga el código desde aquí.

miércoles, 11 de septiembre de 2013

Juego Sudoku C++ y Allegro (Codigo)

Hola amig@s esta vez les traigo otro popular juego del Sudoku. Por el momento el juego Proporciona ayuda en las dificultades fácil y medio mostrando brevemente cuales números están correctamente colocados y cuales no en color verde los correctos y en rojo los erróneos.

En esta ocasión utilizaremos la herramienta de allegro llamada grabber con la cual podremos crear archivos binarios .dat donde podremos almacenar todos los archivos que utilizara nuestro juego y así llegar a ahorrarnos lineas de código  ya que no tendríamos que declarar estos archivos como lo son los BITMAP, FONT, etc. Dentro del código explico como utilizar los archivos dentro del archivo .dat.
 Capturas:





Descarga el juego mas el codigo aquí.

Descarga la herramienta grabber aquí.

lunes, 2 de septiembre de 2013

Mover Imagen Utilizando Hilos (Threads) en Java

Hola amig@s en esta ocasión les mostrare como mover 2 imagenes una con las teclas direccionales del teclado y la otra arrastrarla con el ratón, además de hacer un contador que nos muestre cuantos minutos y segundos la aplicaron ha estado activa, también reproducir un archivo MID todo esto con Hilos (Threads) para ello utilizaremos un IDE como entorno de programacion en mi caso utilizare netbeans.

Imagenes:




dentro de nuestro proyecto crearemos un JFrame form y en modo diseñador utilizaremos 4 JLabels, 1 JPanel, 1 JTextField y JButton.

los re-nombramos para poderlos identificar mas facilmente, yo los llame así:


JLabel jLabel2;//esta sera la etiqueta del JTextField
JPanel jPanel1;
JButton jbmover;//mientras no se presione no se podrán mover las imágenes
JLabel jlbola;//este JLabel  sera la imagen que moveremos con el ratón
JLabel jlimagen1;//este JLabel  sera la imagen que moveremos con el teclado
JLabel jlimagen2;//este JLabel  sera la imagen de fondo
JTextField jttiempo;//aqui mostraremos el tiempo transcurrido

ahora cambiamos la vista de diseñador a código y dentro de la clase colocamos lo siguiente:

 Sonido miHilo;
    Thread miThread;
    boolean band;
    HiloTiempo otrohilo=new HiloTiempo();

clase interna

private class HiloTiempo extends Thread {

        @Override
        public void run() {
            int contador = 0,min=0;
            while (true) {              
                    jttiempo.setText("0"+ min+":"+ contador);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ex) {
                    Logger.getLogger(Animacion.class.getName()).log(Level.SEVERE, null, ex);
                }
                contador++;
                if(contador==60){
                    contador=0;
                    min++;
                }
            }
        }
    }


dentro de nuestro constructor colocamos esto:

    miHilo=new Sonido();
    miThread = new Thread(miHilo);
    miThread.start(); 
    otrohilo.start();

al botón jbmover le colocamos 2 eventos:

1- KeyPressed.
2- ActionPerformed.

debería quedar algo así:

 private void jbmoverKeyPressed(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_jbmoverKeyPressed
        
        if(band==true){
            moverImagen(evt);
        }
    }//GEN-LAST:event_jbmoverKeyPressed

    private void jbmoverActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jbmoverActionPerformed
         band=true;
    }//GEN-LAST:event_jbmoverActionPerformed

al JLabel jlbola le colocaremos el evento: MouseDragged.

debería quedar algo así:

private void jlbolaMouseDragged(java.awt.event.MouseEvent evt) {//GEN-FIRST:event_jlbolaMouseDragged
        if(band==true){
            moverImagen2(evt);
        }
    }//GEN-LAST:event_jlbolaMouseDragged

también declararemos el método para mover la imagen con el ratón:

public void moverImagen2(java.awt.event.MouseEvent evento) {
         jlbola.setLocation(jlbola.getX() + evento.getX() - jlbola.getWidth()/2 , jlbola.getY() + evento.getY() - jlbola.getHeight()/2);          

}

estos son los los métodos para mover la imagen con el teclado:

 private void moverImagen(java.awt.event.KeyEvent evt) {
        switch (evt.getKeyCode()) {
            case KeyEvent.VK_UP:
                moverArriba();
                break;
            case KeyEvent.VK_DOWN:
                moverAbajo();
                break;
            case KeyEvent.VK_LEFT:
                moverIzq();
                break;
            case KeyEvent.VK_RIGHT:
                moverDer();
                break;
            default:
                System.out.println("No valida");
        }
    }

    private void moverArriba() {
        jlimagen1.setLocation(jlimagen1.getX(), jlimagen1.getY() - 10);
    }

    private void moverAbajo() {
        jlimagen1.setLocation(jlimagen1.getX(), jlimagen1.getY() + 10);
    }

    private void moverIzq() {
        jlimagen1.setLocation(jlimagen1.getX() - 10, jlimagen1.getY());
    }

    private void moverDer() {
        jlimagen1.setLocation(jlimagen1.getX() + 10, jlimagen1.getY());
    }

ahora crearemos otra clase para el sonido

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sound.midi.InvalidMidiDataException;
import org.jfugue.Player;

public class Sonido implements Runnable {

    public void run() {
        Player player = new Player();
        File midi=new File("lilium_intro.mid");
         while (true) {
            try {
                    player.playMidiDirectly(midi);
            } catch (IOException ex) {
                Logger.getLogger(Sonido.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InvalidMidiDataException ex) {
                Logger.getLogger(Sonido.class.getName()).log(Level.SEVERE, null, ex);
            }
         }
    }
}

descarga el proyecto desde aquí.

descarga la librería jfugue desde aquí o visita su pagina oficial.

domingo, 25 de agosto de 2013

Juego del Tetris en C++ y Allegro (Juego y Código fuente)

Hola amig@s esta vez les traigo el clásico juego de Tetris escrito en C++ y la librería Allegro. Pero si te gustaría saber como hacer tu propio tetris te recomiendo ver este tutorial ya que para mi fue de gran ayuda para la elaboración de este juego.

Capturas:








Descarga el juego desde aquí.
Descarga el código desde aquí.

viernes, 9 de agosto de 2013

Juego del ahorcado modo gráfico v1

Hola amig@s en esta ocasión les traigo la versión 1 de la adaptacion del juego del ahorcado en C pero esta vez en modo gráfico escrito en C++ y la librería Allegro por el momento solo les presento el ejecutable del juego y una ves que termine el juego lo pondré todo el proyecto para su descarga.

Hasta el momento al juego se puede cargar un máximo de 300 palabras x dificultad. Para agregar nuevas palabras al juego se puede hacer de 2 maneras:

   1- Manualmente abriendo cada uno de los fichero y pegando las palabras.

   2- Automaticamente con la herramienta que he añadido al estilo drag and drop (arrastrar y soltar)        
       solo tienes que crear o copiar un archivo de texto en la carpeta files y el programa agregara
       las palabras al cada uno de los ficheros de dificultad dependiendo de la longitud de cada
       palabra.


Capturas:










Descarga el juego y el proyecto desde aquí.