Week 6. Data structures

Transcription

1 n Week 6 Data structures 6 7 n 8

2 General remarks We start considering Part III Data Structures from CLRS. As a first example we consider two special of buffers, namely stacks and queues. Reading from CLRS for week 5 The introduction to Part III on using on a computer. Chapter 10, Section 10.1.

3 Sets The most fundamental mathematical notion is that of a set: We have the possibility to determine the elements of a set. And we can form, either by some set-defining property, or by using already given (e.g., unions, intersections, differences). Now to bring the eternal and infinite world of mathematics to a computer, we need to take care of construction of objects destruction of objects naming (basically of functions) order issues ( are unordered, but in computation there is always order). For this, CLRS uses the (generic) ADT of dynamic. ADT: abstract data type values (like ) and how to operate with them.

4 Elements of a dynamic A dynamic set might contain pointers (or iterators) to objects, or the objects themselves (in Java this can be only integers and other primitive types, in C++ this is possible for every type of object). Whatever the objects in a set are, access to them (especially for changing them) is only possible via a pointer (or iterator). For insertion into a dynamic set, we must be given the object itself, and typically we obtain the pointer (iterator, handle) to the copy of that object in the dynamic set back. For deletion from a dynamic set, we typically have the pointer of an object (already) in the dynamic set, and we want to delete that (very specific) object. For searching, we typically have only given some key information, and we want to search for some element in the dynamic set, which fits this (key) information.

5 Keys Besides objects (which become elements once they are in the set) and pointers, CLRS uses the notion of a key to identify an object: If the object is for example a record of personal attributes, then the name or some form of ID can be used as a key. Often they keys are used for sorting. For example for that database of personal attributes, we might sort it according to alphabetical sorting of names.

6 : elementship and search With S we can ask whether x S is true. This is the most basic set operation, and the equivalent for dynamic is the operation SEARCH(S,k) for key k and dynamic set S, returning either a pointer (iterator) to an object in S with key k, or NIL if there is no such object. We require the ability to extract the key from an object in S, and to compare keys for equality. 1 Storing S via an array (or a list), SEARCH can be performed in O( S ) time (that is, linear time) by simple sequential search. 2 To do faster than this, typically in time O(log( S )) (logarithmic time), under various circumstances, is a major aim of data structures for dynamic.

7 : modifying operations With the following operations we can build and change dynamic : INSERT(S, x) inserts an object into dynamic set S, where x is either a pointer or the object itself. DELETE(S, x) deletes an object from dynamic set S, where here x is a pointer (iterator) into S. Note that the x in DELETE is of a different nature than the x in INSERT: It is a pointer (iterator!) into the (dynamic) set (and thus these two x are of different type). The most important application of INSERT is for creating a dynamic set: To create a set S of size n, call INSERT(S, ) n-times. We always have INSERT, while we might not have DELETE.

8 : using order Often it is assumed that a linear order is given on the keys: So besides k == k? we now can ask k k?. In practice using strict orders < is more common, however this creates some (necessary) technical complications, which in this module we won t be much concerned about (we discuss issues when the need arises). (These complications have to do with the notion of equality, since < includes not equal. Considering Java, recall that there (lacking operator overloading and lacking the ability to distinguish between object and pointer ) you have two operations for checking equality : = = for object-identity and.equals() for object-equality, and now we needed appropriate object-equality (consistent with the algorithms).)

9 : four further operations Given a linear order on the objects (to be put into the set), we have the following additional operations: MINIMUM(S) returns a pointer (iterator) to the element with the smallest key MAXIMUM(S) returns a pointer (iterator) to the element with the largest key SUCCESSOR(S, x), where x is a pointer (iterator) into S, returns the next element in S w.r.t. the order on the keys PREDECESSOR(S, x), where x is a pointer (iterator) into S, returns the previous element in S. Operations for computing successors and predecessors can fail (there is no successor resp. predecessor iff we are already at the end resp. beginning), and in such we return NIL.

10 Using sorting algorithms: static case can be realised using sorting, where we have to assume a linear order on the keys. If the set S with n elements is to be built only once, at the beginning, from a sequence of elements, then storing the elements in an array and sorting them, using for example MERGE-SORT with time complexity O(n logn), is a good option: SEARCH then takes time O(log n) (using binary search) while each of MINIMUM, MAXIMUM, SUCCESSOR, PREDECESSOR takes constant time. However we are concerned here with the dynamic case, where insertions and deletions are used in unpredictable ways. If we not assume that building the set is done (once and for all) at the beginning, but we want to have insertion and deletion, then the case is much less favourable.

11 Using sorting algorithms: dynamic case Now INSERTION and DELETION take time O(log(n)+n) = O(n), searching first for the right insertion/deletion place, and then shifting the other elements appropriately, while the five other (non-modifying) operations still take logarithmic resp. constant time. For practical applications, the linear complexity of insertion and deletion is not acceptable. And we also see that most of the intelligence of sophisticated searching algorithms is blown out of the window, and only some form of INSERTION-SORT (in combination with binary search) survived. It could be said that data structures for dynamic try to introduce some of the intelligent methods into the dynamic framework, making insertion and deletion more efficient (necessarily at the cost of making the other operations (somewhat) less efficient).

12 of dynamic Often not all of the operations for dynamic are needed, opening up the possibilities of specialised and more efficient s. Three important are as follows: Buffer Only INSERTION, SHOW-SELECTED-ELEMENT (like MINIMUM and MAXIMUM, but not necessarily related to some order) and DELETE-SELECTED-ELEMENT; special are stacks and queues. Priority queue Only INSERTION, MINIMUM resp. MAXIMUM (for min- resp. max-priority queues) and DELETE-MIN resp. DELETE-MAX (special queues, where the selected element is given by a linear order on the keys). Dictionary Only INSERTION, DELETION and SEARCH (i.e., no order-requirements).

13 of dynamic (cont.) In other words: Buffers (stacks, queues, and priority queues) have the notion of a selected element, which they can show and delete (but general deletion is not possible); searching in the general sense is not possible. Dictionaries can perform arbitrary deletions and searches, but they have no order on the elements (and thus also no special elements ). Insertion is always possible (given that there is enough space).

14 Last in first out A stack is a buffer where the selected element is the element last entered. Thus a stack is characterised by the slogan last in first out LIFO. One could also say first in last out (FILO). So if you enter numbers 1,2,3 into a stack (in that order), then you get back 3,2,1 (in that order).

15 Stack operations: PUSH, POP, TOP For dynamic in general we talk about INSERT, but for stacks this is called PUSH. And the DELETE operation (which here deletes a selected element) is called POP. The operation for returning the selected element is called TOP. In the book the operation POP combines the above POP (just deleting the selected element) and the above TOP (just returning the selected element), which is the old style for a stack, which has been shown to have severe disadvantages: Amongst others, separation of concerns requires that we have two different operations POP and TOP.

16 Examples If we have a stack, and perform (in this order) then TOP yields 3. PUSH(1), PUSH(2), PUSH(3), 1 After POP then TOP yields 2. 2 And after another POP then TOP yields 1. 3 A final POP yields an empty stack. Note that we have precisely as many PUSH as POP instructions (that holds for every buffer). What happens if on an empty stack we use POP or TOP?!?

17 The EMPTY operation In order to check whether the stack is empty, the fourth stack-operation is EMPTY, returning a boolean which is true if and only if the stack is empty. It depends on the concrete stack- (i.e., on the interface) what happens in case of an error. There are two principle error possibilities: stack overflow and stack underflow. Overflow means that a push-operation exceeds the stack-capacity. Underflow means the use of a top- or pop-operation on an empty stack.

18 n via an array Using an array we can easily implement the ADT Stack: 1 The class (Java or, say, C++) contains as data member ( instance variable ) a fixed-size array. 2 We fill that array from the left. 3 An index-variable points to the currently open slot in the array. 4 Popping an element from the stack just means decrementing that index. We consider an via the Java-class Stack.

19 Class Stack class Stack { private final int [] stack ; private final int N; // max number elements private int n; // number of elements public Stack( final int N ) { // Standard exceptions raised if N < 0 // or N is too big for available memory. N = N ; stack = new int [N]; n = 0; } Remark: Note that n is the current number of elements as well as the index of the next open array-slot.

20 Class Stack (cont.) public boolean empty() { return n==0; } public int top() { // Standard exception raised if n == 0. assert (stack!=null && stack. length==n) ; assert (n >= 0 && n <= N) ; return stack [n 1]; } Remark: assert is here used for conditions which are enforced by the internal logic of the class (and thus a violation would show that there is a bug in the class definition). The case n == 0 is absolutely possible according to the logic of the class Stack: Either the caller has to ensure that this never happens, or the exception has to be handled.

21 Class Stack (cont.) public boolean push( final int x) { assert (n >= 0 && n <= N) ; if (n == N) return false ; assert (stack!=null && stack. length==n) ; stack [n++] = x; return true ; } public boolean pop() { assert (n >= 0) ; assert (n <= N) ; if (n == 0) return false ; n; return true ; } Remarks: push and pop don t throw (exceptions). Both operations can fail (if we have already N elements, or there is no element left), in which case they return false.

22 Class Stack (cont.) // additional functionality : public int size () { return n; } public int max size () { return N; } public boolean equals(stack S) { if (n!= S.n) return false ; for ( int i = 0; i < n; ++i ) if (stack [ i ]!= S. stack [ i ]) return false ; return true ; } Remark: Recall that for Stack-variables a, b the comparison a == b checks whether these pointers are equal if we wish to check for equal content we need to use a.equals(b).

23 Class Stack (cont.) } public String tostring () { String out = [ + n +, + N + ]\n ; for ( int i = 0; i < n 1; ++i ) out += stack [ i ] + ; if (n > 0) out += stack [n 1]; return out ; } Remark: Here we take care to avoid a trailing space (after the last stack element).

24 First in first out A queue is a buffer where the selected element is the element first entered. Thus a queue is characterised by the slogan first in first out FIFO. One could also say last in last out ( LILO ), but that is apparently not used. So if you enter numbers 1,2,3 into a queue (in that order), then you get back 1,2,3 (in that order).

25 Queue operations We will use very similar notions as for stacks: The only difference is that instead of TOP we use FRONT. Besides that we have PUSH, POP, EMPTY. The book uses ENQUEUE instead of PUSH, and DEQUEUE instead of POP. However our choice is more popular with programming languages.

26 Examples If we have a queue, and perform (in this order) PUSH(1), PUSH(2), PUSH(3), then FRONT yields 1. 1 After POP then FRONT yields 2. 2 And after another POP then FRONT yields 3. 3 A final POP yields an empty queue. Note that we have precisely as many PUSH as POP instructions (that holds for every buffer).

27 n via an array Using an array we can (relatively) easily implement the ADT Queue: 1 The class (Java or, say, C++) contains as data member (instance variable) a fixed-size array. 2 We have furthermore index-variables for the left ( head ) and the right ( tail ) end. 3 PUSH moves forward the right end, POP the left end. 4 We do not need to re-allocate the elements, when we reach the right boundary of the array while actually not the whole array is filled, since we can wrap around the part of the array used for the queue. 5 For a real, one needs to get the details right, but the basic idea is very simple. We consider an via the Java-class Queue.

28 Class Queue class Queue { private final int [] queue ; private final int N; // maximal number private int n; // number of elements private int a, b; // first and one past the last index of current elements public Queue( final int N ) { // Standard exceptions raised if N < 0 or N is too big for available memory. N = N ; queue = new int [N]; n = a = b = 0; }

29 Class Queue (cont.) public boolean empty() { return n==0; } public int front () { // Queue underflow if n==0 (not detected) assert (queue!=null && queue. length==n) ; assert (a >= 0 && a < N) ; return queue [a ]; }

30 Class Queue (cont.) public boolean push( final int x) { assert (n >= 0 && n <= N) ; if (n == N) return false ; assert (queue!=null && queue. length==n) ; assert (b >= 0 && b < N) ; queue [b] = x; if (b == N 1) b = 0; else ++b; ++n; return true ; }

31 Class Queue (cont.) public boolean pop() { assert (n >= 0 && n <= N) ; if (n == 0) return false ; assert (a >= 0 && a < N) ; if (a == N 1) a = 0; else ++a; n; return true ; }

32 Class Queue (cont.) // additional functionality : public int size () { return n; } public int max size () { return N; } public boolean equals(queue S) { if (n!= S.n) return false ; for ( int i=a, j=s.a, c=0; c<n; i=(i==n 1)?0: i+1, j=(j==n 1)?0: j+1, ++c) if (queue [ i ]!= S. queue [ j ]) return false ; return true ; } Note that c is used here as a counter.

33 Class Queue (cont.) } public String tostring () { String out = [ + n +, + N + ]\n ; for ( int i = a, c = 0; c < n; i = ( i==n 1)? 0: i+1, ++c) out += queue [ i ] + ; return out ; }

34 Pushing and popping From [Sedgewick, Exercise 4.6]: A letter means push and an asterisk means pop in the following sequence. Give the sequence of values returned by the pop operations when this sequence of operations is performed on an initially empty stack: Solution: E A S * Y * Q U E * * * S T * * * I O * N * * * S Y E U Q T S A O N I E

35 Pushing and popping From [Sedgewick, Exercise 4.6]: A letter means push and an asterisk means pop in the following sequence. Give the sequence of values returned by the pop operations when this sequence of operations is performed on an initially empty stack: Solution: E A S * Y * Q U E * * * S T * * * I O * N * * * S Y E U Q T S A O N I E

36 Checking balancedness Develop the idea for a program that reads in a sequence of characters, and determines whether its parentheses, braces, and curly braces are balanced. For example is balanced, while is not. Solution: ( [ { ( [ ] ) ( [ ] ) } ] ) ( ( [ { } { } [ ] ) ) ) When you read an opening bracket-symbol, push it onto the stack, when you read a closing bracket-symbol, check whether it s the top-symbol, and pop it.

37 Checking balancedness Develop the idea for a program that reads in a sequence of characters, and determines whether its parentheses, braces, and curly braces are balanced. For example is balanced, while is not. Solution: ( [ { ( [ ] ) ( [ ] ) } ] ) ( ( [ { } { } [ ] ) ) ) When you read an opening bracket-symbol, push it onto the stack, when you read a closing bracket-symbol, check whether it s the top-symbol, and pop it.

38 Pushing and popping again A letter means enqueue and an asterisk means dequeue in the sequence E A S * Y * Q U E * * * S T * * * I O * N * * * Give the sequence of values returned by the dequeue operations when this sequence of operations is performed on an initially empty queue. Solution: E A S Y Q U E S T I O N

39 Pushing and popping again A letter means enqueue and an asterisk means dequeue in the sequence E A S * Y * Q U E * * * S T * * * I O * N * * * Give the sequence of values returned by the dequeue operations when this sequence of operations is performed on an initially empty queue. Solution: E A S Y Q U E S T I O N

40 A queue via two stacks Can we implement a queue using two stacks in an efficient way?! Solution: the basic idea is = + 1 Use two stacks, IN and OUT. 2 The queue is empty iff both stacks are empty. 3 push(x) : IN.push(x). 4 front(): if OUT is not-empty, perform OUT.top(), otherwise pop everything from IN, push it to OUT, and then perform OUT.top(). 5 pop(): The same as with front, only replacing OUT.top() with OUT.pop().

41 A queue via two stacks Can we implement a queue using two stacks in an efficient way?! Solution: the basic idea is = + 1 Use two stacks, IN and OUT. 2 The queue is empty iff both stacks are empty. 3 push(x) : IN.push(x). 4 front(): if OUT is not-empty, perform OUT.top(), otherwise pop everything from IN, push it to OUT, and then perform OUT.top(). 5 pop(): The same as with front, only replacing OUT.top() with OUT.pop().