ECM1406. Answer Sheet Lists

Transcription

1 ECM1406 Answer Sheet Lists These questions are based on those found in Chapters 3 and 4 of the core text Data Structures Using Java by Malik and Nair. The source code for the ArrayListClass, UnorderedArrayList, DataElement and IntElement class are available on the Study Resources page for this module. Exercise 1: The method removeat of the class ArrayListClass removes an element from the list by shifting the elements of the list. However, if the element to be removed is at the beginning of a fairly large list, it could take a long time. Because the list elements are in no particular order, it would be possible to swap the last element of the list with the item to be removed and reduce the length of the list. Rewrite the method removeat to use this technique. Write a program to test the revised method removeat. Exercise 2: The method remove of the class ArrayListClass removes only the first occurrence of an element. Add a method removeall as an abstract method to the ArrayListClass that would remove all occurrences of a given element. Write the definition of the removeall method for the UnorderedArrayList class and a program to test this method. Exercise 3: Develop a LinkedListClass class from the code fragments given in the notes, using the class ArrayListClass as your template. Derive a class UnorderedLinkedList which provides a concrete implementation. Write a program to test the insertion, deletion, search, copylist and copy constructor operations for your UnorderedLinkedList class. Exercise 4: Rework the method removeall from exercise 2 for use with the LinkedListClass and UnorderedLinkList classes. Write a program to test your method.

2 Answer 1: ArrayListClassEx1.java 1 /** 2 * The method removeat of the class ArrayListClass removes an element 3 * from the list by shifting the elements of the list. However, if 4 * the element to be removed is towards the beginning of a fairly 5 * large list, it could take a long time. Because the list elements 6 * are in no particular order, it is possible to swap the last element 7 * of the list with the item to be removed and reduce the length of 8 * the list. 9 * 10 * Rather than rewriting the whole class, we simply provide a 11 * new class which overrides the removeat method as described. 12 * The new test program simply needs to use the new class. 13 */ public class ArrayListClassEx1 extends UnorderedArrayListEx2 { 16 /** 17 * Parametric Constructor. Unfortunately we still have to provide 18 * a constructor for the new class * 20 size an int given the maximum size of the list. 21 */ public ArrayListClassEx1(int size) { 24 super(size); 25 } /** 28 * Remove an item at a given position from the list. 29 * If the position is out of range, an appropriate message 30 * is printed. This is a revised removeat as indicated in 31 * the exercise. 32 * 33 location an int giving the position of the item to 34 * be removed. 35 */ public void removeat(int location) { 38 if (location < 0 location >= length) { 39 System.err.println("The location of the item to be " 40 + "removed is out of range."); 41 } else { 42 // Copy this element a copy of the last element 43 list[location] = list[length - 1]; // Remove the last element 46 length--; 47 list[length] = null; // Having just removed an object, we should call the 50 // garbage collector. 51 System.gc(); 52 } 53 } 54 } 2

3 TestEx1.java 1 /** 2 * Program to test the removeat method of the ArrayListClass. 3 */ 4 5 import java.io.*; 6 import java.util.*; 7 8 public class TestEx1 { 9 10 static BufferedReader keyboard = new 11 BufferedReader(new InputStreamReader(System.in)); public static void main(string[] args) throws IOException { 14 //* A list of up to 50 elements 15 ArrayListClassEx1 intlist = new ArrayListClassEx1(50); //* A temporary element to hold input values 18 IntElement num = new IntElement(); //* A counter so we know how many elements we have input 21 int counter; //* The position of a given element 24 int position; //* The keyboard input buffer 27 StringTokenizer tokenizer; // Tell the user what we are up to. 30 System.out.println("Processing the integer list."); 31 System.out.print("Enter 8 integers in the same line: "); 32 System.out.flush(); tokenizer = new StringTokenizer(keyboard.readLine()); // Read 8 numbers from the user input and place them into 37 // the ArrayList 38 for ( counter = 0; counter < 8; counter++ ) { 39 num.setnum(integer.parseint(tokenizer.nexttoken())); 40 intlist.insert(num); 41 } // Allow the user to confirm the input 44 System.out.println(); 45 System.out.print("The list you entered is: "); 46 intlist.print(); 47 System.out.println(); // Now ask which number they wish to remove 50 System.out.print("Enter the position of the num to be deleted: "); 51 System.out.flush(); 52 position = Integer.parseInt(keyboard.readLine()); 53 System.out.println(); // Remove it 56 intlist.removeat(position); 57 System.out.println("After removing the element at position " 58 + position + ", intlist:"); intlist.print(); 61 System.out.println(); 62 } 63 } 3

4 Answer 2: 1. Copy ArrayListClass.java to ArrayListClassEx2.java, adding the following: 284 /** 285 * Remove all occurrences of an item from the list. 286 * 287 removeitem 288 */ public abstract void removeall(dataelement removeitem); 2. Copy UnorderedArrayList.java to UnorderedArrayListEx2.java adding the following: 122 /** 123 * Remove all of the occurrences of an element from the list. 124 * Scan the whole list and remove all occurrences of an element 125 * from the list. 126 * 127 removeitem the DataElement to remove from the list. 128 */ public void removeall(dataelement removeitem) { 131 int current; if ( length == 0 ) { 134 System.err.println("Cannot delete from an empty list."); 135 } else { 136 current = 0; while ( current < length ) { 139 if ( list[current].equals(removeitem)) { 140 removeat(current); 141 } else { 142 current++; 143 } 144 } 145 } 146 } TestEx2.java 1 /** 2 * Program to test the removeall method of the UnorderedArrayList 3 * as extended by the second exercise. 4 */ 5 6 import java.io.*; 7 import java.util.*; public class TestEx2 { 11 static BufferedReader keyboard = new 12 BufferedReader(new InputStreamReader(System.in)); public static void main(string[] args) throws IOException { 4

5 15 //* A list of up to 50 elements (with the removeall method) 16 UnorderedArrayListEx2 intlist = new UnorderedArrayListEx2(50); //* A temporary element to hold input values 19 IntElement num = new IntElement(); //* A counter so we know how many elements we have input 22 int counter; //* The keyboard input buffer 25 StringTokenizer tokenizer; // Tell the user what we are up to. 28 System.out.println("Processing the integer list."); 29 System.out.print("Enter 8 integers in the same line: "); 30 System.out.flush(); tokenizer = new StringTokenizer(keyboard.readLine()); // Read 8 numbers from the user input and place them into 35 // the ArrayList 36 for ( counter = 0; counter < 8; counter++ ) { 37 num.setnum(integer.parseint(tokenizer.nexttoken())); 38 intlist.insertat(counter,num); 39 } // Allow the user to confirm the input 42 System.out.println(); 43 System.out.print("The list you entered is: "); 44 intlist.print(); 45 System.out.println(); // Now ask which number they wish to remove 48 System.out.print("Enter the num to be deleted: "); 49 System.out.flush(); 50 num.setnum(integer.parseint(keyboard.readline())); 51 System.out.println(); // Remove all instances of the number 54 intlist.removeall(num); 55 System.out.println("After removing " + num.getnum() + ", intlist:"); intlist.print(); 58 System.out.println(); 59 } 60 } 5

6 Answer 3: LinkedListClassEx3.java 1 /** 2 * An abstract class that allows for an unbounded list of data elements. 3 */ 4 5 public abstract class LinkedListClassEx3 { 6 //* A reference to the first node in the list. 7 protected LinkedListNode first; 8 9 //* A reference to the last node in the list. 10 protected LinkedListNode last; //** An int to keep track of the number of nodes in the list. 13 protected int count; /** 16 * Default Constructor. 17 * Initialises the list to an empty list. As this is a linked 18 * list implementation there is no maximum size to set. 19 */ public LinkedListClassEx3() { 22 first = null; 23 last = null; 24 count = 0; 25 } /** 28 * Determine if the list is empty. 29 * The list is empty only when there are no element in the list, 30 * i.e., the head of the list is still referring to null. 31 * 32 true if the list is empty; false otherwise. 33 */ public boolean isempty() { 36 return (first == null); 37 } /** 40 * Clears the list of all contents. 41 * Resets the list to the empty state. 42 */ public void clear() { 45 first = null; 46 last = null; 47 count = 0; 48 System.gc(); 49 } /** 52 * Print the contents of the list to the standard output 53 * device. 54 */ public void print() { 57 // Start with the first node in the list 58 LinkedListNode current = first; 59 6

7 60 // While there are more nodes to be displayed 61 while ( current!= null ) { 62 System.out.print(current.data + " "); 63 current = current.link; 64 } 65 } /** 68 * Return the number of elements in the list. 69 * 70 a count of the number of elements in the list. 71 */ public int length() { 74 return count; 75 } /** 78 * Return a copy of the first element in the list. 79 * 80 a copy of the DataElement at the start of the list, 81 * or null if there is no list. 82 */ public DataElement front() { 85 DataElement temp = null; 86 if ( first!= null ) { 87 // Avoid a null pointer exception 88 temp = first.data.getcopy(); 89 } 90 return temp; 91 } /** 94 * Return a copy last element in the list. 95 * 96 a copy of the last DataElement in the list or a 97 * null if there is no list. 98 */ public DataElement back() { 101 DataElement temp = null; 102 if ( last!= null ) { 103 // Avoid a null pointer exception 104 temp = last.data.getcopy(); 105 } 106 return temp; 107 } // It might be better to let the null pointer exception occur 110 // and catch it, rather than preventing it in the first place /** 113 * Insert a new element at the start of the list. 114 * 115 newitem the DataElement to insert into the list. 116 */ public void insertfirst(dataelement newitem) { 119 LinkedListNode newnode; // Create a new node with newitem as the payload 122 newnode = new LinkedListNode(); 123 newnode.data = newitem.getcopy(); // Link the new node into the front of the list 7

8 126 newnode.link = first; 127 first = newnode; if ( last == null ) { 130 // if the list was empty, the new node is now 131 // the last in the list as well as the first 132 last = newnode; 133 } 134 count++; 135 } /** 138 * Insert a copy of newitem at the end of the list. 139 * 140 newitem the DataElement to add onto the end of the list. 141 */ public void insertlast(dataelement newitem) { 144 LinkedListNode newnode; // Create a new node to become the new end node 147 newnode = new LinkedListNode(); 148 newnode.data = newitem.getcopy(); 149 newnode.link = null; // If the list is empty, add the newnode to the front 152 // of the list. 153 if ( first == null ) { 154 first = newnode; 155 last = newnode; 156 } else { 157 // List not empty, insert newnode after last 158 last.link = newnode; 159 last = newnode; 160 } 161 count++; 162 } // end insertlast /**************************************************************/ 165 /* Abstract Methods to be supplied by implementations of this */ 166 class. */ 167 /**************************************************************/ /** 170 * Search for a specific element in the list. 171 * 172 target the DataElement to search for. 173 true if the target element is found in the 174 * list; false otherwise. 175 */ public abstract boolean search(dataelement target); /** 180 * Remove a specific element from the list. 181 * 182 deleteitem the DataElement to be removed. 183 */ public abstract void deletenode(dataelement deleteitem); /**************************************************************/ /** 190 * Make the current list a copy of another list. 191 * Performs a deep copy, that is it makes a new copies of each of 8

9 192 * the DataElements within the other list. 193 * 194 otherlist the LinkedListClass to duplicate. 195 */ private void copy(linkedlistclassex3 otherlist) { 198 LinkedListNode newnode; // variable to create a node 199 LinkedListNode current; // variable to traverse the list first = null; //make this list empty if ( otherlist.first == null ) { 204 // otherlist is empty 205 first = null; 206 last = null; 207 count = 0; 208 } else { 209 // Copy other list into this list 210 // Start with the first element of the other list 211 count = otherlist.count; 212 current = otherlist.first; // Copy the first element 215 first = new LinkedListNode(); 216 first.data = current.data.getcopy(); 217 first.link = null; // We now have one node in out list 220 last = first; // Start to traverse the other list 223 current = current.link; // While there are nodes in the other list, 226 // copy them into this list 227 while ( current!= null ) { 228 // Make copy of node in other list 229 newnode = new LinkedListNode(); 230 newnode.data = current.data.getcopy(); // Add new node to end of this list 233 newnode.link = null; 234 last.link = newnode; 235 last = newnode; // Move on to next node in other list 238 current = current.link; 239 } 240 } 241 } /** 244 * Make this list a copy of another list. 245 * This is simply another name for the copy() method. 246 * 247 otherlist the other LinkedListClass to duplicate. 248 */ public void copylist(linkedlistclassex3 otherlist) { 251 if ( this!= otherlist ) { 252 //avoid self-copy 253 copy(otherlist); 254 } 255 } /** 9

10 258 * Copy constructor, makes a new list which is a direct copy 259 * of another list. This list is a deep copy of the other 260 * list. 261 * 262 otherlist the other LinkedListClass to copy. 263 */ public LinkedListClassEx3(LinkedListClassEx3 otherlist) { 266 copy(otherlist); 267 } 268 } UnorderedLinkedListEx3.java 1 /** 2 * The UnorderedLinkedList provides a concrete implementation of the 3 * abstract LinkedListClass. This is an unordered list, so we don t 4 * need to worry about keeping the elements of the list in order. 5 */ 6 7 public class UnorderedLinkedListEx3 extends LinkedListClassEx3 { 8 9 //* The default constructor simply create an empty list. 10 public UnorderedLinkedListEx3() { 11 super(); 12 } /** 15 * The copy constructor will make a new list which is a duplicate 16 * of another list, duplicating all of the elements with the list 17 * so that operations on the original list will not effect elements 18 * in the new list. 19 * 20 otherlist the UnorderedLinkedList to duplicate. 21 */ public UnorderedLinkedListEx3(UnorderedLinkedListEx3 otherlist) { 24 // All that really means is that we call the copy 25 // constructor or the abstract LinkedListClass. 26 super(otherlist); 27 } /************************************************************/ 30 /* Concrete implementations of the abstract methods defined */ 31 by the abstract class LinkedListClass */ 32 /************************************************************/ /** 35 * Search for a specific element in the list. 36 * 37 target the DataElement to search for. 38 true if the target element is found in the 39 * list; false otherwise. 40 */ public boolean search(dataelement target) { 43 LinkedListNode current; // variable to traverse the list 44 boolean found = false; // default to the worst case // Start the search as the front of the list 47 current = first; // While there are nodes in the list 10

11 50 while ( current!= null &&!found ) { 51 if ( current.data.equals(target) ) { 52 // we have found our target 53 found = true; 54 } else { 55 // Not found, keep looking 56 current = current.link; 57 } 58 } 59 return found; 60 } /** 63 * Remove a specific element from the list. 64 * 65 deleteitem the DataElement to be removed. 66 */ public void deletenode(dataelement deleteitem) { 69 if ( first == null ) { 70 // List empty, report it as an error 71 System.err.println("Cannot delete from an empty list."); 72 } else { 73 // So we know the list is not empty. 74 if ( first.data.equals(deleteitem) ) { 75 // The item we wish to delete is the first element 76 // of the list, simply move head of the list to the 77 // next element in the list. 78 first = first.link; if ( first == null ) { 81 // There was only one element in the list, 82 // so make the list empty 83 last = null; 84 } count--; 87 } else { 88 // Okay so we have to search the list for the item 89 // we wish to delete. 90 boolean found = false; // assume worst case // We know it s not the first element of the list, 93 // so lets start looking from the second element. 94 LinkedListNode current = first.link; // In order to remove the node we need to keep track 97 // of the node which proceeds the current node so 98 // we can modify its link correctly. 99 // As we are staring with the second node, 100 // that must be the first node. 101 LinkedListNode previous = first; // While we have not found the node, and we have not 104 // reached the end of the list. 105 while ( current!= null &&! found ) { 106 if ( current.data.equals(deleteitem) ) { 107 // we have found our target 108 found = true; 109 } else { 110 // keep looking 111 previous = current; 112 current = current.link; 113 } 114 }

12 116 // Did we find the blasted thing 117 if ( found ) { 118 // Yes, the remove it! 119 // Modify the link on the previous node to refer 120 // to the next node, skipping the current node 121 // all together. 122 previous.link = current.link; // If it was the last node, make the previous 125 // node the last node. 126 if ( last == current ) { 127 last = previous; 128 } count--; 131 } else { 132 // Target node was not found! 133 // Report an error to the standard error output 134 System.out.println("Item to be deleted is " "not in the list."); 136 } 137 } 138 // We really should invoke the garbage collector, 139 // but it s not worth it for a single object. 140 } 141 } 142 } TestEx3.java 1 /** 2 * Program to test the UnorderedLinkedList Class. 3 */ 4 5 import java.io.*; 6 import java.util.*; 7 8 public class TestEx3 { 9 static BufferedReader keyboard = new 10 BufferedReader(new InputStreamReader(System.in)); public static void main(string[] args) throws IOException { 13 UnorderedLinkedListEx3 list1 = new UnorderedLinkedListEx3(); 14 UnorderedLinkedListEx3 list2 = new UnorderedLinkedListEx3(); //* A temporary element to hold input values 17 IntElement num = new IntElement(); // Tell the user what we are up to 20 System.out.println("Enter integers on one line."); 21 StringTokenizer tokenizer = new StringTokenizer(keyboard.readLine()); // Read a number of item from the input string adding it to the list 24 while ( tokenizer.hasmoretokens() ) { 25 num.setnum( Integer.parseInt(tokenizer.nextToken()) ); 26 list1.insertlast(num); 27 } // Allow the user to confirm the input 30 System.out.println(); 31 System.out.print("List 1: "); 32 list1.print(); System.out.println(); 12

13 35 System.out.println("Length of list 1: " + list1.length()); // Test 1: Search the list for a specific value 38 System.out.print("\nTest 1: Enter the number to be searched: "); 39 System.out.flush(); 40 num.setnum(integer.parseint(keyboard.readline())); 41 System.out.println(); if (list1.search(num) ) { 44 System.out.println("Test 1: " + num + " found in list 1."); 45 } else { 46 System.out.println("Test 1: " + num + " is not in list 1."); 47 } // Test 2: Make a copy of the list 50 list2.copylist(list1); System.out.println("\nTest 2: After copying list 1 into list 2"); 53 System.out.print("list 2: "); 54 list2.print(); 55 System.out.println(); 56 System.out.println("Test 2: Length of list 2: " + list2.length()); // Test 3: Delete a node from the list 59 System.out.print("\nTest 3: Enter the number to be deleted: "); 60 System.out.flush(); 61 num.setnum(integer.parseint(keyboard.readline())); list2.deletenode(num); System.out.print("Test 3: After deleting " + num + " list 2: "); 66 list2.print(); 67 System.out.println(); 68 System.out.println("Test 3: Length of list 2: " + list2.length()); // Test 4: Use the copy constructor to duplicate a list 71 UnorderedLinkedListEx3 list3 = new UnorderedLinkedListEx3(list1); // If the list was correctly copied, with a deep copy this 74 // should be fine. If it was only cloned, copied with a 75 // shallow copy, this will cause a null pointer exception 76 // when we access the original list. 77 destroylist(list3); System.out.print("Test 4: list 1: "); 80 list1.print(); 81 System.out.println(); 82 System.out.println("Test 4: Length of list 1: " + list1.length()); 83 } /** 86 * Destroy a list and all the elements within the list. 87 * 88 list the list to be destroyed. 89 */ 90 private static void destroylist(unorderedlinkedlistex3 list) { 91 System.out.println("In the method destroylist."); 92 list.print(); 93 System.out.println(); // Clear the actual list. 96 list.clear(); System.out.println("Exiting the method destroylist."); 99 } 100 } 13

14 Answer 4: 1. Copy LinkedListClassEx3.java to LinkedListClassEx4.java adding the following to the abstract methods section: 187 /** 188 * Remove all occurrences of an item from the list. 189 * 190 removeitem 191 */ public abstract void removeall(dataelement removeitem); 2. Copy UnorderedLinkedListEx3.java to UnorderedLinkedListEx4.java adding the following: 143 /** 144 * Remove all of the occurrences of an element from the list. 145 * Scan the whole list and remove all occurrences of an element 146 * from the list. 147 * 148 removeitem the DataElement to remove from the list. 149 */ public void removeall(dataelement removeitem) { 152 if ( first == null ) { 153 // List empty, report it as an error 154 System.err.println("Cannot delete from an empty list."); 155 } else { 156 // Start at the beginning, always a good place to start 157 LinkedListNode current = first; 158 LinkedListNode previous = null; // While there are nodes in the list 161 while ( current!= null ) { 162 // Should we remove it? 163 if ( current.data.equals(removeitem) ) { 164 // Is it the head of the list? 165 if ( current == first ) { 166 first = first.link; 167 current = first; // Was it the only item in the list? 170 if ( first == null ) { 171 last = null; 172 } 173 } else { 174 // Not first element 175 previous.link = current.link; // Is the last element? 178 if ( current == last ) { 179 last = previous; 180 } else { 181 current = previous.link; 182 } 183 } // Decrement cashed list length 186 count--; 187 } else { 188 // Not for removal, move on to next node 189 previous = current; 190 current = current.link; 191 } 192 } 14

15 // We will call up the garbage collector this time, as 195 // we could have removed a large number of elements 196 System.gc(); 197 } 198 } TestEx4.java 1 /** 2 * Program to test the removeall method of the UnorderedLinkedList 3 * as extended by the second exercise. 4 */ 5 6 import java.io.*; 7 import java.util.*; public class TestEx4 { 11 static BufferedReader keyboard = new 12 BufferedReader(new InputStreamReader(System.in)); public static void main(string[] args) throws IOException { 15 //* An unbounded list of elements (with the removeall method) 16 UnorderedLinkedListEx4 list = new UnorderedLinkedListEx4(); //* A temporary element to hold input values 19 IntElement num = new IntElement(); //* The keyboard input buffer 22 StringTokenizer tokenizer; // Tell the user what we are up to 25 System.out.println("Enter integers on one line."); 26 tokenizer = new StringTokenizer(keyboard.readLine()); // Read a number of item from the input string adding it to the list 29 while ( tokenizer.hasmoretokens() ) { 30 num.setnum( Integer.parseInt(tokenizer.nextToken()) ); 31 list.insertlast(num); 32 } // Allow the user to confirm the input 35 System.out.println(); 36 System.out.println("list: "); 37 list.print(); System.out.println(); 40 System.out.println("Length of list: " + list.length()); // Test 1: Remove All 43 System.out.print("Enter the number to be deleted: "); 44 System.out.flush(); 45 num.setnum(integer.parseint(keyboard.readline())); // Remove all instances of the number 48 list.removeall(num); 49 System.out.println("After removing all occurrences of " + num + " list: "); 50 list.print(); 51 System.out.println(); 52 System.out.println("Length of list: " + list.length()); 53 } 54 } 15