Data Structures. Alice E. Fischer. Lecture 4, Fall Alice E. Fischer Data Structures L4... 1/19 Lecture 4, Fall / 19

Transcription

1 Data Structures Alice E. Fischer Lecture 4, Fall 2018 Alice E. Fischer Data Structures L4... 1/19 Lecture 4, Fall / 19

2 Outline 1 Ordered Lists 2 Sorted Lists Tail Pointers 3 Doubly Linked Lists 4 Circular Lists Alice E. Fischer Data Structures L4... 2/19 Lecture 4, Fall / 19

3 Ordered Lists ADT Ordered List The data in an ordered list is sorted at all times. When a new item is inserted into the list, it is inserted in its proper place. An ordering implies that we have a key part of the data item and a function to compare two data items according to that part. The basic operations on an ordered list have the same names as the operations on an unsorted list BUT the actions and running time might be different. Alice E. Fischer Data Structures L4... 3/19 Lecture 4, Fall / 19

4 Ordered Lists Ordered List Operations The running time of the first group of functions is the same as for an unsorted list. isfull and isempty getn traverse or print replace (given the index of the item to delete) find: O( log(n) ); We can use a binary search on a sorted list. The running time is a log(n) + b (Compare to n for sequential search of an unsorted list) These functions require moving (on the average) half of the items on the list so they are O(N): remove (given the location of the item to delete) insert Alice E. Fischer Data Structures L4... 4/19 Lecture 4, Fall / 19

5 Ordered Lists Binary Search Algorithm This algorithm is stated recursively. The parameters to search are: key (the thing we are searching for) ary (the array to search), begin and end (subscripts to start and stop searching 1 Calculate subscript midway between start and stop. Round down. 2 Compare search key to ary[midway]. Return success if they match. 3 Return failure if start == stop. 4 If key is smaller than data, set stop to midway-1 and call self recursively 5 Else set start to midway+1 and call self recursively. Important: This algorithm ALWAYS eliminates the midway value from consideration. Therefore, each recursive call has at least one fewer data item to search. Therefore the recursion cannot go on forever. Alice E. Fischer Data Structures L4... 5/19 Lecture 4, Fall / 19

6 Ordered Lists Running Time of Binary Search 1 We are given N items to search. log 2 (N) is the number of times we can split N in half before reaching 1. 2 Therefore, we will make approximately log 2 (N) recursive calls. 3 Each call calculates an average, does a comparison and a subtraction, has two if statements, and makes a recursive call. Let s say that takes about 10 steps. 4 So the running time is 10 log 2 (N) 5 This is O(log 2 (N)). Alice E. Fischer Data Structures L4... 6/19 Lecture 4, Fall / 19

7 Ordered Lists Which is Better, Ordered or Unordered? That depends on the nature of your application. If you search frequently through a stable set of data, ordered is better. If search is seldom but items come and go often, unordered is better. Alice E. Fischer Data Structures L4... 7/19 Lecture 4, Fall / 19

8 Sorted Lists Searching a Sorted List. Assume the list is sorted in ascending order. To insert into it, you must find the proper insertion spot. Do this with a 2-pointer : Start with = ; and = nullptr; Position the cursors: while (value < ->data) gonext(); When the loop ends, either ->data equals value, or the two cursors bracket the proper insertion slot. Alice E. Fischer Data Structures L4... 8/19 Lecture 4, Fall / 19

9 Sorted Lists Insertion into a Sorted List Suppose we want to search the sorted list for Nora and insert her if she is not there. Perform the search from the previous slide. If Nora is not yet in the list do: ->next = new Cell( value, ); Alice E. Fischer Data Structures L4... 9/19 Lecture 4, Fall / 19

10 Sorted Lists One Special Case for Insertion This insertion algorithm has one special case: insertion at the of the sorted list, before the first cell. This case can be identified because will still be null. if ( == nullptr) = new Cell( value, ); Carl Insertion at the end of the list is not a special case. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

11 Sorted Lists Tail Pointers TList: a List with a Tail Pointer This kind of list is used to implement a queue. It is shown three times: once empty, then with one and two objects in it. The red links are the two that must be set after the Cell is created. tail count 3 ~~~ The TList constructor creates a dummy cell to provide a place to anchor the tail pointer in an empty list. The dummy cell contains a recognizable special value of the type that will be stored in the list. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

12 Sorted Lists Tail Pointers Insertion at the end of a TList. This operation is used to insert a cell into a queue. The Cell is created and attached by executing.next = new Cell( value, nullptr ); Then the tail pointer is updated: tail = tail->next; tail count 1 2 ~~~ If the Cell has a count, that must also be updated. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

13 Sorted Lists Tail Pointers A second insertion. Do the same operation to add more cells. tail count 1 2 ~~~ Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

14 Doubly Linked Lists A Doubly Linked List This list has links pointing both forwards and backwards. class Cell { Cell back; (red) int data; (black) Cell next; (blue)... count tail The C++ std::list is a doubly-linked list. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

15 Circular Lists A Circular List The list should be made circular when the first cell is added to it. = new Cell( value, nullptr ); ->next = ; The red link was the initial value of next, and is replaced by the blue link in the second line.. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

16 Circular Lists Insertion in an unsorted circular list. Add a second (or later) cell after ->next ->next = new Cell( value, ->next); Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

17 Circular Lists Deletion from the Circular List. If the list has only one remaining cell, handle it appropriately, as a special case. If ->data equals the value you want to delete, skip the next slide. Else set = = ->next Then use the 2-pointer search to find the cell you want to delete. The pointer should end up pointing at that cell. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

18 Circular Lists Deletion from the Middle of a Circular List. Position to point at the cell you want to delete. Then: ->next = ->next; ->next = nullptr; delete ; The old links are red, the new ones are blue. The list remains circular. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19

19 Circular Lists Deletion from the Head of a Circular List. It is also possible to delete a cell by copying the next cell on the list over it. = ->next; * = *; ->next = nullptr; delete ; A cell is gone and the list remains circular. Alice E. Fischer Data Structures L /19 Lecture 4, Fall / 19