Strutture dati

Vitoantonio Bevilacqua vitoantonio.bevilacqua@poliba.it

Antonio Brunetti antonio.brunetti@poliba.it

Gianpaolo Francesco Trotta gianpaolofrancesco.trotta@poliba.it

Pagina in lavorazione

Indice

1 Introduzione
2 Pila
- 2.1 Implentazione della Pila
3 Coda
- 3.1 Implementazione della Coda

Introduzione

Le strutture dati astratte sono strutture dati che non specificano il modo in cui i dati vengono memorizzati in memoria, ma ciascuna definisce un particolare comportamento di tipo logico nell'organizzazione dei dati. La rappresentazione di una struttura di dati astratta fatta mediante strutture dati concrete è detta "implementazione". Le strutture astratte che qui di seguito definiremo e implementeremo sono la Pila, la Coda.

Pila

La pila (o stack) è una struttura di dati astratta, monodimensionale, costituita da elementi omogenei, ad esempio di tipo intero, ordinati in una sequenza. La pila segue la logica di gestione dei dati LIFO (Last In First Out): le operazioni di inserimento ed eliminazione/estrazione di un elemento della pila sono effettuale dallo stesso estremo della sequenza, detto "testa della pila", dunque l'ultimo elemento inserito è quello che per primo viene estratto/eliminato.

Per implementare la struttura dati astratta PILA con un vettore, bisogna innanzitutto decidere (o conoscere) la sua profondità, ovvero la massima dimensione del vettore che la rappresenta. Poiché si vuole fare in modo che il vettore si comporti come una pila, deve essere possibile aggiungere ed estrarre elementi dal vettore seguente la logica desiderata; per far ciò sono state implementate due funzioni: inserisciElemento() ed estraiElemento(). Per la gestione della pila è necessaria una variabile intera che rappresenti l’indice, ovvero la testa della pila (head). Questa variabile ha il compito quindi di indicare la posizione nella quale inserire il prossimo elemento. È ovvio che dopo aver inserito un elemento, questa debba essere incrementata; ma nell’estrazione necessita decrementarla prima, perché a quell’indice nella pila non esiste ancora nulla in quanto l'ultimo elemento inserito si trova all'indice precedente.

Implentazione della Pila

```
import java.util.Scanner;
```
```
 
```
```
public class Pila {
```
```
 
```
```
	private int[] pila;
```
```
	private int head;
```
```
	private int length;
```
```
 
```
```
	public Pila(int len) {
```
```
		length = len;
```
```
		pila = new int[length];
```
```
		head = 0;
```
```
	}
```
```
 
```
```
	public void run() {
```
```
		Scanner s = new Scanner(System.in);
```
```
		int scelta = -1;
```
```
 
```
```
		while (scelta != 0) {
```

			System.out.print("Inserisci scelta (1 per inserire, 2 per estrarre, 3 per visualizzare, 0 per uscire): ");

```
			scelta = s.nextInt();
```
```
 
```
```
			if (scelta == 1) {
```
```
				// Inserimento
```
```
				if (head >= length) {
```

					System.out.println("La pila è piena");

```
				} else {
```

					System.out.println("Inserisci elemento: ");

```
					inserisciElemento(s.nextInt());
```
```
				}
```
```
			}
```
```
			else if (scelta == 2) {
```
```
				// Estrazione
```
```
				if (head == 0) {
```

					System.out.println("La pila è vuota");

```
				} else {
```
```
					int ele = estraiElemento();
```

					System.out.println("L'elemento estratto vale: " + ele );

```
				}
```
```
			}
```
```
			else if (scelta == 3) {
```
```
				// Visualizzazione
```
```
				if (head== 0) {
```

					System.out.println("La pila è vuota");

```
				} else {
```
```
					stampaPila();
```
```
				}
```
```
			}
```
```
		}
```
```
 
```
```
		System.out.println("Ciao");
```
```
 
```
```
	}
```
```
 
```

	public void inserisciElemento(int ele) {

```
		pila[head] = ele;
```
```
		head++;
```
```
	}
```
```
 
```
```
	public int estraiElemento() {
```
```
		head--;
```
```
		return pila[head];
```
```
	}
```
```
 
```
```
	public void stampaPila() {
```
```
		int i = 0;
```

		System.out.println("Gli elementi nella pila sono: ");

```
		for (i = 0; i < head; i++) {
```
```
			System.out.print(pila[i] + " ");
```
```
		}
```
```
		System.out.println();
```
```
	}
```
```
}
```

```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

```
 
```
```
		Scanner s = new Scanner(System.in);
```

		System.out.print("Inserisci lunghezza pila: ");

```
		Pila p = new Pila(s.nextInt());
```
```
		p.run();
```
```
	}
```
```
}
```

Coda

La "coda" o "queue" è una struttura dati monodimensionale e costituita da elementi omogenei ordinati in sequenza. Essa segue la logica FIFO (First In First Out), ovvero le operazioni vengono effettuate su due estremi differenti.

Analogamente alla struttura PILA, per implementare la struttura dati astratta CODA attraverso un vettore, bisogna innanzitutto decidere (o conoscere) la sua lunghezza, che quindi sarà la massima dimensione del vettore che la rappresenta. Inoltre, per gestire la coda sono necessari due indici, ovvero il puntatore d’inserimento (tail) e puntatore d’estrazione (head), che indicano i due estremi della coda. Verosimilmente, quando inserisco un elemento nella coda, il puntatore d’inserimento deve essere incrementato, mentre quando estraggo un elemento dalla coda è il puntatore d’estrazione ad incrementare. Quando il puntatore d’inserimento ha raggiunto il valore massimo, ovvero quello della lunghezza della coda, si potrebbe pensare che questa sia piena; tuttavia, se durante l'esecuzione è stato estratto almeno un elemento, allora è possibile inserirne un altro (“si è liberato un posto”), gestendo il vettore ciclicamente. Effettuare la gestione ciclica della coda significa che i puntatori, quando raggiungono la lunghezza della coda devono essere riportati all’inizio della stessa, il che vuol dire che l’incremento si traduce nel resto della divisione per la lunghezza.

Implementazione della Coda

```
import java.util.Scanner;
```
```
 
```
```
public class Coda {
```
```
 
```
```
	private int[] coda;
```
```
	private int head;
```
```
	private int tail;
```
```
	private int length;
```
```
	private int size = 0;
```
```
 
```
```
	public Coda(int len) {
```
```
		length = len;
```
```
		coda = new int[length];
```
```
		head = 0;
```
```
		tail = 0;
```
```
	}
```
```
 
```
```
	public void run() {
```
```
		Scanner s = new Scanner(System.in);
```
```
		int scelta = -1;
```
```
 
```
```
		while (scelta != 0) {
```

			System.out.print("Inserisci scelta (1 per inserire, 2 per estrarre, 3 per visualizzare, 0 per uscire): ");

```
			scelta = s.nextInt();
```
```
 
```
```
			if (scelta == 1) {
```
```
				if (size == length) {
```

					System.out.println("La coda è piena");

```
				} else {
```

					System.out.print("Inserisci il prossimo elemento elemento in coda: ");

```
					inserisciElemento(s.nextInt());
```
```
				}
```
```
			}
```
```
			else if (scelta == 2) {
```
```
				// 
```
```
				if (size == 0) {
```

					System.out.println("La coda è vuota");

```
				} else {
```
```
					int ele = estraiElemento();
```

					System.out.println("L'elemento estratto vale: " + ele );

```
				}
```
```
			}
```
```
			else if (scelta == 3) {
```
```
				// stampa
```
```
				if (size == 0) {
```

					System.out.println("La coda è vuota");

```
				} else {
```
```
					stampaCoda();
```
```
				}
```
```
			}
```
```
		}
```
```
		System.out.println("Fine Programma");
```
```
 
```
```
	}
```
```
 
```

	public void inserisciElemento(int ele) {

```
		coda[tail] = ele;
```
```
		tail = (tail + 1) % length;
```
```
		size++;
```
```
 
```
```
	}
```
```
 
```
```
	public int estraiElemento() {
```
```
		int ele = coda[head];
```
```
		head = (head + 1) % length;
```
```
		size--;
```
```
		return ele;
```
```
	}
```
```
 
```
```
	public void stampaCoda() {
```
```
		int i = 0;
```

		System.out.print("Gli elementi nella coda sono:");

```
		for (i = 0; i < size; i++) {
```

			System.out.print(" " + coda[(head + i) % length]);

```
		}
```
```
		System.out.println();
```
```
	}
```
```
}
```

```
import java.util.Scanner;
```
```
 
```
```
public class Principale {
```
```
 
```

	public static void main(String[] args) {

```
 
```
```
		Scanner s = new Scanner(System.in);
```

		System.out.println("Inserisci lunghezza coda: ");

```
		Coda p = new Coda(s.nextInt());
```
```
		p.run();
```
```
	}
```
```
}
```

Strutture dati

Indice

Introduzione

Pila

Implentazione della Pila

Coda

Implementazione della Coda

Menu di navigazione

Strumenti personali

Namespace

Varianti

Visite

Azioni

Ricerca

Navigazione

Strumenti