Esempi JAVA: differenze tra le versioni

Da Bioingegneria Elettronica e Informatica.
(→‎Algoritmo di ordinamento Selection Sort)
Riga 382: Riga 382:
 
}
 
}
  
 +
</syntaxhighlight>
 +
 +
== Algoritmo di fusione Merge Sort ==
 +
Consideriamo due vettori (U e V) già ordinati con lo stesso criterio e nelle ipotesi che la loro lunghezza non coincida, che ogni vettore non contenga elementi uguali e che non ci sono elementi comuni tra i due vettori. L'algoritmo merge sort crea un terzo vettore ordinato (W) dato dalla fusione dei primi due. La logica alla base dell'algoritmo è quella di far lavorare in un ciclo due indici (i e j), ciascuno su un vettore, scorrendo i quali si aggiunge al vettore fusione volta per volta l'elemento minore a cui fanno riferimento i due indici. Quando uno dei due vettori termina, si aggiungono al vettore fusione i restanti elementi dell'altro vettore.
 +
 +
<syntaxhighlight lang="java" line>
 +
public class MergeSort {
 +
 +
public static void main(String[] args) {
 +
 +
new MergeSort().run();
 +
}
 +
 +
public void run() {
 +
 +
// Dimensioni dei Vettori U e V
 +
int n = 10;
 +
int m = 20;
 +
 +
// I vettori su cui applicare il merge sort
 +
int[] U = {21, 30, 15, 6, 0, 1, 78, 99, 100, 200};
 +
int[] V = {3, 251, 20, 5, 9, 101, 45, 67, 80, 71, 98, 2, 7, 125, 156, 24, 1010, 4, 8, 2000};
 +
 +
// Applico l'ordinamento su entrambi i vettori con l'algoritmo Selection SOrt
 +
ordinamentoSelectionSort(U, n);
 +
ordinamentoSelectionSort(V, m);
 +
 +
// Ora che i vettori sono entrambi ordinati posso fare il merge sort
 +
int[] W = new int[n+m];
 +
mergeSort(U, n, V, m, W);
 +
 +
                // Stampa i tre vettori U,V e W
 +
stampaVettore(U,n);
 +
stampaVettore(V,m);
 +
stampaVettore(W,n+m);
 +
 +
}
 +
 +
/**
 +
* Funzione che implementa l'algoritmo di Merge Sort
 +
* @param v1
 +
* @param dim1
 +
* @param v2
 +
* @param dim2
 +
* @param v3
 +
*/
 +
public void mergeSort(int[] v1, int dim1, int[] v2, int dim2, int[] v3) {
 +
 +
int i = 0;
 +
int j = 0;
 +
int k = 0;
 +
 +
// Utilizzo gli indici i e j che scorrono sui vettori v1 e v2 rispettivamente.
 +
while (i < dim1 && j < dim2) {
 +
if(v1[i] < v2[j]) {
 +
v3[k] = v1[i];
 +
i++;
 +
}
 +
else {
 +
v3[k] = v2[j];
 +
j++;
 +
}
 +
k++;
 +
}
 +
 +
/* Il blocco condizionale if serve a capire qual è il vettore non terminato
 +
* in modo da inserire i sui rimanenti elementi nel vettore fusione v3
 +
*/
 +
if (i < dim1) {
 +
for (i = i; i < dim1; i++) {
 +
v3[k] = v1[i];
 +
k++;
 +
}
 +
}
 +
else {
 +
for (; j < dim2; j++) {
 +
v3[k] = v2[j];
 +
k++;
 +
}
 +
}
 +
}
 +
 +
       
 +
/**
 +
* Funzione di ordinamento con algoritmo Selection Sort
 +
* @param vett
 +
* @param dim
 +
*/
 +
public void ordinamentoSelectionSort(int[] vett, int dim) {
 +
int i, j, i_min;
 +
 +
for(i = 0; i < dim-1; i++) {
 +
i_min = i;
 +
for (j = i+1; j < dim; j++) {
 +
if(vett[j] < vett[i_min])
 +
i_min = j;
 +
}
 +
 +
scambiaElementi(vett, i_min, i);
 +
}
 +
}
 +
 +
        /**
 +
* Funzione di scambio delle componenti in posizione A e B del vettore vett
 +
* @param vett
 +
* @param A
 +
* @param B
 +
*/
 +
public void scambiaElementi(int[] vett, int A, int B) {
 +
int temp = vett[A];
 +
vett[A] = vett[B];
 +
vett[B] = temp;
 +
}
 +
 +
        /**
 +
* Funzione di stampa degli elementi del vettore vett
 +
* @param vett
 +
* @param dim
 +
*/
 +
public void stampaVettore(int[] vett, int dim) {
 +
int i = 0;
 +
for (i = 0; i < dim; i++)
 +
System.out.print(vett[i] + "  ");
 +
System.out.println();
 +
}
 +
 +
}
 
</syntaxhighlight>
 
</syntaxhighlight>

Versione delle 11:14, 22 mar 2017

Hello World

Esercizio introduttivo a JAVA. Il seguente codice mostra a video la stringa "Hello World !" 

  1. /* Questo è il primo programma in JAVA
  2.  * e inizia con un commento multilinea
  3.  */
  4.  
  5. // Commento su singola linea
  6.  
  7. /**
  8.  * Uso della javadoc 
  9.  * Questo programma deve stampare sullo standard output, ovvero la console,
  10.  * la stringa "Hello World !"
  11.  * 
  12.  * @author antonio
  13.  *
  14.  */
  15.  
  16. public class Principale {
  17.  
  18. 	/**
  19. 	 * Metodo di avvio del programma
  20. 	 * @param args argomenti passati dalla linea di comando
  21. 	 */
  22. 	public static void main(String[] args) {
  23.  
  24. 		// Standard output
  25. 		System.out.println("Hello World !");	
  26. 	}
  27. }

Uso delle funzioni: Doppio e Somma

Codice Java per l'introduzione alle funzioni; sono state implementate due funzioni:

  1. calcolo del doppio di un numero intero;
  2. calcolo della somma di due numeri interi. 
  1. /** Programma per mostrare il funzionamento di:
  2.  *  1. Funzione chiamante (main) e funzione chiamata;
  3.  *  2. Variabili locali e parametri (valori) attuali; 
  4.  *  3. Passaggio per Valore;
  5.  * 
  6.  * @author antonio
  7.  * 
  8.  */
  9. public class Principale {
  10.  
  11. 	public static void main(String[] args) {
  12.  
  13. 		new Principale().run();
  14. 	}
  15.  
  16. 	public void run() {
  17.                 // Dichiarazione e inizializzazione delle variabili origin, origin2 e result
  18. 		int origin = 3;
  19. 		int origin2 = 5;
  20. 		int result = 0;
  21.  
  22. 		System.out.println("Doppio di una variabile");
  23.  
  24. 		// Stampa in console del valore attuale di origin
  25. 		System.out.println("Il valore di origin è: " + origin);
  26.  
  27.                 /* Calcolo il doppio della variabile origin:
  28.                  * 1. chiamo la funzione doppio
  29.                  * 2. salvo il risultato nella variabile result
  30.                  */
  31. 		result = doppio(origin);
  32.  
  33. 		// Stampa in console il valore di result
  34. 		System.out.println("Il valore di result è: " + result);
  35.  
  36.  
  37. 		System.out.println("Somma di due variabili");
  38.  
  39. 		// Stampa in console del valore attuale di origin e origin2
  40. 		System.out.println("Il valore di origin è: " + origin);
  41. 		System.out.println("Il valore di origin2 è: " + origin2);
  42.  
  43.                 // Calcolo la somma di origin e origin2
  44. 		result = somma(origin, origin2);
  45.  
  46.                 // Stampa in console il valore di result
  47. 		System.out.println("Il valore di result è: " + result);
  48. 	}
  49.  
  50. 	/**
  51. 	 * Funzione per calcolare il doppio di un valore
  52. 	 * @param val
  53. 	 * @return
  54. 	 */
  55. 	public int doppio(int val) {
  56.                 // Dichiaro la variabile res per salvare il doppio della variabile val
  57. 		int res = 0;
  58. 		res = val * 2;
  59.  
  60.                 // Restituzione di res
  61. 		return res;
  62. 	}
  63.  
  64. 	/**
  65. 	 * Funzione per calcolare la somma di due addendi
  66. 	 * @param add1
  67. 	 * @param add2
  68. 	 * @return
  69. 	 */
  70. 	public int somma(int add1, int add2) {
  71.  
  72.                 // Codice compatto che fa la somma di add1 e add2 e restituisce il risultato
  73. 		return add1 + add2;
  74. 	}
  75. }

Scambio di due elementi all'interno di un vettore

Codice Java che implementa lo scambio di due componenti in un vettore; sono stati implementati due casi:

  1. caso1: vettore di sole due componenti che vengono scambiate (funzione scambia(...));
  2. caso2: vettore di dimensione N nel quale sono scambiate le componenti con indice ind1 e ind2 (funzione scambia_componenti(...)). 
  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		// Vettore formato da due elementi
  10. 		int[] v = {3,5};
  11.  
  12. 		// Stampo il valore delle due variabili prima dello scambio
  13. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  14. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  15.  
  16. 		// Effettuo lo scambio
  17. 		scambia(v);
  18.  
  19. 		// Stampo il valore delle due variabili dopo lo scambio
  20. 		System.out.println("La prima componente del vettore vale: " + v[0]);
  21. 		System.out.println("La seconda componente del vettore vale: " + v[1]);
  22.  
  23.  
  24. 		// Generalizzazione a vettore formato da N elementi in cui indico le componenti da scambiare
  25. 		// Vettore formato da N elementi
  26. 		int N = 10;
  27. 		int i = 0;
  28. 		int[] vett = new int[N];
  29.  
  30. 		for(i = 0; i < N; i++)
  31. 			vett[i] = i+1;
  32.  
  33. 		int ind1 = 3;
  34. 		int ind2 = 8;
  35. 		// Stampo il vettore prima dello scambio
  36. 		for(i = 0; i < N; i++)
  37. 			System.out.print(vett[i] + " ");
  38. 		System.out.println();
  39.  
  40. 		// Effettuo lo scambio
  41. 		scambia_componenti(vett, ind1, ind2);
  42.  
  43. 		// Stampo il vettore dopo dello scambio
  44. 		for(i = 0; i < N; i++)
  45. 			System.out.print(vett[i] + " ");
  46. 		System.out.println();
  47. 	}
  48.  
  49. 	/**
  50. 	 * Funzione scambia funzionante
  51. 	 * @param V
  52. 	 */
  53. 	public void scambia(int[] V) {
  54. 		int temp;
  55. 		temp = V[0];
  56. 		V[0] = V[1];
  57. 		V[1] = temp;
  58.  
  59. 	}
  60.  
  61.         /**
  62. 	 * Funzione di scambio delle componenti in posizione c1 e c2 del vettore V 
  63. 	 * @param V
  64. 	 * @param c1
  65. 	 * @param c2
  66. 	 */
  67. 	public void scambia_componenti(int[] V, int c1, int c2) {
  68. 		int temp;
  69. 		temp = V[c1];
  70. 		V[c1] = V[c2];
  71. 		V[c2] = temp;
  72. 	}
  73. }

Prodotto tra matrici

Codice Java che implementa il prodotto, righe per colonne, tra due matrici. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		int r1, c1;
  10. 		int r2, c2;
  11. 		int k;
  12.  
  13. 		// Affinchè il prodotto tra matrici possa essere eseguito è necessario che c1 = r2;
  14.  
  15. 		// Dimensioni prima matrice
  16. 		r1 = 2;
  17. 		c1 = 3;
  18.  
  19. 		// Dimensioni della seconda matrice
  20. 		r2 = 3;
  21. 		c2 = 5;
  22.  
  23. 		// Valorizzazzione matrice1 con numeri interi da 0 (r1*c1)-1
  24. 		k = 0;
  25.  
  26. 		int[][] mat1 = new int[r1][c1];
  27.  
  28. 		for (int i  = 0; i < r1; i++) {
  29. 			for (int j = 0; j < c1; j++) {
  30. 				mat1[i][j] = k;
  31. 				k++;
  32. 			}
  33. 		}
  34.  
  35. 		// Valorizzazzione matrice1 con numeri interi da 0 (r2*c2)-1
  36. 		k = 0;
  37.  
  38. 		int[][] mat2 = new int[r2][c2];
  39. 		for (int i  = 0; i < r2; i++) {
  40. 			for (int j = 0; j < c2; j++) {
  41. 				mat2[i][j] = k;
  42. 				k++;
  43. 			}
  44. 		}
  45.  
  46. 		// Stampa delle matrici mat1 e mat2
  47. 		System.out.println("La prima matrice vale: ");
  48. 		stampaMatrice(mat1, r1, c1);
  49. 		System.out.println("La seconda matrice vale: ");
  50. 		stampaMatrice(mat2, r2, c2);
  51.  
  52. 		/* Controllo che le dimensioni delle matrici rispettano r2 == c1 
  53. 		 * affinchè sia possibile effettuare il prodotto tra le due matrici 
  54. 		 */
  55. 		if (r2 != c1) {
  56. 			System.out.println("Non è possibile fare il prodotto tra matrici");
  57. 		}
  58. 		else {
  59. 			// Dichiarazione della matrice prodotto mat3 di dimensioni r1*c2
  60. 			int[][] mat3 = new int[r1][c2];
  61.  
  62. 			// Il prodotto tra le matrici è effettuato nella relativa funzione
  63. 			prodottoMatrici(mat1, r1, c1, mat2, r2, c2, mat3);
  64.  
  65. 			// Stampa della matrice prodotto mat3
  66. 			System.out.println("La matrice prodotto vale: ");
  67. 			stampaMatrice(mat3, r1, c2);
  68. 		}
  69. 	}
  70.  
  71. 	/**
  72. 	 * Funzione per la stampa della matrice mat note le sue dimensioni r e c
  73. 	 * @param mat
  74. 	 * @param r
  75. 	 * @param c
  76. 	 */
  77. 	public void stampaMatrice(int[][] mat, int r, int c) {
  78. 		int i = 0;
  79. 		int j = 0;
  80.  
  81. 		for (i = 0; i < r; i++) {
  82. 			for (j = 0; j < c; j++) {
  83. 				System.out.print(mat[i][j] + "\t");
  84. 			}
  85. 			System.out.println();
  86. 		}
  87. 	}
  88.  
  89. 	/**
  90. 	 * Funzione che effettua il prodotto tra matrici
  91. 	 * @param A prima matrice
  92. 	 * @param r1 numero di righe della prima matrice
  93. 	 * @param c1 numero di colonne della prima matrice
  94. 	 * @param B seconda matrice
  95. 	 * @param r2 numero di righe della seconda matrice
  96. 	 * @param c2 numero di colonne della seconda matrice
  97. 	 * @param C matrice prodotto
  98. 	 */
  99. 	public void prodottoMatrici(int[][] A, int r1, int c1, int[][] B, int r2, int c2, int[][] C) {
  100. 		int i = 0;
  101. 		int j = 0;
  102. 		int k = 0;
  103.  
  104. 		// Algoritmo per il prodotto tra matrici
  105. 		for (i = 0; i < r1; i++) {
  106. 			for (k = 0; k < c2; k++) {
  107. 				C[i][k] = 0;
  108. 				for (j = 0; j < c1; j++) {
  109. 					C[i][k] = C[i][k] + A[i][j] * B[j][k];
  110. 				}
  111. 			}
  112. 		}
  113. 	}
  114. }

Algoritmo di ordinamento Selection Sort

Codice Java che implementa l'algoritmo di ordinamento Selection Sort. 

  1. public class Principale {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new Principale().run();
  6. 	}
  7.  
  8. 	public void run() {
  9. 		int i = 0;
  10.  
  11. 		// Vettore formato da N elementi
  12. 		int N = 10;
  13. 		int[] vett = {15, 25, 18, 6, 4, 9, 110, 200, 0, 201};
  14.  
  15. 		// Stampo il vettore prima dell'ordinamento
  16. 		for(i = 0; i < N; i++)
  17. 			System.out.print(vett[i] + " ");
  18. 		System.out.println();
  19.  
  20. 		// Effettuo l'ordinamento
  21. 		ordinamentoSelectionSort(vett, N);
  22.  
  23. 		// Stampo il vettore dopo l'ordinamento
  24. 		for(i = 0; i < N; i++)
  25. 			System.out.print(vett[i] + " ");
  26. 		System.out.println();
  27. 	}
  28.  
  29.         /**
  30. 	 * Funzione che implementa l'algoritmo di ordinamento Selection Sort noti il vettore e la sua dimensione
  31. 	 * @param V
  32. 	 * @param dim
  33. 	 */
  34. 	public void ordinamentoSelectionSort(int[] V, int dim) {
  35. 		int i = 0;
  36. 		int j = 0;
  37. 		int i_min = 0;
  38.  
  39. 		for (i = 0; i < dim -1; i++) {
  40. 			i_min = i;
  41. 			for (j = i+1; j < dim; j++ ) {
  42. 				if (V[j] < V[i_min])
  43. 					i_min = j;
  44. 			}
  45.  
  46. 			scambia_componenti(V, i, i_min);
  47. 		}
  48. 	}
  49.  
  50.         /**
  51. 	 * Funzione di scambio delle componenti in posizione c1 e c2 del vettore V 
  52. 	 * @param V
  53. 	 * @param c1
  54. 	 * @param c2
  55. 	 */
  56. 	public void scambia_componenti(int[] V, int c1, int c2) {
  57. 		int temp = V[c1];
  58. 		V[c1] = V[c2];
  59. 		V[c2] = temp;
  60. 	}
  61. }

Algoritmo di fusione Merge Sort

Consideriamo due vettori (U e V) già ordinati con lo stesso criterio e nelle ipotesi che la loro lunghezza non coincida, che ogni vettore non contenga elementi uguali e che non ci sono elementi comuni tra i due vettori. L'algoritmo merge sort crea un terzo vettore ordinato (W) dato dalla fusione dei primi due. La logica alla base dell'algoritmo è quella di far lavorare in un ciclo due indici (i e j), ciascuno su un vettore, scorrendo i quali si aggiunge al vettore fusione volta per volta l'elemento minore a cui fanno riferimento i due indici. Quando uno dei due vettori termina, si aggiungono al vettore fusione i restanti elementi dell'altro vettore. 

  1. public class MergeSort {
  2.  
  3. 	public static void main(String[] args) {
  4.  
  5. 		new MergeSort().run();
  6. 	}
  7.  
  8. 	public void run() {
  9.  
  10. 		// Dimensioni dei Vettori U e V
  11. 		int n = 10;
  12. 		int m = 20;
  13.  
  14. 		// I vettori su cui applicare il merge sort
  15. 		int[] U = {21, 30, 15, 6, 0, 1, 78, 99, 100, 200};
  16. 		int[] V = {3, 251, 20, 5, 9, 101, 45, 67, 80, 71, 98, 2, 7, 125, 156, 24, 1010, 4, 8, 2000};
  17.  
  18. 		// Applico l'ordinamento su entrambi i vettori con l'algoritmo Selection SOrt
  19. 		ordinamentoSelectionSort(U, n);
  20. 		ordinamentoSelectionSort(V, m);
  21.  
  22. 		// Ora che i vettori sono entrambi ordinati posso fare il merge sort
  23. 		int[] W = new int[n+m];
  24. 		mergeSort(U, n, V, m, W);
  25.  
  26.                 // Stampa i tre vettori U,V e W
  27. 		stampaVettore(U,n);
  28. 		stampaVettore(V,m);
  29. 		stampaVettore(W,n+m);
  30.  
  31. 	}
  32.  
  33. 		/**
  34. 	 * Funzione che implementa l'algoritmo di Merge Sort
  35. 	 * @param v1
  36. 	 * @param dim1
  37. 	 * @param v2
  38. 	 * @param dim2
  39. 	 * @param v3
  40. 	 */
  41. 	public void mergeSort(int[] v1, int dim1, int[] v2, int dim2, int[] v3) {
  42.  
  43. 		int i = 0;
  44. 		int j = 0;
  45. 		int k = 0;
  46.  
  47. 		// Utilizzo gli indici i e j che scorrono sui vettori v1 e v2 rispettivamente.
  48. 		while (i < dim1 && j < dim2) {
  49. 			if(v1[i] < v2[j]) {
  50. 				v3[k] = v1[i];
  51. 				i++;
  52. 			}
  53. 			else {
  54. 				v3[k] = v2[j];
  55. 				j++;
  56. 			}
  57. 			k++;
  58. 		}
  59.  
  60. 		/* Il blocco condizionale if serve a capire qual è il vettore non terminato
  61. 		 * in modo da inserire i sui rimanenti elementi nel vettore fusione v3
  62. 		 */
  63. 		if (i < dim1) {
  64. 			for (i = i; i < dim1; i++) {
  65. 				v3[k] = v1[i];
  66. 				k++;
  67. 			}
  68. 		}
  69. 		else {
  70. 			for (; j < dim2; j++) {
  71. 				v3[k] = v2[j];
  72. 				k++;
  73. 			}
  74. 		}
  75. 	}
  76.  
  77.  
  78. 	/**
  79. 	 * Funzione di ordinamento con algoritmo Selection Sort
  80. 	 * @param vett
  81. 	 * @param dim
  82. 	 */
  83. 	public void ordinamentoSelectionSort(int[] vett, int dim) {
  84. 		int i, j, i_min;
  85.  
  86. 		for(i = 0; i < dim-1; i++) {
  87. 			i_min = i;
  88. 			for (j = i+1; j < dim; j++) {
  89. 				if(vett[j] < vett[i_min])
  90. 					i_min = j;
  91. 			}
  92.  
  93. 			scambiaElementi(vett, i_min, i);
  94. 		}
  95. 	}
  96.  
  97.         /**
  98. 	 * Funzione di scambio delle componenti in posizione A e B del vettore vett
  99. 	 * @param vett
  100. 	 * @param A
  101. 	 * @param B
  102. 	 */
  103. 	public void scambiaElementi(int[] vett, int A, int B) {
  104. 		int temp = vett[A];
  105. 		vett[A] = vett[B];
  106. 		vett[B] = temp;
  107. 	}
  108.  
  109.         /**
  110. 	 * Funzione di stampa degli elementi del vettore vett
  111. 	 * @param vett
  112. 	 * @param dim
  113. 	 */
  114. 	public void stampaVettore(int[] vett, int dim) {
  115. 		int i = 0;
  116. 		for (i = 0; i < dim; i++)
  117. 			System.out.print(vett[i] + "  ");
  118. 		System.out.println();
  119. 	}
  120.  
  121. }
Estratto da "http://www.vitoantoniobevilacqua.it/wiki/index.php?title=Esempi_JAVA&oldid=426"