Datatypes. List of data structures. Datatypes ISC

Transcription

1 Datatypes ISC Datatypes Effective use of algorithm in computer programs depends strongly on the representation of the data, so that retrieval and insertion of values are simple and fast. Using the correct data structure for a particular problem is one of the key elements of a good programmer or computational scientists. This lecture discusses simple data structures and how they may be implemented. A good dynamic data structure should allow fast access, fast addition, fast deletion, fast sorting, fast finding (elements, minimum, maximum), and also should be economic concerning space. Simple structures are well known since many years (before computers) in shipyards or railyards where concepts such as stacks, queues, or deques were used every day to reassemble sets of objects (trains, containers) in every day operations. List of data structures Linear lists Stack: Elements are added (input) on top and released on top (output). For example a list of numbers can be input one after another to a stack, and potentially be output in reshuffled form. Stacks implement a LAST-IN, FIRST-OUT policy. Exercises: 1-3 Queue: Elements are aded on one side of the queue and released on the other. Queues implement FIRST-IN, FIRST-OUT policy Common usages are you waiting at the post office or bank. Exercise: 1-3 Deque: Elements are added on either side of a container, for example the seat in a old truck that can be entered from both sides, and also left on both sides. variants of a deque are the input-restricted deque where one can only input on one side but output on both, and the output-restricted deque, where one can input on both sides but only output on one side. Deques implement FIRST or LAST-IN, FIRST or LAST-OUT policy. Exercise 1-4 for all three forms of deque. Sequential allocation: In low-level system we reserve memory for lists (stacks, queues, etc). These allocations assume often implicitly that we the memory blocks are contiguous and that we can assume an index that walks us from the first element to the last. In high-level languages, for example Python this is often hidden from us. Issues arise when we run out of allocate space. This is severe in queues and deques because here we need to to consider changes at both end of the allocated memory. Any pointer to memory for the beginning of the queue gets either invalidated when we output an object from the queue, or then we need to shift the content: both are bad prospects with a sequential list. Linked Lists: for linked lists we explicitly define a content for a particular element of the list and add a pointer to that element pointing to the next element in the list, in principle this can be used similarly to the sequential allocation scheme but allows easily to insert elements or delete elements without shifting all the other contents of the list. Often it is rather useful to have stationary pointer into the first element of the list. Removal at the beginning or the end or the middle simply needs to relink the previous element with next, and destroy the memory (!) of the discarded element. 1 Peter Beerli; January 3, 2011

2 Datatypes ISC Circular lists: take the linked list and connect the first and last element. Doubly linked lists: linked list where with not only have a pointer forward but also backwards, we will explore such list in detail in the lab. Arrays allow random access to all elements and not only to the first or last one. This is probably the most common structure we encounter in scientific computing, but particularly with higher dimensions we may use (abuse) memory. If the position in the array is not important stacks or queues may be much better constructs than arrays. Non-linear lists: Trees Binary trees Red-Black trees Dictionary and Hash Tables Exercises Try the exercises with the particular data structures that mention the exercise numbers in the section List of Data Structures. From Knuth (1997): Imagine four railroad cars, positioned on the input side, numbered 1,2,3,4 from left to right. Suppose we perform the following sequence of operations (no jump over other cars allowed): (a) move car 1 into the stack; (b) move car 2 into the stack; (c) move car 2 into the output; (d) move car 3 into the stack; (e) move car 4 into the stack; (f) move car 4 into the output; (g) move car 3 into the output; (h) move car 1 into the output. As a result of this operation the original order of the car 1234 has changed to What permutations are obtainable with the different data structures. 1. If there are six cars labeled , can they be permuted into the oder ? In case this is possible show how to do it. 2. If there are six cars labeled , can they be permuted into the oder ? In case this is possible show how to do it. 3. Give a general answer what operations fail for the particular data structure? Is there a general rule for a sequence of n? Can you give the ratio of failed operations to all possible operations? 4. Clearly an input-restricted deque can function as a stack or a queue if we consistently remove all items from one of the two ends. Can an output-restricted deque also be operated either as a stack or as a queue. 2 Peter Beerli; January 3, 2011

3 Datatypes ISC Implementations Stacks, queues, deques Space for stacks can be sequentially allocated for example as simple contiguous block of memory S[1...n] using a single attribute that marks the last element added to the stack: top(s). For example in python, top(s) is not even needed to be seen by the programmer because the built in function deal with that automatically. # stack example stack = [] stack.append(object) object = stack.pop() # #queue example queue = [] queue.append(object) # push # pop from end # push object = queue.pop(0) # pop from beginning # # dequeue example from collections import deque d = deque() d.append( j ) d.appendleft( f ) d.pop() d.popleft() # make a new deque with zero items # add a new entry to the right side # add a new entry to the left side # return and remove the rightmost item # return and remove the leftmost item if you feel inclined to write your implementation for the programming language of choice, a few functions will do for either stack, deque, or queue: # define a class for the stack, queue, or deque # then implement minimally these functions empty() # test whether the data structure is empty overflow() # test whether adding an element will exhaust the available memory # (candidates for this are languages like C and Fortran) push(value) # add a value pop() # remove a value The functions push() and pop() will need an additional parameter for a deque to mark whether the value has to inserted or removed at the top or bottom. 3 Peter Beerli; January 3, 2011

4 Datatypes ISC Sequential allocations and singly-linked lists Sequential allocations are most common in low-level languages like C. /* C code */ #define NUMVALUES 1000 float *values; values = malloc(1000*sizeof(float)); Errors are most often cryptic when such lists are abused, for example accessing elements beyond the the size of the list (in our example NUMVALUES is the maximum number of elements the list holds) or often fatal and may not always be reported without additional coding. For example check this program: /* C code */ #define NUMVALUES 1000 #include <stdio.h> #include <stdlib.h> int main() int i; float *values; values = malloc(numvalues * sizeof(float)); for(i=0;i<numvalues;i++) values[i]= i + 1.0; fprintf(stdout,"last element(1000): %10.4f\n",values[999]); fprintf(stdout,"element after allocation(1001): %10.4f\n",values[1000]); fprintf(stdout,"9000 elements after allocation: %10.4f\n",values[10000]); Running does not reveal an error: ciguri:samples1>gcc -o overflow overflow.c ciguri:samples1>overflow Last element(1000): Element after allocation(1001): elements after allocation: Keeping track of the allocation would have helped here (well using languages like Java, too). Linked list can be implemented like this (I do not claim that this is the shortest or most elegant way, how would you do this in C++ or Java? : 4 Peter Beerli; January 3, 2011

5 Datatypes ISC /*C code*/ #define NUMVALUES 10 #include <stdio.h> #include <stdlib.h> typedef struct _node float value; struct _node * ptr; node; int main() int i; node *head = malloc(sizeof(node)); node *tmp; tmp = head; for(i=0;i<numvalues;i++) node *v = malloc(sizeof(node)); tmp->ptr = v; v->value = i + 1.0; tmp = v; tmp = head; for(i=0;i<numvalues;i++) fprintf(stdout,"%10.4f\n",tmp->ptr->value); tmp = tmp->ptr; Cost of operations [text lifted and modified from slides by Gordon Erlebacher] What is the cost of insertion and deletion into lists, or sorting of list elements, or finding particular elements? It depends on the data structure. Usually we are concerned with the behavior of a function f(n) as n becomes arbitrarily large (goes to infinity). If f(n) and q(n) are non-negative functions, f(n) is asymptotically bigger than q(n) if and only if q(n) lim == 0. n f(n) Similar definition for asymptotically smaller. 5 Peter Beerli; January 3, 2011

6 Datatypes ISC The O(n) notation [big O notation] expresses these differences. f(n) = O(g(n)) is equivalent to stating the f(n) is asymptotically smaller or equal to g(n). Some properties of the O() notation (John Morris, 1996) Constant factors may be ignored: For all k > 0, kf is O(f). For example an 2 and bn 2 are both O(n 2 ). Higher powers of n grow faster than lower powers: n r is O(n s ) if 0 <= r <= s. the growth rate of sum of tersm is the growth rate of its fastest growing term: if f is O(g) then f + g is O(g). Example: an 3 + bn 2 is O(n 3 ). the growth rate of a polynomial is given by the growth term of the leading term: If f is of degree d then f is O(n d ). If f grows faster than g which grows faster than h, then f grows faster than h. the product of upper bounds of functions gives an upper bound of the product of functions: Example if f is O(n 2 ) and g is O(log n), then fg is O(n 2 log n). Exponential functions grow faster than powers. Logarithms grow slower than than powers. All logarithms grow at the same rate. Exercises What is the cost of insertion for a linked list, a doubly linked list a sequential allocated list, what is the cost of a deletion, the cost of finding a particular element? 6 Peter Beerli; January 3, 2011