1. COMPSCI 105 SS 2015 Principles of Computer Science Linked Lists 1

2. Agenda & Reading  Agenda  Introduction  The Node class  The UnorderedList ADT  Comparing Implementations  The OrderedList ADT  Linked List Iterators  Textbook:  Problem Solving with Algorithms and Data Structures  Chapter 3 – Lists  Chapter 3 - Unordered List Abstract Data Type  Chapter 3 - Implementing an Unordered List: Linked Lists  Chapter 3 – The OrderedList Abstract Data Type Lecture 12COMPSCI1052

3. Review  We have used Python lists to implement the abstract data types presented (Stack and Queue).  The list is a powerful, yet simple, collection mechanism that provides the programmer with a wide variety of operations.  A Python list  stores each element in contiguous memory if possible. This makes it possible to access any element in O(1) time.  However, insertion or deletion elements at the beginning of the list takes O(n). Lecture 12COMPSCI1053

4. 1 Introduction ADT List  A list is a collection of items where each item holds a relative position with respect to the others. We can consider the list as having a first item, a second item, a third item, and so on. We can also refer to the beginning of the list (the first item) and the end of the list (the last item).  Unordered Vs Ordered  Unordered meaning that the items are not stored in a sorted fashion.  A Python list ([]) is an implementation of an unordered list, 54, 26, 93, 17, 77 and 31 17, 26, 31, 54, 77 and 93 Lecture 12COMPSCI1054

5. 1 Introduction The List Abstract Data Type  What are the operations which can be used with a List Abstract Data?  creates a new list that is empty.  It needs no parameters and returns an empty list.  add(item) adds a new item to the list.  It needs the item and returns nothing. Assume the item is not already in the list.  remove(item) removes the item from the list.  It needs the item and modifies the list. Assume the item is present in the list.  search(item) searches for the item in the list.  It needs the item and returns a boolean value.  is_empty() tests to see whether the list is empty.  It needs no parameters and returns a boolean value.  size() returns the number of items in the list.  It needs no parameters and returns an integer. No checking is done in the implementation! Lecture 12COMPSCI1055

6. 1 Introduction Contiguous Memory  A Python list stores each element in contiguous memory if possible.  List ADT – there is no requirement that the items be stored in contiguous memory  In order to implement an unordered list, we will construct what is commonly known as a linked list.  A Node object will store  the data in the node of the list, and  a link to the next Node object. Lecture 12COMPSCI1056

7. 1 Introduction Insertion and Deletion  Items can be inserted into and deleted from the linked list without shifting data. Lecture 12COMPSCI1057

8.  A node  is the basic building block of a linked list.  contains the data as well as a link to the next node in the list. 2 The Node class The Node class p = Node(93) temp = Node(93) p = Node(93) temp = Node(93) p Lecture 12COMPSCI1058

9. 2 The Node class Definition of the Node class class Node: def __init__(self, init_data): self.data = init_data self.next = None def get_data(self): return self.data def get_next(self): return self.next def set_data(self, new_data): self.data = newdata def set_next(self, new_next): self.next = new_next) class Node: def __init__(self, init_data): self.data = init_data self.next = None def get_data(self): return self.data def get_next(self): return self.next def set_data(self, new_data): self.data = newdata def set_next(self, new_next): self.next = new_next) Lecture 12COMPSCI1059

10. 2 The Node class Chain of nodes  You can build a chain of nodes using Node objects n = Node(6) first = Node(9) first.set_next(n) n = Node(6) first = Node(9) first.set_next(n) n.set_data(1) print(first.get_next().get_data())) n.set_data(1) print(first.get_next().get_data())) 1 1 Lecture 12COMPSCI10510

11. Exercise 1  What is the output of the following program? def print_chain(n): while not n == None: print(n.get_data(), end = " ") n = n.get_next() n5 = Node(15) n6 = Node(34) n7 = Node(12) n8 = Node(84) n6.set_next(n5) n7.set_next(n8) n8.set_next(n6) n5.set_next(None) def print_chain(n): while not n == None: print(n.get_data(), end = " ") n = n.get_next() n5 = Node(15) n6 = Node(34) n7 = Node(12) n8 = Node(84) n6.set_next(n5) n7.set_next(n8) n8.set_next(n6) n5.set_next(None) print_chain(n5) print() print_chain(n6) print() print_chain(n7) print() print_chain(n8) print() print_chain(n5) print() print_chain(n6) print() print_chain(n7) print() print_chain(n8) print() Lecture 12COMPSCI10511

12. 3 The UnorderedList class The UnorderedList ADT  The unordered list is built from a collection of nodes, each linked to the next by explicit references.  It must maintain a reference to the first node (head)  It is commonly known as a linked list  Examples:  An Empty List:  A linked list of integers Lecture 12COMPSCI10512

13. 3 The UnorderedList class Operations  List() creates a new list that is empty.  It needs no parameters and returns an empty list.  add(item) adds a new item to the list.  It needs the item and returns nothing. Assume the item is not already in the list.  remove(item) removes the item from the list.  It needs the item and modifies the list. Assume the item is present in the list.  search(item) searches for the item in the list.  It needs the item and returns a boolean value.  is_empty() tests to see whether the list is empty.  It needs no parameters and returns a boolean value.  size() returns the number of items in the list.  It needs no parameters and returns an integer. No checking is done in the implementation! Lecture 12COMPSCI10513

14. 3 The UnorderedList class Constructor  The constructor contains  A head reference variable  References the list’s first node  Always exists even when the list is empty  Examples:  An Empty List:  A linked list of integers class UnorderedList: def __init__(self): self.head = None... class UnorderedList: def __init__(self): self.head = None... my_list = UnorderedList() for i in range(6): my_list.add(i) my_list = UnorderedList() for i in range(6): my_list.add(i) 1 234 5 0 Lecture 12COMPSCI10514

15. 3 The UnorderedList class List Traversals  To traverse a linked list, set a pointer to be the same address as head, process the data in the node, move the pointer to the next node, and so on. Loop stops when the next pointer is None.  Use a reference variable: curr  References the current node  Initially references the first node (head)  To advance the current position to the next node  Loop: curr = self.head curr = curr.get_next() curr = self.head while curr != None:... curr = curr.get_next() curr = self.head while curr != None:... curr = curr.get_next() Lecture 12COMPSCI10515

16. 3 The UnorderedList class Displaying the Contents  Traversing the Linked List from the Head to the End  Use a reference variable: curr curr = self.head while curr != None: print(curr.get_data(), end=" ") curr = curr.get_next() curr = self.head while curr != None: print(curr.get_data(), end=" ") curr = curr.get_next() Print the contents of a linked list 54 25 93 17 77 31 Lecture 12COMPSCI10516

17. 3 The UnorderedList class is_empty() & size()  is_empty()  tests to see whether the list is empty.  size()  Returns the number of items in the list.  Traverses the list and counts the number of items return self.head == None curr = self.head count = 0 while curr != None: count = count + 1 curr = curr.get_next() curr = self.head count = 0 while curr != None: count = count + 1 curr = curr.get_next() count 0->1->2->3->4->5->6 Lecture 12COMPSCI10517

18. 3 The UnorderedList class Inserting a Node  To insert at the beginning of a linked list  Create a new Node and store the new data into it  Connect the new node to the linked list by changing references  change the next reference of the new node to refer to the old first node of the list  modify the head of the list to refer to the new node 1 2 new_node.set_next(self.head) new_node = Node(item) 1 2 3 self.head = new_node 3 Lecture 12COMPSCI10518

19. 3 The UnorderedList class Searching an Item  Searches for the item in the list. Returns a Boolean.  Examples: print (my_list.search(17)) print (my_list.search(1)) current True False Lecture 12COMPSCI10519

20. 3 The UnorderedList class Searching an item  To search an item in a linked list:  set a pointer to be the same address as head,  process the data in the node, (search)  move the pointer to the next node, and so on.  Loop stops either 1) found the item, or 2) when the next pointer is None. curr = self.head while curr != None: if curr.get_data() == item: return True else: curr = curr.get_next() return False curr = self.head while curr != None: if curr.get_data() == item: return True else: curr = curr.get_next() return False Lecture 12COMPSCI10520

21. 3 The UnorderedList class Deleting a Node  Removes the item from the list.  It needs the item and modifies the list. Assume the item is present in the list.  Examples  Delete the first node  Delete a node in the middle of the list  With prev and curr references my_list.remove(5) my_list.remove(8) Lecture 12COMPSCI10521

22.  To delete a node from a linked list  Locate the node that you want to delete (curr)  Disconnect this node from the linked list by changing references  Two situations:  To delete the first node  Modify head to refer to the node after the current node  To delete a node in the middle of the list  Set next of the prev node to refer to the node after the current node 3 The UnorderedList class Deleting a Node 1 1 self.head = curr.get_next() previous.set_next(curr.get_next()) prev is None curr references to the first node Lecture 12COMPSCI10522

23. 4 Comparing Implementations UnorderedList Version2  With a count variable to count the number of items in the list class UnorderedListV2: def __init__(self): self.head = None self.count = 0 class UnorderedListV2: def __init__(self): self.head = None self.count = 0 def size(self): return self.count def is_empty(self): return self.count == 0 def size(self): return self.count def is_empty(self): return self.count == 0 Big-O is O(1) def add(self, item): new_node = Node(item)... self.count += 1 def add(self, item): new_node = Node(item)... self.count += 1 def remove(self, item): current = self.head... self.count -= 1 def remove(self, item): current = self.head... self.count -= 1 Lecture 12COMPSCI10523

24. 4 Comparing Implementations Comparing Implementations Python List UnorderedList if len(my_plist)== 0: …O(1)is_emptyO(1) lenO(1)sizeO(1) with count variable O(n) without count variable append (end of the python List) insert (i, item) O(1) O(n) addO(1) (beginning of the linked list) remove del O(n) inO(n)searchO(n) Lecture 12COMPSCI10524

25. 5 The OrderedList Unordered Vs Ordered  A list is a collection of items where each item holds a relative position with respect to the others.  It must maintain a reference to the first node (head)  It is commonly known as a linked list  Unordered Vs Ordered  Unordered meaning that the items are not stored in a sorted fashion.  The structure of an ordered list is a collection of items where each item holds a relative position that is based upon some underlying characteristic of the item 54, 26, 93, 17, 77 and 31 17, 26, 31, 54, 77 and 93 Unordered Ordered my_orderedlist = OrderedList() num_list = [77, 17, 26, 31, 93, 54] for num in num_list: my_orderedlist.add(num) my_orderedlist = OrderedList() num_list = [77, 17, 26, 31, 93, 54] for num in num_list: my_orderedlist.add(num) Lecture 12COMPSCI10525

26. 5 The OrderedList The OrderedList Abstract Data Type  What are the operations which can be used with an OrderedList Abstract Data?  creates a new list that is empty.  It needs no parameters and returns an empty list.  add(item) adds a new item to the list.  It needs the item and returns nothing. Assume the item is not already in the list.  remove(item) removes the item from the list.  It needs the item and modifies the list. Assume the item is present in the list.  search(item) searches for the item in the list.  It needs the item and returns a boolean value.  is_empty() tests to see whether the list is empty.  It needs no parameters and returns a boolean value.  size() returns the number of items in the list.  It needs no parameters and returns an integer. No checking is done in the implementation! Lecture 12COMPSCI10526

27. 5 The OrderedList Determine the point of insertion  Starting point:  current = self.head  previous = None  stop = False while current != None and not stop: if current.get_data() > item: stop = True else: previous = current current = current.get_next() while current != None and not stop: if current.get_data() > item: stop = True else: previous = current current = current.get_next() Integers are in ascending order my_orderedlist.add(49) previous 26 < 49 31 < 4954 > 49 17 < 49 Must determine the point of insertion Lecture 12COMPSCI10527

28. 5 The OrderedList Inserting a Node - OrderedList  Insert at the beginning of a linked list  Insert at the middle of a linked list  change the next reference of the new node to refer to the current node of the list  modify the next reference of the prev node to refer to the new node 1 2 12 new_node.set_next(self.head) self.head = new_node new_node.set_next(self.head) self.head = new_node new_node.set_next(current) previous.set_next(new_node) Lecture 12COMPSCI10528

29. 5 The OrderedList Searching an Item  Searches for the item in the list. Returns a Boolean.  Examples: print (my_linked_list.search(31)) print (my_linked_list.search(39)) current True False Lecture 12COMPSCI10529

30. 5 The OrderedList Searching an item  To search an item in a linked list:  set a pointer to be the same address as head,  process the data in the node, (search)  move the pointer to the next node, and so on.  Loop stops either 1) found the item, or 2) when the next pointer is None, or 3) value in the node is greater than the item that we are searching current = self.head while current != None: if current.get_data() == item: return True elif current.get_data() > item: return False else: current = current.get_next() return False current = self.head while current != None: if current.get_data() == item: return True elif current.get_data() > item: return False else: current = current.get_next() return False STOP Lecture 12COMPSCI10530

31. 5 The OrderedList UnorderedList Vs OrderedList UnorderedListOrderedList is_emptyO(1) sizeO(1) with count variable addO(1)O(n) removeO(n) searchO(n) Lecture 12COMPSCI10531

32. 6 Iterators Iterators  Traversals are very common operations, especially on containers.  Python’s for loop allows programmer to traverse items in strings, lists, tuples, and dictionaries:  Python compiler translates for loop to code that uses a special type of object called an iterator  An iterator guarantees that each element is visited exactly once.  It is useful to be able to traverse an UnorderedList or an OrderedList, i.e., visit each element exactly once.  To explicitly create an iterator, use the built-in iter function: for item in num_list: print(item) for item in num_list: print(item) i = iter(num_list) print(next(i)) # fetch first value print(next(i)) i = iter(num_list) print(next(i)) # fetch first value print(next(i)) 1212 1212 Lecture 12COMPSCI10532

33. 6 Iterators Create your own Iterator  You can create your own iterators if you write a function to generate the next item. You need to add:  Constructor  The __iter__() method, which must return the iterator object, and  the __next__() method, which returns the next element from a sequence.  For example: my_iterator = NumberIterator(11, 20) for num in my_iterator: print(num, end=" ") my_iterator = NumberIterator(11, 20) for num in my_iterator: print(num, end=" ") 11 12 13 14 15 16 17 18 19 20 Lecture 12COMPSCI10533

34. 6 Iterators The NumberIterator Class  Constructor, __iter__(), __next__ class NumberIterator: def __init__(self, low, high): self.current = low self.high = high def __iter__(self): return self def __next__(self): if self.current > self.high: raise StopIteration else: self.current += 1 return self.current - 1 class NumberIterator: def __init__(self, low, high): self.current = low self.high = high def __iter__(self): return self def __next__(self): if self.current > self.high: raise StopIteration else: self.current += 1 return self.current - 1 Raise this error to tell consumer to stop Lecture 12COMPSCI10534

35. 6 Linked List Iterators Linked List Traversals  Now, we would like to traverse an UnorderedList or an OrderedList using a for-loop, i.e., visit each element exactly once.  However, we will get the following error:  Solution:  Create an iterator class for the linked list.  Add the __iter()__ method to return an instance of the LinkedListIterator class. for num in my_linked_list: print(num, end=" ") for num in my_linked_list: print(num, end=" ") for num in my_linked_list: TypeError: 'UnorderedList' object is not iterable for num in my_linked_list: TypeError: 'UnorderedList' object is not iterable Lecture 12COMPSCI10535

36. 6 Linked List Iterators The LinkedListIterator  The UnorderedList class: class LinkedListIterator: def __init__( self, head): self.current = head def __next__( self ): if self.current != None: item = self.current.get_data() self.current = self.current.get_next() return item else : raise StopIteration class LinkedListIterator: def __init__( self, head): self.current = head def __next__( self ): if self.current != None: item = self.current.get_data() self.current = self.current.get_next() return item else : raise StopIteration class UnorderedList:... def __iter__(self): return LinkedListIterator(self.head) class UnorderedList:... def __iter__(self): return LinkedListIterator(self.head) Lecture 12COMPSCI10536

37. Exercise 2  What is the content inside the UnorderedList and OrderedList after executing the following code fragment? name_list = ["Gill", "Tom", "Eduardo", "Raffaele", "Serena", "Bella"] my_unorderedlist = UnorderedList() for name in name_list: my_unorderedlist.add(name) my_unorderedlist = UnorderedList() for name in name_list: my_unorderedlist.add(name) my_orderedlist = OrderedList() for name in name_list: my_orderedlist.add(name) my_orderedlist = OrderedList() for name in name_list: my_orderedlist.add(name) Lecture 12COMPSCI10537

38. Summary  Reference variables can be used to implement the data structure known as a linked list  Each reference in a linked list is a reference to the next node in the list  Any element in a list can be accessed directly; however, you must traverse a linked list to access a particular node  Items can be inserted into and deleted from a reference- based linked list without shifting data Lecture 12COMPSCI10538