public void sort() {
		for(int i = 1; i < a.length; i++){
			String next = a[i];
			/*
			 * Cerca la posizione in cui inserire, spostando in posizione di
			 * indice superiore a tutti gli elementi di valore maggiore.
			 */
			int j = i;
			boolean isBigger = a[j - 1].compareToIgnoreCase(next) > 0;
			while((j > 0) && isBigger){
				a[j] = a[j - 1];000
				j--;
			}
			a[j] = next;
		}
	}

/**
     * Scambia i valori delle stringhe corrispondenti agli indici in input.
     * Inoltre aggiorna gli array directIndexes e invertedIndexes. In questo
     * modo, se gli algoritmi di ordinamento usano questa funzione per
     * scambiare gli elementi dell'array di stringhe, è garantito che anche gli
     * indici riflettono l'effetto dello scambio.
     * 
     * @param i indice (int) della posizione della prima stringa
     * @param j indice (int) della posizione della seconda stringa
     */
    protected void swap(int i, int j) {
    	String strTemp = strings[i];
    	strings[i] = strings[j];
    	strings[j] = strTemp;
    	
    	int indTemp = invertedIndexes[i];
    	invertedIndexes[i] = invertedIndexes[j];
    	invertedIndexes[j] = indTemp;
    	
    	directIndexes[invertedIndexes[i]] = i;
    	directIndexes[invertedIndexes[j]] = j;
    }

	public void sort() {
		for (int i = 0; i < a.length; i++) {
	        boolean flag = false;
	        for (int j = 0; j < a.length - 1; j++) {
	            /*
	             * Se l' elemento j e maggiore del successivo allora
	             * scambiamo i valori
	             */
	             if (a[j].compareToIgnoreCase(a[j + 1]) > 0) {
	                 swap(j, j + 1);
	                 flag = true; 	//Scambio avvenuto con successo
	             }
	         }
	         /*
	          * Se flag = false allora nell' ultima iterazione
	          * non ci sono stati scambi, quindi il metodo può terminare
	          * poiché l' array risulta ordinato
	          */
	         if (!flag) {
	          	break; 
	         }
	    }                 
	}