Sets and Sequences vs. Linked Lists

Transcription

1 Sets and Sequences vs. Linked Lists Florent Bouchez Tichadou September 24, 2018 We have seen previously that it is possible to use arrays (low-level structure) to hold sets or sequences (high-level structures). Arrays have nice properties such as a compact storage in memory, and constanttime memory access of elements given an index. However, they also have limitations, for instance the size is fixed, and inserting new elements take time when the ordering is important (e.g., in a sequence): a lot of elements must be shifted to make room for the new one. In this document, we will discover another low-level data structure that does not have these limitations (but also has limitations of its own): the linked lists. 1 Memory model Before introducing linked lists, we need to make sure we understand how computers memories work: the memory is like a giant array, where we can store values. The indices are called memory addresses, and the content is a value usually stored using 32 or 64 bits. From the memory point of view, the content has not type. This is the role of the program to know the type of what is stored, and interpret correctly the contents. For instance, the binary value can be interpreted either as the integer value, the True boolean value, the character string "Algo", or... the memory address 0x416c676f (hexadecimal representation). It is then possible to store memory addresses in memory. This is for instance the case for an array of character strings: the array does not actually contain the characters, but instead addresses of the starts of character strings (see Figure 1a). When we want to access a string, given its index in the array, the program only has to follow the link stored in the array, i.e., go to the address. We will use this technique to build a linked list, i.e., an object containing multiple elements called cells so that each cell contains two fields: one to store the element and the other to store the address of the next cell (see Figure 1b). Given the address of the first cell (usually called the head ), it is then possible to access all the cells one after the other by following the links until the end of the list (called the tail, and pointing to the Nil (or Null) address). 2 Linked lists Contrary to arrays, elements of a linked list are not stored contiguously in memory. It is then very easy to add a new element to a linked list: we need to reserve some space in memory for a new cell and modify the links (memory addresses) so that the list now goes through the new cell. Algorithmically, we need a mechanism to go from one cell to the next one. We prefer not to stick on an implementation based on memory addresses ( pointers ), which is dependent of a programming language. We will use the general mechanism of references to define our cells. Type and variable declaration. Creating a list with one element. type Cell: { val: element, next: reference on Cell} type Linked list: { head: reference on Cell} cel: Cell list: Linked list cel Ð new Cell cel.value Ð 42 cel.next Ð Nil list.headð cel INF301 1

2 Memory tab Memory head "Hello" "vraiment" "super" "sympa!" "World!" "L algorithmique" "c est" (a) Array of strings (b) Linked list of integers Figure 1: Memory representation of an array of addresses and a linked list. 3 Sequences and linked lists A linked list can hold an arbitrarily big number of elements (the limit being the machine s memory). Its length (number of elements) is dynamic and it is easy to add a new element while keeping the existing order. This low-level data structure is a very good candidate for storing high-level sequences! It is also a good choice for a set if we already know that the length will vary a lot. At low-level, a sequence can be directly represented using a linked list, i.e., a reference on a cell: the head of the list. Sometimes, its is also valuable to keep other references, such as one for the tail of the list (the last cell), or a reference on the previous cell (doubly linked list, see exercises at the end of the document). Declaring a sequence type Sequence: Linked list S: Sequence cel: Cell Printing a sequence print (cel.value) The next sections give low-level implementations of the usual operations on sequences. 3.1 Sequence creation, access to elements and successors To create an empty sequence, we need a reference on... nothing! Indeed, an empty sequence does not contain any cell. To access en element, given a reference on its cell, we use its value field. To access the successor of an element, we use the next field of its cell. S: Sequence Ð Nil /* Empty sequence */ print ("The cell contains: ", cel.value) cel.val Ð cel.val`12 /* modification */ /* on to the next one */ Representations in memory of an empty sequence and a cell containing 12. INF301 2

3 cel... Note: in a linked list, it is not possible to directly access the i th element as we would normally do in an array: we need to start from the head and follow the next links as many times as required (cf. next section). 3.2 Iterating on all element and computing the length In order to traverse a linked list, we first access the head of the list, then to successive elements one after the other by using the links. To compute the length, we use the same scheme while incrementing a counter. 1 Traversal and printing Computing the length Accessing the i th element print (cel.value) ; lengthð 0 length Ð length`1 do i times Drawing of the following invariant when computing the length: length contains the number of cells before the one referenced by cel in the sequence. cel length 0 length 4 cel length 8 cel Simple Search of an element Searching for an element, or testing whether an element belongs to a sequence or not, is a direct application of the iteration schemes on linked lists. We propose here three versions that return True if the value belongs to the sequence, and False otherwise. The first one uses a boolean that remembers whether the element was seen in the sequence or not, while the second and third ones stop as soon as the element is found. The third algorithm is the most elegant one, but only works in a function, since the return allows us to break out of the loop. The second algorithm shows a classical scheme where the loop exit depends on two conditions: we could either be at the end of the sequence, or on the found element. We then have to test again one of the conditions to know the exit status. 1 If this operation is used a lot, it is also possible to store a length field in the list data structure alongside the head field. INF301 3

4 Simple search Double condition loop Loop exit using return search (S, v) found Ð False if cel.value = v then found Ð True return found search (S, v) while cel Nil and cel.value v do return cel Nil search (S, v) if cel.value = v then return True return False Important For the second search algorithm, the order of the conditions in the while loop is very important: it is of utmost importance to verify first that cel is not Nil before testing cel.value. Otherwise, we would ask for the field of a potentially non-existing object, which is an algorithmic mistake, and in the case of a real program, source of nasty bugs. For the same reason, after exiting the loop, we can only test if cel is Nil and not the other condition. 3.3 Inserting an element Order is import in sequences. We distinguish three cases: 1. inserting at the beginning of a sequence, i.e., at the head; 2. inserting after an element, i.e., after a given cell; 3. inserting at the end of a sequence, i.e., at the tail. To insert at the head, we create a new cell whose successor in the current head, then the head becomes that cell. Inserting after a particular element is easy when we have a reference on the cell c of that element: similarly to the insertion at the head, we create a new cell whose successor is c.next, then we update c.next so that it points to this new cell. Finally, inserting at the tail requires to first find the tail; then inserting is done as after it (and in that case c.next is Nil), unless the list is empty (there is no tail), in which case we simply create a new cell which becomes the head (and the tail). Warning: in all cases, the order in which modifications are performed is important! Suppose we start by modifying so that it refers to the new cell, then we have lost the initial head (and the full list with it!). insert_first (S,x) cel Ð new Cell cel.value Ð x cel.next Ð Ð cel insert_after (S,x,pred) cel Ð new Cell cel.value Ð x cel.next Ð pred.next pred.nextð cel INF301 4

5 insert_last (S,x) if Nil then insert_first (S,x) else tail Ð while tail.next Nil do tail Ð tail.next insert_after (S,x,tail) Inserting 12, 18 and 42 respectively at the beginning, after 3, and at the end of a sequence. Numbers on new links show the order of modification. Crossed-out links show connections that are lost due to modifications numbered Searching and deleting an element To delete an element, we need to make the predecessor cell point to the successor, then free the element s cell (so that the memory does not get saturated eventually). The main problem here is that it is easy to access the successor (by following the next link), however it is not directly possible to get the predecessor: we must start again from the head and traverse the list! It is highly recommended, if we know that we might delete an element, to keep a reference also on the predecessor to avoid a new traversal. We present here an improved search function that returns both a reference on the cell of the element we are looking for (or Nil if not found), and a reference on the cell of the predecessor (or Nil if at the head of the list). Note: again, the order of comparisons in the while loop is very important: we must first verify that cel is not Nil before testing cel.value. Likewise, when deleting, we only free the cell when we have finished accessing its fields. search (S, x) pred Ð Nil while cel Nil et cel.value x do pred Ð cel return (cel, pred) delete (S, x) (cel, pred) Ð search (S, x) if cel Nil then Error ("Element not found!) if pred Nil then Ð cel.next else pred.next Ð cel.next free (cel) Deleting the head, an element in the middle, and the tail of a linked list. INF301 5

6 3.5 Swap of two elements In order to swap two elements, we must modify all links between the predecessors and the successors of the cells of these elements. Again, if we know we will perform a swap, it is important to keep a reference on the predecessors so we don t have do traverse the list again. We have here a corner case we need to handle: if one of the elements is the head of the list. Since we don t want to write three times the same error-prone code, we start by creating a fictional cell that becomes the head. Now we know the predecessors will never be Nil (we must give the fictional cell a value that will never be searched, or modify the search function so that it ignores this cell). Note: another corner case: when the two elements are consecutive. The proposed algorithm handles this case. Verification that it behaves as expected is left as an exercise to the reader (trace the algorithm s execution). swap (S, x, y) fictional Ð new Cell fictional.next Ð Ð fictional (cel x, pred x ) Ð search (S, x) (cel y, pred y ) Ð search (S, y) pred x.next Ð cel y pred y.next Ð cel x tmp Ð cel x.next cel x.next Ð cel y.next if cel x pred y then cel y.next Ð cel x ; else cel y.next Ð tmp; Ð fictional.next free (fictional) Swapping elements 4 and 13. fictional tmp pred x cel x pred y cel y 2 1 INF301 6

7 4 Exercises 4.1 Revisiting previous exercises Linked lists are a low-level possibility to implement the set and sequence data structures. It is then possible to re-use the exercises from the Set and Sequences vs. Arrays document and change all the low-level algorithms (using arrays) to algorithms using linked lists. Doing so will also be very helpful to make sure you understand the difference between high-level and lowlevel: if your high-level algorithm cannot be implemented in low-level using a linked list, it means you are implicitly supposing your set or sequence is stored in a array Special linked-list exercises The following exercises could of course also use arrays but linked-lists here are either well adapted or introduce interesting notions. Exercise 1 (Insert before) We have seen previously how to insert a new cell after a given cell. Give the algorithm to insert before a given cell. Exercise 2 (Separating in two) Given a sequence S using a linked list. We want to separate the sequence into S and S2 so that every other element from the initial sequence stays in S while all others go into S2. We want to keep the original ordering and use only modifications of links (no creation or removal of cells). 1. Draw on an example the initial state of the sequence as well as the final state (draw links with a different color). 2. Re-draw the example but in an intermediate state (during execution of the separation): some part of the sequence is already separated while the rest awaits processing. This drawing is your loop invariant. 3. Identify on your previous drawing the modification(s) you need to perform that one more cell is processed. This represent the body of your loop and must satisfy the invariant (keep the same state at the end of the iteration to prepare for the next one). 4. Deduce the body of your loop. Now you only need to write the initialisation part (get to the initial state before the loop) and the stop condition (loop test). Start the exercise again but separating the sequence based on the elements (integers): all the elements ě 0 stay in S while the others go in S2. Exercise 3 (Waiting queue) We wand to model a waiting queue of customers at the post office. We use a sequence represented as a linked list of the FIFO type (First In First Out): the first to enter in the first to get out. When a new customer comes, he/she must be inserted at the end of the sequence by calling a function wait. When a counter is available, the customer at the beginning of the sequence is being attended to using the function attend. 1. Give an implementation of functions wait (name: string) and attend (): string. 2. To insert at the end, we first need to find the tail of a linked list which is costly. We would like to keep a reference on the tail, i.e., the last cell of the list. Modify the data structure as well as the function wait so that the cost of inserting is now independent of the size of the waiting queue. INF301 7

8 Exercise 4 (Both ways) Let us consider a playing card game with two people. This game starts with a row of five cards randomly picked up and placed face up. At its turn, each player can either take the first or last card of the row, or add a new card (randomly picked from the deck) at the beginning or the end of the row. We want to propose a simulator of the game. We choose to implement the row of cards as a sequence using linked lists. A linked list would be efficient for one of the extremity, but slow for the other extremity. 1. Propose an extension to the data structure so the lists are now doubly linked: each cell has a reference to the next one, but also to the previous one. 2. Give the algorithms for inserting and deleting at the beginning or the end of a sequence for your doubly linked list. 3. Suppose we also want to insert and delete at any position in the sequence. Give the necessary algorithms. Exercise 5 (The pancakes maker) The local pancake shop employs a very good chef, but she has a bit of an OCD with those. She puts then in a big stack, but the stack has to be perfectly ordered: from the largest pancake at the bottom to the smallest one at the top. To modify the stack, the chef only has her spatula: she can insert it between any two pancakes, and flip over in one move all the pancake that are above. 1. Give a high-level algorithm (using for instance sentences such as flip the three first pancakes ) that correctly orders a stack of pancakes. 2. Give a low-level implementation of you algorithm, using linked lists. 3. Pancakes always have a side that is prettier than the other. Order the stack so that the pretty side is always facing top. INF301 8