1 FONDAMENTI DI INFORMATICA II Ingegneria Gestionale a.a ° Ciclo Strutture Dati

2 Le strutture Dati Per strutture dati s’intendono generalmente insiemi di dati caratterizzati dalla modalità d’accesso e dalla dimensione. Strutture Dati Statiche Sono caratterizzate dalla dimensione fissa. Tipici esempi sono gli array e i record implementati attraverso le struct. Strutture Dati Dinamiche Sono quelle la cui dimensione può crescere o decrescere durante l’esecuzione del programma. Esempi di strutture dati dinamiche sono le liste concatenate in cui i dati sono suddivisi in sottoinsiemi (nodi) ciascuno dei quali è collegato ad uno o più altri sottoinsiemi per mezzo di puntatori. Una lista concatenata può crescere o decrescere aggiungendo o togliendo nodi.

3 Strutture Dati Classi ricorsive Una classe ricorsiva contiene un membro di tipo puntatore che punta ad una struttura dello stesso tipo di quella in cui è contenuto. In sostanza ricorre una situazione del tipo sotto indicato: class Nome_Classe { ………….. ………………………………….. Nome_Classe *Nome_Puntatore; …………………………………}; Gli oggetti istanziati da una classe ricorsiva costituiscono perciò la naturale implementazione dei nodi di una lista concatenata.

4 Strutture Dati Esempio di classe ricorsiva. Class Node { public: Node (int); void setData (int); int getData ( ) const; void setNextPtr (const Node *); const Node *getNextPtr ( ) const; private: int data; Node *nextptr;// Puntatore di tipo Node };

5 Strutture Dati Liste concatenate Una lista concatenata può quindi definirsi come una sequenza di oggetti di una classe ricorsiva, chiamati nodi, connessi attraverso i puntatori della classe. Se la sequenza è unica, ossia se ogni oggetto può puntare solo all’oggetto che lo precede e/o lo segue in sequenza, la lista viene detta lineare. Esempi di liste lineari, che differiscono tra loro solo per le modalità di accesso, sono le pile (stack) e le code. Esempi di liste non lineari, ossia con più di un puntatore per ogni nodo che puntano a nodi non strettamente sequenziali, sono gli alberi. Nel caso di liste lineari il primo oggetto della sequenza, che viene detto testa della sequenza, è individuato da un puntatore. L’ultimo oggetto della sequenza, o coda, ha il suo puntatore convenzionalmente inizializzato a 0. Anche la coda può essere individuata da un puntatore.

6 Strutture Dati Rappresentazione grafica La rappresentazione grafica di una lista lineare può quindi essere fatta come segue: Oggetto B Puntatore Puntatore di testa Oggetto A Puntatore Oggetto C Puntatore Oggetto x 0 Puntatore di coda

7 Strutture Dati Ancora sulle liste concatenate lineari Le liste concatenate lineari possono essere ulteriormente caratterizzate come segue: Liste concatenate semplici Ogni nodo contiene un puntatore al successivo nodo, formando una sequenza che termina con un nodo il cui puntatore è 0. Liste concatenate semplici circolari Come sopra, tranne che il puntatore dell’ultimo nodo punta al primo nodo. Liste concatenate doppie Ogni nodo ha un puntatore sia al nodo precedente che al successivo, tranne l’ultimo che ha il puntatore al successivo uguale a 0 e il primo che ha il puntatore al precedente uguale a 0. Liste concatenate doppie circolari Come sopra tranne che il puntatore al successivo dell’ultimo nodo punta al primo nodo, mentre il puntatore al precedente del primo nodo punta all’ultimo nodo.

8 Strutture Dati Programma di manipolazione liste lineari semplici Il programma che ora consideriamo è un template di classe (di nome List), che manipola quindi liste con valori di un tipo da specificare, per mezzo delle seguenti opzioni selezionabili: 1 - Inserire un valore ad inizio lista (funzione insertAtFront) 2 - Inserire un valore alla fine della lista (funzione insertAtBack) 3 - Eliminare un valore dall’inizio della lista (funzione removeFromFront) 4 - Eliminare un valore dalla fine della lista (funzione removeFromBack) 5 - Terminare l’elaborazione eliminando tutti i nodi residui (funzione Distruttore)

9 Strutture Dati - Esempio // ListNode template definition #ifndef LISTND_H #define LISTND_H template class List; // forward declaration template class ListNode { friend class List ; // make List a friend public: ListNode( const NODETYPE & ); // constructor NODETYPE getData() const; // return data in the node private: NODETYPE data; // data ListNode *nextPtr; // next node in the list };

10 Strutture Dati - Esempio // Constructor template ListNode ::ListNode( const NODETYPE &info ) : data( info ), nextPtr( 0 ) { } // Return a copy of the data in the node template NODETYPE ListNode ::getData() const { return data; } #endif

11 Strutture Dati - Esempio // Template List class definition #ifndef LIST_H #define LIST_H #include #include "listnd.h" using std::cout; template class List { public: List(); // constructor ~List(); // destructor void insertAtFront( const NODETYPE & ); void insertAtBack( const NODETYPE & ); bool removeFromFront( NODETYPE & ); bool removeFromBack( NODETYPE & ); bool isEmpty() const; void print() const;

12 Strutture Dati - Esempio private: ListNode *firstPtr; // pointer to first node ListNode *lastPtr; // pointer to last node // Utility function to allocate a new node ListNode *getNewNode( const NODETYPE & ); }; // Default constructor template List ::List() : firstPtr( 0 ), lastPtr( 0 ) { }

13 Strutture Dati - Esempio // Is the List empty? template bool List ::isEmpty() const { return firstPtr == 0; } // Return a pointer to a newly allocated node template ListNode *List ::getNewNode ( const NODETYPE &value ) { ListNode *ptr = new ListNode ( value ); assert( ptr != 0 ); return ptr; }

14 Strutture Dati - Esempio 12 newPtr 711 firstPtrb) 12 newPtr firstPtra) 711

15 Strutture Dati - Esempio // Insert a node at the front of the list template void List :: insertAtFront( const NODETYPE &value) { ListNode *newPtr = getNewNode( value ); if ( isEmpty() ) // List is empty firstPtr = lastPtr = newPtr; else { // List is not empty newPtr->nextPtr = firstPtr; firstPtr = newPtr; }

16 Strutture Dati - Esempio 5 a) newPtrlastPtrfirstPtr lastPtrb) newPtrfirstPtr 5

17 Strutture Dati - Esempio // Insert a node at the back of the list template void List :: insertAtBack( const NODETYPE &value ) { ListNode *newPtr = getNewNode( value ); if ( isEmpty() ) // List is empty firstPtr = lastPtr = newPtr; else { // List is not empty lastPtr->nextPtr = newPtr; lastPtr = newPtr; }

18 Strutture Dati - Esempio a) firstPtrlastPtr 5 b) firstPtrlastPtr 5 tempPtr

19 Strutture Dati - Esempio // Delete a node from the front of the list template bool List ::removeFromFront( NODETYPE &value ) { if ( isEmpty() ) // List is empty return false; // delete unsuccessful else { ListNode *tempPtr = firstPtr; if ( firstPtr == lastPtr ) firstPtr = lastPtr = 0; else firstPtr = firstPtr->nextPtr; value = tempPtr->data; // data being removed delete tempPtr; return true; // delete successful }

20 Strutture Dati - Esempio a) firstPtrlastPtr 5 b) firstPtrlastPtr 5 currentPtr tempPtr

21 Strutture Dati - Esempio // Delete a node from the back of the list template bool List ::removeFromBack( NODETYPE &value ) {if ( isEmpty() ) return false; // delete unsuccessful else {ListNode *tempPtr = lastPtr; if ( firstPtr == lastPtr ) firstPtr = lastPtr = 0; else {ListNode *currentPtr = firstPtr; while ( currentPtr->nextPtr != lastPtr ) currentPtr = currentPtr->nextPtr; lastPtr = currentPtr; currentPtr->nextPtr = 0;} value = tempPtr->data; delete tempPtr; return true; // delete successful }

22 Strutture Dati - Esempio // Destructor template List ::~List() { if ( !isEmpty() ) { // List is not empty cout << "Destroying nodes...\n"; ListNode *currentPtr = firstPtr, *tempPtr; while ( currentPtr != 0 ) { // delete remaining nodes tempPtr = currentPtr; cout data << '\n'; currentPtr = currentPtr->nextPtr; delete tempPtr; } cout << "All nodes destroyed\n\n"; }

23 Strutture Dati - Esempio // Display the contents of the List template void List ::print() const { if ( isEmpty() ) { cout << "The list is empty\n\n"; return; } ListNode *currentPtr = firstPtr; cout << "The list is: "; while ( currentPtr != 0 ) { cout data << ' '; currentPtr = currentPtr->nextPtr; } cout << "\n\n"; } #endif

24 Strutture Dati - Esempio // List class test #include #include "list.h" using std::cin; using std::endl; // Function to test an integer List template void testList( List &listObject, const char *type ) { cout << "Testing a List of " << type << " values\n"; instructions( ); int choice; T value;

25 Strutture Dati - Esempio do { cout << "? "; cin >> choice; switch ( choice ) { case 1: cout << "Enter " << type << ": "; cin >> value; listObject.insertAtFront( value ); listObject.print(); break; case 2: cout << "Enter " << type << ": "; cin >> value; listObject.insertAtBack( value ); listObject.print(); break;

26 Strutture Dati - Esempio case 3: if ( listObject.removeFromFront( value ) ) cout << value << " removed from list\n"; listObject.print(); break; case 4: if ( listObject.removeFromBack( value ) ) cout << value << " removed from list\n"; listObject.print(); break; } } while ( choice != 5 ); cout << "End list test\n\n"; }

27 Strutture Dati - Esempio void instructions() { cout << "Enter one of the following:\n" << " 1 to insert at beginning of list\n" << " 2 to insert at end of list\n" << " 3 to delete from beginning of list\n" << " 4 to delete from end of list\n" << " 5 to end list processing\n"; } int main() { List integerList; testList( integerList, "integer" ); // test integerList List doubleList; testList( doubleList, "double" ); // test doubleList return 0;}

28 Strutture Dati - Esempio Testing a List of integer values Enter one of the following: 1 to insert at beginning of list 2 to insert at end of list 3 to delete from beginning of list 4 to delete from end of list 5 to end list processing ? 1 Enter integer: 1 The list is: 1 ? 1 Enter integer: 2 The list is: 2 1 ? 2 Enter integer: 3 The list is: ? 2 Enter integer: 4 The list is:

29 Strutture Dati - Esempio ? 3 2 removed from list The list is: ? 3 1 removed from list The list is: 3 4 ? 4 4 removed from list The list is: 3 ? 4 3 removed from list The list is empty ? 5 End list test

30 Strutture Dati - Esempio Testing a List of float values Enter one of the following: 1 to insert at beginning of list 2 to insert at end of list 3 to delete from beginning of list 4 to delete from end of list 5 to end list processing ? 1 Enter float: 1.1 The list is: 1.1 ? 1 Enter float: 2.2 The list is: ? 2 Enter float: 3.3 The list is: ? 2 Enter float: 4.4 The list is:

31 Strutture Dati - Esempio ? removed from list The list is: ? removed from list The list is: ? removed from list The list is: 3.3 ? removed from list The list is empty ? 5 End list test All nodes destroyed All nodesd destroyed