Laboratorio di Algoritmi e Strutture Dati

Size: px

Start display at page:

Download "Laboratorio di Algoritmi e Strutture Dati"

Robyn Mabel Stanley
6 years ago
Views:

1 Laboratorio di Algoritmi e Strutture Dati Guido Fiorino guido.fiorino@unimib.it aa

2 2 Linked lists (of int) We focus on linked lists for integers; let us start with a class that defines a node of the list: class Node{ int data; Node next; we want to define the class LinkedList to store arbitrary long sequences of integers by means of a linked list. The definition of the class LinkedList has the following features: 1 the class Node will be an inner class of LinkedList; 2 head will be an instance variable of type Node. As usual, head equals null means empty list, otherwise head points to the first node of the list. Notice that for practical purposes, LinkedList could have more instance variables, such as one to point to the last node, one containing the number of items,...

3 The class LinkedList This is the skeleton of the class LinkedList. In the next slides we develop some methods for the class. public class LinkedList{ private class Node{ int data; Node next; //end Node private Node head; /* methods go here, see next slides */ //end LinkedList

4 The class LinkedList: constructors public LinkedList(){ //creates an empty list head = null; // end constructor // creates a list with a node public LinkedList(int x){ head = new Node(); head.data = x; head.next = null; // end constructor

5 The class LinkedList: check for emptiness public boolean isempty(){ //returns true if the list is empty, //false otherwise return head == null; // end isempty()

6 The class LinkedList: head insert and delete //add a node to the head of the list public void insertasfirst(int x){ Node n = new Node(); n.data = x; n.next = head; head = n; // end insertasfirst //remove the first node public boolean deletefirst(){ if (head == null) return false; //nothing to delete head = head.next; return true;

7 The class LinkedList: check for the existence public boolean exists(int x){ // returns true if x occurs as a data in a node of the list, // false otherwise return exists(head, x); //call a private recursive method private boolean exists(node p, int x){ if ( p == null ) return false; return (p.data == x) ( exists(p.next, x) ) ;

8 The class LinkedList: traversing the list to multiply The method multiplyby(int x) multiplies by x the instance variable data of every node. The method void multiplyby(int x) calls method void multiplyby(node p, int x) that by recursion traverses the list starting from p. public void multiplyby(int x){ multiplyby(head, x); // end multiplyby(int) private void multiplyby(node p, int x){ if (p!= null){ p.data *= x; multiplyby(p.next, x); // end multiplyby(node, int)

9 The class LinkedList: traversing the list to print public void print(){ if ( head!= null ){ System.out.println("Data in the list"); print(head); else System.out.println("The list is empty"); // end print() private void print(node p){ if (p!= null){ System.out.println("data: " + p.data); print(p.next); // end print(node)

10 The class LinkedList: tail insertion The method void insertaslast(int x) creates a new node and insert it as the last node of the list. public void insertaslast(int x){ if (head == null) insertasfirst(x); //the list is empty else insertaslast(head,x); private void insertaslast(node p, int x){ if (p.next==null) { //base case //p is pointing to the last node Node g = new Node(); g.data= x; g.next = null; p.next=g; /* In alternative we can save g: p.next = new Node(); p.next.data = x; p.next.next = null; */ return; // end if insertaslast(p.next, x);//recursione

11 The class LinkedList: tail deletion We devise a pubic method deletelast that returns true if the list is not empty, false is the list is empty and thus there is nothing to delete. The easy part is for the empty list or the list with one element. For the list with more than one element, the public method deletelast() calls the private method deletelast(node p). public boolean deletelast(){ if (head == null) return false; // nothing to delete; if (head.next == null){ // the list has one element head = null; return true; // the list has two or more elements return deletelast(head);

12 The class LinkedList: tail deletion private boolean deletelast(node p){ // base case Node front = p.next; //front points to the successor of p if ( front.next == null){ //if the successor of p is the last element //then p becomes the last element p.next = null; return true; return deletelast(front);

13 The class LinkedList: deletion of all nodes with a value The method deletedata(int x) deletes all the nodes containing the given value x. The easy part is when the list is empty; If the first node has to be deleted, we proceed recursively on the (public) method deletedata(int x). For the other cases we proceed recursively by means of the (private) method deletedata(node p, int x). //delete all the nodes containing the value x public boolean deletedata(int x){ if (head == null) return false; // the list is empty, // nothing to do if (head.data == x) { //the first node has to be deleted head = head.next; deletedata(x); return true; //the first node must not be deleted return deletedata(head,x); // end deletedata(int)

14 The class LinkedList: deletion of all nodes with a value private boolean deletedata(node p, int x){ //p points a node that does not contain x Node front = p.next; // front points to the successor of p, if any if (front == null) return false; //p has no successor if (front.data == x) { // delete the successor of p p.next = front.next; //now p.next different from front deletedata(p, x); return true; //the successor of p must not by deleted //recursively proceed on the rest of the list return deletedata(front, x); // deletedata(node, int)

15 The class LinkedList: print in reverse public void printreverse(){ if ( head!= null ){ System.out.println("Data of the list"); printreverse(head); else System.out.println("The list is empty"); // end printreverse() private void printreverse(node p){ if (p!= null){ printreverse(p.next); System.out.println("data: " + p.data); // end printreverse(node)

16 The class LinkedList: reverse the list Build the reverse of the given list by reversing the pointers; when we finish, head points to the last node of the original given list; no new node is created, only the value of next is changed; public void reverse(){ if (head!= null && head.next!= null) //there is more than one element head=reverse(head);

17 The class LinkedList: reverse the list private Node reverse(node p){ if (p.next == null) return p; //there is one element //there is more than one element: //recursively reverse the list starting from the successor of p Node r = reverse(p.next); /* now the list starting from the node successor of p is reversed and r points to it. The first node of the given list pointed by p must become the last node of the list pointed by r. We change the pointer of the the successor of p, which is the last node of the list pointed by r. */ p.next.next=p; //now the successor of p points to p p.next=null; //the given list is fully reversed return r;

18 The class LinkedList: copy the data We want a method copy that returns an object of LinkedList; the instance variable head points to a list whose data are equal to the original list; note that by copy we mean a genuine duplicate of the data in the given object. //duplicates the nodes of the list pointed by head public LinkedList copy(){ LinkedList thecopy = new LinkedList(); thecopy.head = copy(head); //duplicate the list return thecopy; private Node copy(node p){ Node g; if (p == null) return null; //the given list is empty; g = new Node(); g.data = p.data; g.next = copy(p.next); //recursively copy the rest of the list return g;

19 19 A collection of exercises on the class LinkedList Provide and iterative version of the recursive methods given in the previous slides; write a method int size() that returns the number of nodes in the list; write a method int getat(int k) that returns the value stored in the k-th node of the list (k = 1 means the first node). If the list has less than k nodes, then getat() returns the value of the last node. You are free to handle the cases of the empty list or of k < 1. write a method boolean insertat(int x, int k) that creates a new node and assigns x to the instance variable data. If the list has less than k 1 nodes, the method insertat() places the new node as last node and returns false. Otherwise, the method insertat() places the new node in the k-th position and returns true; write a method boolean deleteat(int k) that removes the node at the k-th position and returns true if the k-th node of the list exists, false otherwise; write a method int lastpositionof(int x) that returns the last position where x occurs, -1 if x does not occur in the list; write a method void moveahead(int x) that if the value x does not occur in the list, then creates a new node and inserts it as first node of the list. Otherwise moveahead makes one of the nodes containing x the first node of the list; write a method LinkedList concatenate(linkedlist g) that returns an object of LinkedList containing the data pointed by head followed by the data contained in g.

20 20 Circular linked lists A circular linked list is a linked list where the link of the last node references the head node of the list. Consequences: every node has a predecessor and a successor; given a reference to any node, we can traverse the whole list. We follow the definition of the class LinkedList to define the class CircularLinkedList. In particular: CircularLinkedList has one Node instance variable last. The methods handle last as the reference to the last node of the list.

21 The class CircularLinkedList public class CircularLinkedList{ private class Node{ int data; Node next; // end Node private Node last; // last.next points to the head list public CircularLinkedList(){ //creates an empty list last = null; // end constructor // creates a list with a node public CircularLinkedList(int x){ last = new Node(); last.data = x; last.next = last; // this is both the first and // the last node of the list // end constructor /* methods go here, see next slides */ // end class

22 The class CircularLinkedList: handling the first element public int getfirst(){ // returns the value in the first node of // the list. Note that // if last == null holds we get an error return last.next.data; public void deletefirst(){ if (last == null) return; // the list is empty if (last.next!= last){ //there are at least 2 elements last.next = last.next.next; else { // the list has one element last = null;

23 The class CircularLinkedList: check for the existence public boolean exists(int x){ // returns true if x occurs as a data in a node of the list, // false otherwise if (last == null) return false; //the list is empty return exists(last.next, x); //search from the head node private boolean exists(node p, int x){ if ( p == last ) return (last.data == x); return ( p.data == x ) ( exists(p.next, x) ) ;

24 The class CircularLinkedList: traversing the list to print public void print(){ if ( last!= null ){ //the list is not empty System.out.println("Data in the list"); print(last.next); else System.out.println("The list is empty"); // end print() private void print(node p){ System.out.println("data: " + p.data); if (p!= last){ print(p.next); // end print(node)

25 The class CircularLinkedList: head insertion public void insertasfirst(int x){ if (last == null){ //the list is empty last = new Node(); last.data=x; last.next=last; else { // the list is not empty Node n = new Node(); n.data = x; n.next = last.next; // the successor of n is the first node last.next = n; // the successor of the last node is n // end insertasfirst(int)

26 The class CircularLinkedList: tail insertion public void insertaslast(int x){ if (last == null) insertasfirst(x); else { // the list is not empty Node n = new Node(); n.data = x; n.next = last.next; //the successor of n is the first node last.next = n; // the predecessor of n is pointed by last last = n; // makes the new node the last element // end insertaslast(int)

27 A collection of exercises for the class CircularLinkedList Add to the class the methods given for the class LinkedList; write a method int size() that returns the number of nodes in the list; write a method int getat(int k) that returns the value stored in the k-th node of the list (k = 1 means the first node). If the list has less than k nodes, then getat() returns the value of the last node. You are free to handle the cases of the empty list or of k < 1. Remember that the first node is the successor of the node referenced by the instance variable last. write a method boolean insertat(int x, int k) that creates a new node and assigns x to the instance variable data. If the list has less than k 1 nodes, insertat() places the new node as last node and returns false. Otherwise, insertat() places the new node in the k-th position and returns true; write a method boolean deleteat(int k) that removes the node at the k-th position and returns true if the k-th node of the list exists, false otherwise; write a method int lastpositionof(int x) that returns the last position where x occurs, -1 if x does not occur in the list; write a method void moveahead(int x) that if the value x does not occur in the list, then creates a new node and inserts it as first node of the list. Otherwise, moveahead() makes one of the nodes containing x the first node of the list; write a method CircularLinkedList concatenate(circularlinkedlist g) that returns an object of CircularLinkedList containing the data pointed by head followed by the data contained in g.

28 28 (Circular) doubly linked lists In a (circular) doubly linked list there is no a privileged direction to traverse the list because every node brings information to access both to the predecessor and to the successor: every node has two instances variables to reference the nodes. We call them next and prev; the instance variable next references the successor; the instance variable prev references the predecessor. Analogously to linked lists, double linked lists have: a node without a predecessor, where prev is null. We call it the first node or the head node of the list; a node without a successor, where next is null. We call it the last node or the tail node of the list. Analogously to circular linked lists, all the nodes of a circular doubly linked list have a predecessor.

29 The class DoublyLinkedList public class DoublyLinkedList{ private class Node{ int data; Node next; Node prev; // end Node private Node head; private Node tail; // not necessary but useful /* methods go here, see the next slides //end class

30 The class DoublyLinkedList: the constructors public DoublyLinkedList(){ head = tail = null; // creates an empty list // end constructor // creates a list with a node public DoublyLinkedList(int x){ head = new Node(); tail = head ; // in a one-node list the node is both // the head and the tail head.data = x; head.next = null; //the node has no successor head.prev = null; //the node has no predecessor // end constructor

31 The class DoublyLinkedList: insertion public void insertasfirst(int x){ Node n = new Node(); n.data = x; n.next = head; n.prev = null; // the first node has no predecessor if (head!= null){ // the list is not empty, // also tail!= null holds // only head needs to be updated head.prev = n; head = n; else { // the list is empty this is //the first node and also tail == null holds // head and tail need to be updated head = tail = n; // end insertasfirst(int)

32 The class DoublyLinkedList: insertion public void insertaslast(int x){ Node n = new Node(); n.data = x; n.next = null; //n is the last node n.prev = tail; //the predecessor of n is //the last node of the list if (tail!= null){ //the list is not empty tail.next = n; //n becomes the successor of the last node tail = n; //n becomes the last node of the list else head = tail = n; // end insertaslast(int)

33 The class CircularDoublyLinkedList public class CircularDoublyLinkedList{ private class Node{ int data; Node next; prev; // end Node private Node last; // points to the last node of the list // last.next is the first node of the list /*methods go here, see next slides*/ // end class

34 The class CircularDoublyLinkedList: the constructors public CircularDoublyLinkedList(){ last = null; // creates an empty list // end constructor // creates a list with a node public CircularDoublyLinkedList(int x){ last = new Node(); last.data = x; last.next = last.prev = last; // the node has itself // as predecessor and successor // end constructor / end class

35 35 Exercises for the classes of double linked lists Complete the classes DoublyLinkedList and CircularDoublyLinkedList with the methods given for the class LinkedList. Pay attention to the insertion and deletion methods for the class CircularDoublyLinkedList!

36 36 Implementation of FIFO queue via linked lists By using the class CircularLinkedList introduced before it is easy to implement a class Queue that handles collection of integers according the policy first-in-first-out. The class Queue contains the following methods: void enqueue(int) to add an integer; int dequeue() to remove the last recently added item; boolean isempty() to check if the queue is empty.

37 The class Queue for integers //a fifo queue implemented by means of a circular linked list public class Queue{ private CircularLinkedList queueofint = new CircularLinkedList(); public boolean isempty(){ return queueofint.isempty(); public void enqueue(int data){ //insert as last element of the queue queueofint.insertaslast(data); public int dequeue(){ //delete the first item of the queue int data=queueofint.getfirst(); queueofint.deletefirst(); return data;

38 38 Implementation of Pushdown stack via circular linked lists By using the class LinkedList introduced before it is easy to implement a class Stack that handles collection of integers according the policy last-in-first-out. The class Stack contains the following methods: void push(int) to add an integer; int pop() to remove the last recently added item; boolean isempty() to check if the queue is empty.

39 The class Stack for integers public class Stack{ private LinkedList stackofint = new LinkedList(); public boolean isempty(){ return stackofint.isempty(); public void push(int data){ // add data to the top of the stack stackofint.insertasfirst(data); public int pop(){ // remove the data from the top of the stack int data = stackofint.getat(1); stackofint.deletefirst(); return data;

40 40 Exercises Write a class to handle stack of characters. Then use the class to: write a method boolean balanced(string s) that returns true if the parenthesis in s are balanced. For example balanced( [()({){] ) should return true and balanced( {[([])] ) should return false; write a method int evaluate(string s) that returns the value of the arithmetic expression contained in s. Suppose that the expression is fully parenthesized, the unary minus is not used and the numbers have one digit.

CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University

CS 112 Introduction to Computing II Wayne Snyder Department Boston University Today Introduction to Linked Lists Stacks and Queues using Linked Lists Next Time Iterative Algorithms on Linked Lists Reading: