Implementing Dynamic Data Structures

Size: px

Start display at page:

Download "Implementing Dynamic Data Structures"

Sophia McBride
5 years ago
Views:

1 Chapter 16 Implementing Dynamic Data Structures Lecture slides for: Java Actually: A Comprehensive Primer in Programming Khalid Azim Mughal, Torill Hamre, Rolf W. Rasmussen Cengage Learning, ISBN: Permission is hereby granted to use these lecture slides in conjunction with the book. Modified: 21/1/10 Java Actually 16: Implementing Dynamic Data Structures 16-1/44 Simple Linked Lists: Insertion Deletion Lookup Other Abstract Data Types (ADT): Stack Queues Overview Java Actually 16: Implementing Dynamic Data Structures 16-2/44

2 Linked lists A simple linked list is a linear collection of objects, called nodes. A node is an example of an object that has a reference to an object of the same type, i.e., is self-referencing. The class Node<E> defines two field variables: The reference that refers to any object. The reference that refers to a node. The nodes can be linked together using the field to form a linked list. Java Actually 16: Implementing Dynamic Data Structures 16-3/44 The class Node /** A node holds and a reference to a node. */ public class Node<E> { /** Data in the node. */ private E ; /** Reference to the node. */ private Node<E> ; public Node(E _obj, Node<E> noderef) { = _obj; = noderef; public void setdata(e obj) { = obj; public void setnext(node<e> node) { = node; public E getdata() { return ; public Node<E> getnext() { return ; Java Actually 16: Implementing Dynamic Data Structures 16-4/44

3 Class diagram for a simple linked list (Figure 16.1) E E LinkedList head Node tail A concrete linked list for strings :String :String :String :String "hail" "ice" "snow" "sleet" :LinkedList<String> = null p:ref(node<string>) Java Actually 16: Implementing Dynamic Data Structures 16-5/44 To insert into and get from the node: String str = head.getdata(); // Get from the first node. p.setdata("frost");// Data in the node referenced by p is changed to "frost". Find the node s successor: Node<String> successor = p.getnext(); // Get successor to p. Set the successor of the node: p.setnext(q); // q set as successor to p. Move the reference p so that it refers to its successor: p = p.getnext(); // Reference p now refers to its successor. Java Actually 16: Implementing Dynamic Data Structures 16-6/44

4 Interface ILinkedListe<E> (Program 16.2, Figure 16.2) public interface ILinkedList<E> extends Iterable<E> { // Mutators public void insertathead(e _obj); public void insertattail(e _obj); public E removefromhead(); public E removefromtail(); boolean remove(e _obj); // Selectors public boolean isempty(); int numberofnodes(); Node<E> first(); Node<E> last(); Node<E> find(e _obj); // Other methods void listtoarray(e[] array); «interface» Iterable<E> Iterator<E> iterator() «interface» ILinkedList<E> LinkedList<E> «interface» Iterator<E> boolean hasnext() E () void remove() LinkedListIterator<E> (a) Implementing linked lists (b) Implementing an iterator for linked lists Java Actually 16: Implementing Dynamic Data Structures 16-7/44 The class LinkedList<E> public class LinkedList<E> implements ILinkedList<E> { /** Head of the list */ private Node<E> head; /** Tail of the list */ private Node<E> tail; /** Number of nodes in the list */ private int numberofnodes; //... Java Actually 16: Implementing Dynamic Data Structures 16-8/44

5 Inserting at the head of a linked list (Program 16.3) If the list is empty The head and the tail are set to refer to the new node Else Step 1: Set the head to be the successor of the new node Step 2: Set the head to refer to the new node public void insertathead(e Obj) { // (1) Node<E> p = new Node<E>(Obj, null); if (isempty()) { head = tail = p; else { // head = new MyNode<E>(Obj, head); p.setnext(head); // Step 1 head = p; // Step 2 numberofnodes++; It is important that the two steps are performed in the right order (Figure 16.3). Java Actually 16: Implementing Dynamic Data Structures 16-9/44 Insert a node at the head of a linked list (Figure 16.4) = null p:ref(node<string>) = "frost" Step 1: p.setnext(head); (b) Step 1 in inserting at the head of the list Step 2: head = p; = null p:ref(node<string>) = "frost" (c) Step 2 in inserting at the head of the list Java Actually 16: Implementing Dynamic Data Structures 16-10/44

6 Inserting at the tail of a linked list If the list is empty The head and the tail are set to refer to the new node Else Step 1: Set the new node as the successor of the tail node Step 2: Set the tail to refer to the new node public void insertattail(e Obj) { // (2) Node<E> p = new Node<E>(Obj, null); if (isempty()) { head = tail = p; else { tail.setnext(p); // Step 1 tail = p; // Step 2 numberofnodes++; Java Actually 16: Implementing Dynamic Data Structures 16-11/44 Insert a node at the tail of a linked list (Figure 16.5b og c) ( ) g Step 1: tail.setnext(p); p:ref(node<string>) = "frost" = null (b) Step 1 in inserting at the tail of the list Step 2: tail = p; p:ref(node<string>) = "frost" = null (c) Step 2 in inserting at the tail of the list Java Actually 16: Implementing Dynamic Data Structures 16-12/44

7 Removing a node from the head of a linked list Step 1: Let p refer to the first node in the list, i.e. same node as the head If the head and the tail refer to the same node, i.e. only one node in the list Both the head and the tail are set to null Else Step 2: Set the head to refer to the successor of the first node referenced by p public E removefromhead() { // (3) assert numberofnodes > 0 : "The list cannot be empty."; Node<E> p = head; // Step 1 if (head == tail) { head = tail = null; // Only one node in the list. else { head = p.getnext(); // Step 2 numberofnodes--; return p.getdata(); Java Actually 16: Implementing Dynamic Data Structures 16-13/44 Removing a node from the head of a linked list (Figure 16.6b og c) ( ) g = null Step 1: p = head; p:ref(node<string>) = "frost" (b) Step 1 in removing from the head of the list Step 2: head = p.getnext(); = null p:ref(node<string>) = "frost" (c) Step 2 in removing from the head of the list Java Actually 16: Implementing Dynamic Data Structures 16-14/44

8 Removing a node from the tail of a linked list We let reference p denote the node to be removed (Figure 16.7, step 1): p = tail; // Step 1 p:ref(node<string>) Step 1: p = tail; (b) Step 1 in removing from the tail of the list = "frost" = null Deleting a node in a list requires knowledge of the predecessor of the node to be deleted. To find the second last node, we have to traverse the list from the head: Let ToLast refer to the first node in the list, i.e. same node as the head Repeat while not arrived at the -to-last node Move the reference ToLast to the successor Java Actually 16: Implementing Dynamic Data Structures 16-15/44 Source code to find the second last node (Figure 16.7, step 2): Node<E> ToLast = head; while (ToLast.getNext()!= tail) // Arrived at the -to-last node? ToLast = ToLast.getNext(); // Move to the successor. Step 2: update ToLast; ToLast:Ref(Node<String>) p:ref(node<string>) (c) Step 2 in removing from the tail of the list = "frost" = null Java Actually 16: Implementing Dynamic Data Structures 16-16/44

9 Removing a node from the tail of a linked list (Fig. 16.8, steps 3 and 4) ToLast:Ref(Node<String>) Step 3: tail = ToLast; p:ref(node<string>) = "frost" = null (d) Step 3 in removing from the tail of the list ToLast:Ref(Node<String>) = null Step 4: tail.setnext(null); p:ref(node<string>) = "frost" = null (e) Step 4 in removing from the tail of the list Java Actually 16: Implementing Dynamic Data Structures 16-17/44 public E removefromtail() { // (4) assert numberofnodes > 0 : "The list cannot be empty."; Node<E> p = tail; // Step 1 if (head == tail) { head = tail = null; // Only one node in the list. else { Node<E> ToLast = head; // Step 2 while (ToLast.getNext()!= tail) { ToLast = ToLast.getNext(); tail = ToLast; // Step 3 tail.setnext(null); // Step 4 numberofnodes--; return p.getdata(); Java Actually 16: Implementing Dynamic Data Structures 16-18/44

10 Removing a node from inside a linked list Find the node to be deleted and its predecessor (step 1): Repeat while the end of the list not reached and the node to be removed not found If the current node is the one to be removed The node is found, and thereby its predecessor Else Move the reference for the current node and for the predecessor Source code to find the node to be deleted and its predecessor: Node<E> currentnode = head; Node<E> predecessor = null; boolean found = false; while (currentnode!= null &&!found) { if (currentnode.getdata().equals(obj)) { found = true; else { // Not yet found. Update predecessor and currentnode references. predecessor = currentnode; // (1) currentnode = currentnode.getnext(); // (2) Java Actually 16: Implementing Dynamic Data Structures 16-19/44 Removing a node from inside a linked list (Figure 16.9, step 1) = "snow" = "sleet" = null (a) Before removing a node from inside the list predecessor:ref(node<string>) currentnode:ref(node<string>) = "snow" = "sleet" = null Step 1: Find node that is to be deleted, and its predecessor; (b) Step 1 in removing a node from inside the list Java Actually 16: Implementing Dynamic Data Structures 16-20/44

11 There are three possibilities to consider in order to delete a node that exists in the list: The node is the first node in the list (predecessor == null). The method removefromhead() is called to delete it. The node is the last node in the list (currentnode.getnext () == null). The tail and the last node are updated: tail = predecessor; tail.setnext(null); Node is inside the list. The successor to the node to be deleted is now the successor to its predecessor (step 2): predecessor.setnext(currentnode.getnext()); Java Actually 16: Implementing Dynamic Data Structures 16-21/44 Removing a node from inside a linked list (Figure 16.9, step 2) predecessor:ref(node<string>) currentnode:ref(node<string>) = "snow" = "sleet" = null Step 2: predecessor.setnext(currentnode.getnext()); (c) Step 2 in removing a node from inside the list Java Actually 16: Implementing Dynamic Data Structures 16-22/44

12 Finding in a linked list The method uses equals() method to compare objects in the list. The method returns the node that contains the object to be found. public Node<E> find(e Obj) { // Traverse the list, starting from the head. Node<E> currentnode = head; while (currentnode!= null) { if (currentnode.getdata().equals(obj)) { return currentnode; // Found. currentnode = currentnode.getnext(); return null; // Not found. Java Actually 16: Implementing Dynamic Data Structures 16-23/44 Iterator for a linked list. The class LinkedList<E> implements the contract ILinkedList<E>, and thus also indirectly the contract Iterable<E> (See Figure 16.3). The class LinkedListIterator implements an iterator for the class LinkedList: public class LinkedListIterator<E> implements Iterator<E> { private Node<E> currentnode; public LinkedListIterator(ILinkedList<E> list) { currentnode = list.first(); public boolean hasnext() { return currentnode!= null; public E () { E = currentnode.getdata(); currentnode = currentnode.getnext(); return ; public void remove() { throw new UnsupportedOperationException(); Java Actually 16: Implementing Dynamic Data Structures 16-24/44

13 Convert a linked list to an array The method fills the specified array with elements from the list. public void listtoarray(e[] toarray) { // (7) assert toarray.length == numberofnodes : "Wrong size of array."; int i = 0; for (E : this) { toarray[i++] = ; Java Actually 16: Implementing Dynamic Data Structures 16-25/44 Example: Convert a linked list to an array public class ListeTilTabellDemo { public static void main(string[] args) { LinkedList<Character> lst = new LinkedList<Character>(); lst.insertathead('a'); lst.insertathead('b'); lst.insertathead('b'); lst.insertathead('a'); for (char c : lst) System.out.print(c); System.out.println(); Character[] array = new Character[lst.numberOfNodes()]; lst.listtoarray(array); System.out.println(array.length); for (char c : array) System.out.print(c); System.out.println(); //... Java Actually 16: Implementing Dynamic Data Structures 16-26/44

14 Data can be shared among linked lists list1: :Node :Node :Node Name: head Type: ref(node) Name: tail Type: ref(node) : : : : list2: :Node :Node :Node :Node Name: head Type: ref(node) Name: tail Type: ref(node) Name: p Type: ref(node) Java Actually 16: Implementing Dynamic Data Structures 16-27/44 ADT: Stack A stack is a LIFO (Last-In, First-Out) structure (Figure 16.10). push(element) pop() tos or top-of-stack "ice" "sleet" "snow" stack peek() Java Actually 16: Implementing Dynamic Data Structures 16-28/44

15 Stack operations Stack operation push(element) pop() peek() isempty() Description Add the element to top of the stack. Removes and returns the first element on the top of the stack. Returns the first element on the top of the stack without removing it from the stack. Returns true or false depending on whether the stack is empty or not. Java Actually 16: Implementing Dynamic Data Structures 16-29/44 Stack Implementation by aggregation Stack operations are delegated to the linked list operations. In this implementation a client can not break the abstraction that a stack represents. The class java.util.stack<e> provides another implementation of stacks. class StackByAggregation<E> { // Field private LinkedList<E> stacklist; // (1) // Constructor public StackByAggregation() { // (2) stacklist = new LinkedList<E>(); // Instance methods public void push(e ) { // (3) stacklist.insertathead(); Java Actually 16: Implementing Dynamic Data Structures 16-30/44

16 public E pop() { // (4) if (empty()) return null; return stacklist.removefromhead(); public E peek() { // (5) if (empty()) return null; return stacklist.first().getdata(); public boolean empty() { // (6) return stacklist.isempty(); Java Actually 16: Implementing Dynamic Data Structures 16-31/44 A client that uses a stack (StackClient.java) public class StackClient { public static void main(string[] args) { // (1) Check if there are program arguments: if (args.length == 0) { System.out.println("Usage: java StackClient <argument list>"); return; // (2) Create a stack: StackByAggregation<String> stack = new StackByAggregation<String>(); // (3) Push all program arguments (strings) on to the stack: for (int i = 0; i < args.length; i++) stack.push(args[i]); // (4) Pop all elements from the stack: while (!stack.empty()) System.out.print(stack.pop().toLowerCase() + " "); System.out.println(); Java Actually 16: Implementing Dynamic Data Structures 16-32/44

17 Running the program: >java StackClient Tall STACKS topple easily easily topple stacks tall Java Actually 16: Implementing Dynamic Data Structures 16-33/44 Using stacks We will look at a problem from graph theory. A graph has nodes and edges connecting the nodes together. The edges are directed, meaning that they have an arrowheads at one end. One can navigate from one node to another in the specified direction. Java Actually 16: Implementing Dynamic Data Structures 16-34/44

18 Graphs Each node is a city (which has a number specified in the node) An edge from one city indicates which city can be accessed directly from this city. 1 0 edge 3 2 node [0] [1] [2] [3] [4] [0] [1] [2] [3] [4] F T F T T F F T F F F F F F T F T T F F F F F F F 4 T:true F:false (a ) Graph (b ) Graph array Java Actually 16: Implementing Dynamic Data Structures 16-35/44 The Problem Which cities can be reached from a given city? We may, for example, reach the cities with the numbers 1, 2 and 4 b starting in city number 3 We can step-wise find the cities that can be accessed directly from a city, and repeat the same process for these cities. The process uses a stack and a set. The stack keeps track of which cities we have not as yet checked to reach other cities directly. The set keeps track of cities that have been reached so far in the process. Each step in the process involves the following: Pop the city from the top of the stack If this city is not in the set Add this city to the set Push all cities that can be reached directly from this city on to the stack Java Actually 16: Implementing Dynamic Data Structures 16-36/44

19 Step to find the cities that are reachable from city number 3 Step no. Stack Set 1. <3> [] 2. <1, 2> [3] 3. <1, 4> [3, 2] 4. <1> [3, 2, 4] 5. <2> [3, 2, 4, 1] 6. <> [3, 2, 4, 1] Java Actually 16: Implementing Dynamic Data Structures 16-37/44 import java.util.hashset; import java.util.scanner; import java.util.set; Example: Graph public class StackClient2 { public static void main(string[] args) { // (1) Create a city graph: boolean[][] citygraph = { {false, true, false, true, true, {false, false, true, false, false, {false, false, false, false, true, {false, true, true, false, false, {false, false, false, false, false ; // (2) Read the city from the keyboard: System.out.print("Type the number of the city to start from [0-" + (citygraph.length-1) + "]: "); Java Actually 16: Implementing Dynamic Data Structures 16-38/44

20 Scanner keyboard = new Scanner(System.in); int startcitynum = keyboard.int(); if (startcitynum < 0 startcitynum >= citygraph.length) { System.out.print("Unknown city number: " + startcitynum); return; // (3) Create a city stack: StackByAggregation<Integer> citystack = new StackByAggregation<Integer>(); // (4) Create a city set: Set<Integer> cityset = new HashSet<Integer>(); // (5) Push start city on the stack: citystack.push(startcitynum); // (6) Handle each city found on the stack: while (!citystack.empty()) { // Pop current city from the stack. int currentcitynum = citystack.pop(); // Check if the city has already been handled. if (!cityset.contains(currentcitynum)) { Java Actually 16: Implementing Dynamic Data Structures 16-39/44 // Insert current city to the city set. cityset.add(currentcitynum); // Push all cities that can be reached directly from // the current city on to the stack for (int j = 0; j < citygraph[currentcitynum].length; j++) { if (citygraph[currentcitynum][j]) citystack.push(j); // Remove start city from the city set, and print the city stack. cityset.remove(startcitynum); System.out.print("From city no. " + startcitynum + ", the following cities can be reached: " + cityset); Running the program: >java StackClient2 Type the number of the city to start from [0-4]: 3 From city no. 3, the following cities can be reached: [1, 2, 4] Java Actually 16: Implementing Dynamic Data Structures 16-40/44

21 ADT: Queues A queue is a FIFO (First-In, First-Out) structure (Figure 16.13). enqueue(element) "ice" "sleet" "snow" dequeue() peek() Queue operation enqueue(element) dequeue() peek() isempty() Queue operations Description Adds the element to the back of the queue. Removes and returns the first element in queue. Returns the first element in the queue without removing it from the queue. Returns true or false depending on whether the queue is empty or not. Java Actually 16: Implementing Dynamic Data Structures 16-41/44 Queue implementation by inheritance Since we have used inheritance, a client can break the abstraction a queue represents. class QueueByInheritance<E> extends LinkedList<E> { public void enqueue(e ) { // (1) insertattail(); public E dequeue() { // (2) if (empty()) return null; return removefromhead(); public E peek() { // (3) if (empty()) return null; return first().getdata(); public boolean empty() { // (4) return isempty(); Java Actually 16: Implementing Dynamic Data Structures 16-42/44

22 Client using a Queue (QueueClient.java) public class QueueClient { public static void main(string[] args) { // (1) Check if there are any program arguments: if (args.length == 0) { System.out.println("Usage: java QueueClient <argument list>"); return; // (2) Create a queue: QueueByInheritance<String> queue = new QueueByInheritance<String>(); // (3) Enqueue all the program arguments (strings): for (int i = 0; i < args.length; i++) queue.enqueue(args[i]); // (4) Dequeue the queue for all elements: while (!queue.empty()) System.out.print(queue.dequeue().toUpperCase() + " "); System.out.println(); Java Actually 16: Implementing Dynamic Data Structures 16-43/44 // (5) Can call methods that queues inherit and break // the queue abstraction: for (int i = 0; i < args.length; i++) queue.insertathead(args[i]); // (6) Print the queue elements: while (!queue.empty()) System.out.print(queue.dequeue().toUpperCase() + " "); System.out.println(); Running the program: >java QueueClient You are now number two in the queue YOU ARE NOW NUMBER TWO IN THE QUEUE QUEUE THE IN TWO NUMBER NOW ARE YOU Java Actually 16: Implementing Dynamic Data Structures 16-44/44

More on Exception Handling

Chapter 18 More on Exception Handling Lecture slides for: Java Actually: A Comprehensive Primer in Programming Khalid Azim Mughal, Torill Hamre, Rolf W. Rasmussen Cengage Learning, 2008. ISBN: 978-1-844480-933-2