Descarga Sygic Mobile 7.71+Skin PRO+Radares+Voces+Cracked Full
Hola Bienvenido! Si eres Nuevo en Javasymbian, talvez quieras Suscribirte al Feed RSS para recibir las ultimas actualizaciones de la pagina via e-mail.





Descarga Sygic Mobile 7.71+Skin PRO+Radares+Voces+Cracked Full

Autoregistrado Trial Full - Cracked full
Skin aplicado - Iconos 32bits - Voces Radares
Pois Radares ( actualizados 05-04-2009 )
Archivos de recursos rebajados un 70%
Todas las optimizaciones hasta la fecha
No Incluye Mapas, se los instala aparte!

Mejoras Version Sygic Mobile 7.71:





Colores de carreteras cambiados - Colores de la Ruta cambiados - Colores noche cambiados - Ruta más estrecha (para que no sobresalga demasiado) - Autozoom optimizado pantallas 320×240 - Aviso de alerta cambiado estilo SpeedCam - Fondo parpadeante de alerta de los pois ocultado - Rótulo negro de indicación de la vía ocultado - Listas más altas para iconos grandes - Corregido bug en asistente de carril en modo noche - Claqueta de demostración visible - Símbolos + y – ocultos (no borrados..) - Barra de navegación reducida para pantallas de 320×240 - Barra de Progreso más gruesa - Iconos pois en listas más grandes - Iconos (Dirigirse a..Explorar Mapa…Calcular alternativa y última posición Gps,memorizar,….)cambiados - Imagenes en la Guia Cambiadas (Español) - Iconos radares 32Bits 48×48 pixeles - Upis de radares actualizados a 22-02-2009 - Voces alerta radares (Radio BBS) - Peso de los archivos de Recursos Rebajado un 70 %.



DESCARGA TOUCH VERSION: (Nokia 5800)




DESCARGA VERSION COMUN: (Ej: Nokia N95)

Shell short
//Shell sort original con cuatro bucles
//Correcto, aunque no es la implementación más común
void ShellSort(int[] A)
{
//el primer salto o gap (representado por la variable k)
//es la mitad de la longitud del array
int k=A.Length/2;
//este primer bucle nos mantendrá dentro del algoritmo
//mientras el salto sea mayor o igual que 1. Antes de
//cada iteración dividimos el salto o gap (k) entre 2
while (k>=1)
{
//este segundo bucle cuenta los subarrays que nos
//salen para cada valor de salto k.
for (int subarray = 0; subarray < k; subarray++)
{
//para cada subarray recorremos sus elementos
//con este otro bucle for, desde el segundo
//hasta el último. Este bucle es igual que el del
//algoritmo de inserción directa, pero adaptado
//para un salto k
for (int i = k+subarray; i < A.Length; i += k)
{
int v = A[i]; //tomamos el elemento i-ésimo
int j = i - k; //apuntamos al anterior en el subarray
//Con este bucle desplazamos elementos en el subarray
//hasta encontrar la posición que le corresponde
//al elemento i-ésimo que tenemos guardado en v
//Es como el bucle interior de la inserción directa
//pero adaptado para moverse por un subarray con
//con salto k
while (j >= 0 && A[j] > v)
{
A[j + k] = A[j];
j-=k;
}
A[j + k] = v;
} //fin for
} //fin for
//obtenemos un nuevo salto
k /= 2;
} //fin while
} //ShellSort

//arbol en java inorden, posorden, preorden */

//definicion de la clase NodoArbol
class NodoArbol {

//miembros de acceso
NodoArbol nodoizquierdo;
int datos;
NodoArbol nododerecho;

//iniciar dato y hacer de este nodo un nodo hoja
public NodoArbol(int datosNodo)
{
datos = datosNodo;
nodoizquierdo = nododerecho = null; //el nodo no tiene hijos
}

//buscar punto de insercion e insertar nodo nuevo
public synchronized void insertar(int valorInsertar)
{
//insertar en subarbol izquierdo
if (valorInsertar < datos){

//inserta nuevo nodoarbol
if (nodoizquierdo == null)
nodoizquierdo = new NodoArbol(valorInsertar);
else //continua recorriendo subarbol izquierdo
nodoizquierdo.insertar(valorInsertar);
}

//insertar nodo derecho
else if(valorInsertar > datos){

//insertar nuevo nodoarbol
if (nododerecho == null)
nododerecho = new NodoArbol(valorInsertar);
else //continua recorriendo subarbol derecho
nododerecho.insertar(valorInsertar);
}
} //fin del metodo insertar

} //fin clase nodoarbol

//---------- CLASE ARBOL------------------
class Arbol{
private NodoArbol raiz;

//contruir un arbol vacio
public Arbol()
{
raiz = null;
}

//insertar un nuevo nodo en el arbol de busqueda binaria
public synchronized void insertarNodo(int valorInsertar)
{
if(raiz == null)
raiz = new NodoArbol(valorInsertar); //crea nodo raiz

else
raiz.insertar(valorInsertar); // llama al metodo insertar
}

//--------------- EMPESAR EL RECORRIDO EN PREORDEN-----------------------
public synchronized void recorridoPreorden()
{
ayudantePreorden(raiz);
}
//metodo recursivo para recorrido en preorden

private void ayudantePreorden(NodoArbol nodo)
{
if (nodo == null)
return;

System.out.print(nodo.datos + " "); // mostrar datos del nodo
ayudantePreorden(nodo.nodoizquierdo); //recorre subarbol izquierdo
ayudantePreorden(nodo.nododerecho); //recorre subarbol derecho
}

//--------------EMPEZAR RECORRIDO INORDEN-----------------------------------
public synchronized void recorridoInorden()
{
ayudanteInorden(raiz);
}

// metodo recursivo para recorrido inorden

private void ayudanteInorden(NodoArbol nodo)
{
if (nodo == null)
return;

ayudanteInorden(nodo.nodoizquierdo);
System.out.print(nodo.datos + " ");
ayudanteInorden(nodo.nododerecho);
}

//-----------------------------EMPEZAR RECORRIDO POSORDEN---------------------------------
public synchronized void recorridoPosorden()
{
ayudantePosorden(raiz);
}

//metodo recursivo para recorrido posorden

private void ayudantePosorden(NodoArbol nodo)
{
if (nodo == null)
return;

ayudantePosorden(nodo.nodoizquierdo);
ayudantePosorden(nodo.nododerecho);
System.out.print(nodo.datos + " ");
}

}//fin clase arbol

//programa para probar la clase arbol

public class PruebaArbol {
public static void main(String args[])
{
Arbol arbol = new Arbol();
int valor;

System.out.println( "Insertando los siguientes valores: ");

//insertando 10 numeros aleatorios del 0 al 99 en el arbol
for (int i = 1; i<=10 ; i++)
{
valor = (int) (Math.random() * 100);
System.out.print(valor + " ");
arbol.insertarNodo(valor);
}

System.out.println("\n\nRecorrido preorden");
arbol.recorridoPreorden();

System.out.println("\n\nRecorrido inorden");
arbol.recorridoInorden();

System.out.println("\n\nRecorrido posorden");
arbol.recorridoPosorden();
}
}

import java.util.Comparator;

public class QuickSort
implements Sort
{
private Comparator comp = null;

public QuickSort( Comparator c )
{ comp = c; }

public QuickSort()
{}

public void sort( Object [] d )
{ sort( d, 0, d.length - 1 ); }

public void sort( Object [] d, int start, int end )
{
if ( start >= end )
return;

int p = partition( d, start, end );

sort( d, start, p - 1 );
sort( d, p + 1, end );
}

private int partition( Object [] d, int start, int end )
{
Object pivot = d[ end ];
int low = start - 1;
int high = end;

while ( true )
{
while ( compare( d[ ++low ], pivot ) < 0 ) ;
while ( compare( pivot, d[ --high ] ) < 0 && high > low) ;
if ( low >= high ) break;
exchange( d, low, high );
}
exchange( d, low, end );
return low;
}

private void exchange( Object [] a, int i, int j )
{
// inercambia los elementos low y high del array a
Object o = a[ i ];
a[ i ] = a[ j ];
a[ j ] = o;
}

private int compare( Object a, Object b )
{
if ( comp == null )
{
return ((Comparable)a).compareTo( b );
}
else
{
return comp.compare( a, b );
}
}
}

Metodos de ordenamiento java

ORDENAMIENTO.
Uno de los procedimientos más comunes y útiles en el procesamiento de datos, es la clasificación u ordenación de los mismos. Se considera ordenar al proceso de reorganizar un conjunto dado de objetos en una secuencia determinada. Cuando se analiza un método de ordenación, hay que determinar cuántas comparaciones e intercambios se realizan para el caso más favorable, para el caso medio y para el caso más desfavorable.


La colocación en orden de una lista de valores se llama Ordenación. Por ejemplo, se podría disponer una lista de valores numéricos en orden ascendente o descendente, o bien una lista de nombres en orden alfabético. La localización de un elemento de una lista se llama búsqueda.

Tal operación se puede hacer de manera más eficiente después de que la lista ha sido ordenada.
Existen varios métodos para ordenamiento, clasificados en tres formas:
Intercambio
Selección
Inserción.
En cada familia se distinguen dos versiones: un método simple y directo, fácil de comprender pero de escasa eficiencia respecto al tiempo de ejecución, y un método rápido, más sofisticado en su ejecución por la complejidad de las operaciones a realizar, pero mucho más eficiente en cuanto a tiempo de ejecución. En general, para arreglos con pocos elementos, los métodos directos son más eficientes (menor tiempo de ejecución) mientras que para grandes cantidades de datos se deben emplear los llamados métodos rápidos.

Intercambio
El método de intercambio se basa en comparar los elementos del arreglo e intercambiarlos si su posición actual o inicial es contraria inversa a la deseada. Pertenece a este método el de la burbuja clasificado como intercambio directo. Aunque no es muy eficiente para ordenar listas grandes, es fácil de entender y muy adecuado para ordenar una pequeña lista de unos 100 elementos o menos.
Una pasada por la ordenación de burbujeo consiste en un recorrido completo a través del arreglo, en el que se comparan los contenidos de las casillas adyacentes, y se cambian si no están en orden. La ordenación por burbujeo completa consiste en una serie de pasadas ("burbujeo") que termina con una en la que ya no se hacen cambios porque todo está en orden.

Ejemplo:
Supóngase que están almacenados cuatro números en un arreglo con casillas de memoria de x[1] a x[4]. Se desea disponer esos números en orden creciente. La primera pasada de la ordenación por burbujeo haría lo siguiente:
Comparar el contenido de x[1] con el de x[2]; si x[1] contiene el mayor de los números, se intercambian sus contenidos.
Comparar el contenido de x[2] con el de x[3]; e intercambiarlos si fuera necesario.
Comparar el contenido de x[3] con el de x[4]; e intercambiarlos si fuera necesario.

Al final de la primera pasada, el mayor de los números estará en x[4].






Quicksort.
Si bien el método de la burbuja era considerado como el peor método de ordenación simple o menos eficiente, el método Quicksort basa su estrategia en la idea intuitiva de que es más fácil ordenar una gran estructura de datos subdividiéndolas en otras más pequeñas introduciendo un orden relativo entre ellas. En otras palabras, si dividimos el array a ordenar en dos subarrays de forma que los elementos del subarray inferior sean más pequeños que los del subarray superior, y aplicamos el método reiteradamente, al final tendremos el array inicial totalmente ordenado. Existen además otros métodos conocidos, el de ordenación por montículo y el de shell.

DEJA UN COMENTARIO

Reloj