Computer Science Fundamentals 107

Transcription

1 Computer Science Fundamentals 107 OrderedList ADT opera0ons OrderedList ADT using a singly linked list OrderedList implementa0on analysis Doubly linked lists a first taste

2 What is an ordered list? 2 unordered ordered Figure 15: An Ordered Linked List In an ordered list, elements are placed rela0ve to some ordering (ascending, descending).

3 The OrderedList ADT implementa?on 3 using a singly linked list These are some possible OrderedList opera0ons. add(item) remove(item) search(item) is_empty() size() index(item) pop() pop(pos) Note that it makes no sense to include the insert(pos, item) and the append(item) methods.

4 The OrderedList ADT Implementa?on 4 Assump?ons pop() pop(pos) These methods assume that there are enough items already in the list. remove(item) index(item) These methods assume that the parameter item is present in the OrderedList, i.e., no checking is done in the implementa0on. add(item) This method assumes that the parameter item is NOT already present in the OrderedList, i.e., no checking is done in the implementa0on. For simplicity, assumes that OrderedLists cannot contain duplicate items.

5 The OrderedList ADT Implementa?on 5 We will use a chain of Node objects to implement the OrderedList ADT. pop() head... pop(pos) remove(item) index(item) next... add(item) next search(item) is_empty() size()... next = OrderedList() next None.add("Dog").add("Cat")

6 OrderedList implementa?on 6 Stored in the file, OrderedSLLinkedList.py. class OrderedList: def init (self): self.head = None self.count = 0 init () head None count 0 from OrderedSLLinkedList import OrderedList = OrderedList() This implementa0on will keep the items in ascending alphabe0c order.

7 OrderedList implementa?on add() 7 add( ) a new item to the list. class OrderedList: def init (self): self.head = None self.count = 0 def add(self, item):??? head None count 0 head count 1 dog next: None Assump?on: the item to be added is not already in the list from OrderedSLLinkedList def main(): import OrderedList = OrderedList().add("dog").add("cat").add("zebra") main() head count 2 cat next: dog next:none head count 3 cat dog next: next: zebra next:none

8 OrderedList implementa?on add() In the add() method we will use two references, current and previous where previous follows current through the list. 8 Either need to add the first node:.add("ant") head count 2 cat next: current previous?????? dog next:none or a node inside the list (or at the end) of the list:.add("zebra") current??? previous???

9 OrderedList implementa?on add() 9 class OrderedList: def init (self): def add(self, item): temp = Node(item) current = self.head previous = None found_pos = False while current!= None and not found_pos: if current.get_() > item: found_pos = True else: previous = current current = current.get_next() if previous == None: temp.set_next(self.head) self.head = temp else: temp.set_next(current) previous.set_next(temp) self.count += 1

10 OrderedList implementa?on remove() Assump0on that the item to be removed is present in the list 10 head count 3 ant next: cat next: dog next:none Either need to remove the first node:.remove("ant") current previous?????? or a node inside the list (or at the end) of the list:.remove("cat") current previous??????

11 11 OrderedList implementa?on remove() class OrderedList: def init (self): def remove(self, item): current = self.head previous = None found = False while not found: if current.get_() == item: found = True else: previous = current current = current.get_next() if previous == None: self.head = current.get_next() else: previous.set_next(current.get_next()) self.count -= 1 Assump0on that the item to be removed is present in the list What is the Big O for the remove() method? If the above assump0on is not made, how would you change the code? (Make sure the change is efficient given that it is a sorted list.)

12 OrderedList implementa?on search() 12 The search() method returns a boolean. head count 3 ant next: cat next: dog next:none Either the item is found.search("cat") or, the item is not found.search("bee") current??? current??? Which element is current poin0ng to if the method returns True/False?

13 OrderedList implementa?on search() 13 class OrderedList: def init (self): def search(self, item): current = self.head while current!= None: if current.get_() == item: return True elif current.get_() > item: return False else: current = current.get_next() return False

14 OrderedList implementa?ons Using sorted Linked List vs sorted Python list 14 OrderedList (linked list) Maintaining a sorted Python list implementa0on add(item) O(n) add(item) O(n) remove(item) O(n) remove(item) O(n) search(item) O(n) in (search) O(n) is_empty() O(1) is_empty() O(1) size() if count variable O(1) len() O(1) head ant next: cat dog next:... next:none vs 0"""""""""""""1" """2" """3" "..."" "n

15 Linked List - Things to consider 15 Are there any advantages to using an OrderedList (linked list implementa0on) vs using a Python list? linked lists advantages? linked lists disadvantages?

16 Linked List - Things to consider 16 linked lists advantages? Grows and shrinks as required (nodes in a linked structure are allocated individually) Inser0ng and dele0ng are more efficient (don't need to reorganize/move all the subsequent elements) linked lists disadvantages? Random access of elements is inefficient (O(n)), Each element needs to contain the informa0on as well as a pointer to the next.

17 Singly-Linked Lists Using singly linked lists proved quite awkward when removing or adding to a sorted list in that we needed a 'current and a 'previous' reference. 17 previous None previous head current 21 next: 46 current next: None class OrderedList: def remove(self, item): current = self.head previous = None if previous == None: self.head = current.get_next() else: previous.set_next(current.get_next())

18 Singly-Linked Lists 18 Certain tasks are awkward using a singly linked list, e.g., very hard to process this implementa0on of a list in reverse. head count 3 ant next: cat next: dog next:none class OrderedList: def init (self): self.head = None self.count = 0 def remove(self, item): current = self.head previous = None found = False

19 Doubly-Linked Lists 19 A doubly-linked list consists of a sequence of nodes, connected by links in both direc0ons. next prev... Another node Another node The Node class for a doublylinked list needs two pointers. class Node: def init (self, init_): self. = init_ self.prev = None self.next = None Stored in the file, DLNode.py. For unordered/ordered lists.

20 class Node: def init (self, init_): self. = init_ self.prev = None self.next = None def get_(self): return self. def get_prev(self): return self.prev def get_next(self): return self.next def set_(self, new_): self. = new_ def set_next(self, new_next): self.next = new_next def set_prev(self, new_prev): self.prev = new_prev... next Another node prev Another node 20 Doubly-Linked Lists Node class

21 Doubly-Linked Lists implementa?on A head reference is used to reference the first node in the list. A tail reference points to the last node and is commonly used with a doubly linked list to take advantage of the reverse chain which allows for traversals from the back of the list to the front of the list The last node in the list is indicated by a None in the next reference (as was done in the singly linked list). Since the list can be traversed in reverse order we must also indicate the first node. This is done using a None in the prev reference of the first node. head None count 0 tail None from DLNode import Node class OrderedList: def init (self): self.head = None self.tail = None self.count = 0 21

22 Doubly-Linked Lists add() Adding a new element at a given point in a doubly linked list. Four cases to consider: 1. inser0on in an empty linked list 22 We are talking about an OrderedList is this discussion. head None count 0 tail None.add("dog") 2. inser0on before the first node of a nonempty linked list head count 1 tail None prev dog next None.add("ant")

23 Doubly-Linked Lists add() 23 Four cases to consider con0nued: 3. inser0on aher the last node of a non-empty linked list head count 2 tail None prev ant next prev dog next None.add("zebra") dog 4. inser0on between nodes of a non-empty linked list head count 3 tail None prev ant next prev dog next prev zebra next None.add("cat") zebra The inser0on algorithm needs references to the new node s successor and predecessor.

24 Doubly-Linked Lists add() 24 from DLNode import Node class OrderedList: def init (self): self.head = None self.tail = None self.count = 0 def add(self, item): new_node = Node(item)???? #empty list???? #insert before 1 st node???? #insert after last node???? #insert in the middle

25 Doubly-Linked Lists search() 25 Searching in either direc0on is fine. Can stop searching once an item which is greater/smaller is found. from DLNode import Node class OrderedList: def init (self): self.head = None self.tail = None self.count = 0 def search(self, item): current = self.head while current!= None: if current.get_() == item: return True elif current.get_() > item: return False else: current = current.get_next() return False

26 Doubly-Linked Lists remove() 26 Remove an item from the linked list. Four cases to consider: Assume the item to be removed is present in the list 1. Remove node from a list with one element.remove("dog") 2. Remove first node (list has more than 1 element).remove("ant")

27 Doubly-Linked Lists remove() 27 Four cases to consider con0nued: 3. Remove last node (list has more than 1 element) of the head last (but not first) nextnode count 3 tail None prev zebra.remove("zebra") ant prev 4. Remove an intermediate node dog next prev zebra next None head count 3 tail None prev ant next prev dog next prev zebra next None zebra.remove("dog") The dele0on algorithm needs pointers to the new node s successor and predecessor.

28 Doubly-Linked Lists remove() 28 from DLNode import Node class OrderedList: def init (self): self.head = None self.tail = None self.count = 0 Assume that the item to be removed is present in the list. def remove(item):???? #remove from a list with one element???? #remove first node (list has more than 1 element)???? #remove last node (list has more than 1 element)???? #remove intermediate node

29 Doubly-Linked Lists 29 Doubly Linked OrderedList add(item) remove(item) search(item) is_empty() size() if count variable O(n) O(n) O(n) O(1) O(1) Doubly linked list needs two references per node. Think about the running 0mes for doubly-linked unordered lists!