1 Deletion in singly linked lists (cont d) 1 Other Functions. 1 Doubly Linked Lists. 1 Circular lists. 1 Linked lists vs. arrays

Transcription

1 Unit 3: Linked Lists Part 2: More on Linked Lists 1 Deletion in singly linked lists (cont d) 1 Other Functions Engineering 4892: Data Structures 1 Doubly Linked Lists Faculty of Engineering & Applied Science Memorial University of Newfoundland 1 Circular lists May 30, Linked lists vs. arrays ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 Deletion in singly linked lists (cont d) We now consider the more general deletenode method. deletenode deletes the node containing a particular integer (it will delete the first node containing the integer, if there are more than one). In the following, we are trying to delete the 8-node. First, we will need to search for the node to delete. Removing a node from an SLL is accomplished by linking the node s predecessor to its successor. Like in deletefromtail we will have to use a loop to find the predecessor. So we need two loops: one to find tmp, the node to remove one to find tmp s predecessor, pred The loop begins with pred = head and tmp = head >next. At each step, both pred and tmp are incremented: pred = pred >next, tmp = tmp >next Actually, we can combine these into one. ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20

2 Before continuing we check that tmp!= 0 (if this is not true, the item does not exist... so we have nothing to do). The loop terminates when tmp is at the item to delete: tmp >info == el. Actually, if the item is not present this will never happen. So we should check that tmp!= 0 before trying to dereference tmp. The loop: IntSLLNode pred, tmp ; The 8-node is removed by setting pred >next = tmp >next. tmp is delete ed ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 This is the code for the general case: void IntSLList : : deletenode ( int el ) { IntSLLNode pred, tmp ; if ( tmp!= 0) { pred >next = tmp >next ; There are several special cases: Trying to delete from an empty list Could prevent by precondition; Here we choose to allow this Exit immediately if head = 0 Deleting the one node in an SLL of length 1: Delete the node and set head = tail = 0 if ( head == tail && el == head >info ) { Deleting the first node in an SLL of length 2: Update head and delete the node else if ( el == head >info ) { IntSLLNode tmp = head ; head = head >next ; Deleting the last node in an SLL of length 2: Same as general case, but set tail = pred ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20

3 void IntSLList : : deletenode ( int el ) { if ( head!= 0) // i f non empty l i s t ; if ( head == tail && el == head >info ) { // i f o n l y one node else if ( el == head >info ) { // i f more than one node IntSLLNode tmp = head ; // and o l d head i s d e l e t e d head = head >next ; else { // i f more than one node IntSLLNode pred, tmp ; // and a non head d e l e t e d if ( tmp!= 0) { pred >next = tmp >next ; if ( tmp == tail ) tail = pred ; What is the asymptotic complexity of deletenode? Best case: O(1) Worst case: This requires going into our loop n 1 times. Thus, it is O(n), just like deletefromtail. Average case: Assume that every node has an equal chance of being deleted. How many iterations through the loop are there for each possible position: First node: 0 iterations (special case) Second node: 0 iterations Third node: 1 iteration... Last node: n 2 iterations The average number of iterations is: 1 n (1 + + (n 2)) = n n = O(n) ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 Other Functions Consider the following functions of IntSLList, The search function isinlist(): bool IntSLList : : isinlist ( int el ) const { IntSLLNode tmp ; for ( tmp = head ; tmp = tmp >next ) ; return tmp!= 0 ; Best case: O(1) Worst case: O(n) The destructor: IntSLList : : IntSLList ( ) { for ( IntSLLNode p ;! isempty ( ) ; ) { p = head >next ; head = p ; The printing function: void IntSLList : : printall ( ) const { for ( IntSLLNode tmp = head ; tmp!= 0 ; tmp = tmp >next ) cout << tmp >info << " " ; cout << endl ; ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20

4 Doubly Linked Lists Recall that the deletefromtail function of our SLL was O(n). We can improve upon this by introducing doubly linked lists. Each node in a DLL has two pointers: One to the previous node in the list: prev One to the next node in the list: next At the front of the list the prev pointer is null. Similarly, at the rear next is null. ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 The definition of a node is modified to include these pointers, as well as to store a generic type T. class DLLNode { public : DLLNode ( ) { next = prev = 0 ; DLLNode ( const T& el, DLLNode n = 0, DLLNode p = 0) { info = el ; next = n ; prev = p ; T info ; DLLNode next, prev ; ; ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 Consider the process of inserting into the last position of a doubly-linked list. The following steps are required: Create a new node: info is set next is set to null prev is set to tail Modify the current nodes to link in the new one: tail is set to point at the new node The next member of the former last node is set to point at the new node These steps are accomplished by the following member function: void DoublyLinkedList<T >:: addtodlltail ( const T& el ) { tail = new DLLNode<T>(el, 0, tail ) ; tail >prev >next = tail ; Special case: What if the new node has no predecessor (i.e. the list is empty). The last step is removed. Also, we have to worry about setting head. The complete code for addtodlltail is as follows: void DoublyLinkedList<T >:: addtodlltail ( const T& el ) { if ( tail!= 0) { tail = new DLLNode<T>(el, 0, tail ) ; tail >prev >next = tail ; else head = tail = new DLLNode<T>(el ) ;

5 Consider deletion of the last node. This should be much easier than for a SLL because we don t have to loop to find tail s predecessor: For the general case (i.e. list length 2), Store the element to delete Shift tail back by one: tail = tail >prev Delete last node: delete tail >next Update the dangling pointer of the last node: tail >next = 0 Special case: Empty list. Handle this by forbidding it with a precondition. Special case: One node in list. Delete node and set head = tail = 0 T DoublyLinkedList<T >:: deletefromdlltail ( ) { T el = tail >info ; if ( head == tail ) { // o n l y one node i n l i s t else { // more than one node tail = tail >prev ; delete tail >next ; tail >next = 0 ; What is the asymptotic complexity of deletefromdlltail? O(1) DLL s may also tend be more efficient than SLL s in situations where operations occur repeatedly around one part of the list (e.g. text editing where each word is represented by a node). ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 Circular lists Linked lists vs. arrays In some cases, we may have a list of items that we wish to continuously circle through. e.g. processes sharing some resource such as CPU time. A circular list (a.k.a circular linked list) would be a suitable data structure for this purpose, We compare arrays with DLL s. DLL s have the best asymptotic performance for all operations over other LL variants. (Although they may be less efficient in some cases due to the overhead of additional pointers) Operation Array Linked list Indexing 1 O(1) O(n) Search O(n) / O(lg n) 2 O(n) Inserting / Deleting at beginning O(n) O(1) Inserting / Deleting at end O(n) 3 O(1) Inserting / Deleting in middle 4 O(n) O(1) ENGI 4892 (MUN) Unit 3, Part 2 May 30, / 20 1 Indexing means to access a particular element via an index. Accessing the 100 th element in an array is done by pointer arithmetic. Accessing the 100 th node in a linked list requires iterating through the first 99 nodes. 2 Searching in an ordered array can be done in O(lg n) using binary search. 3 O(1) if space is available at the end of the array. 4 Not counting search cost