Data Structure - Skip List etc. -

Transcription

1 Data Structure - Skip List etc. - Hanyang University Jong-Il Park

2 SKIP LIST

3 Introduction to Skip Lists An interesting generalization of linked lists for dictionary ADT. Keep the simplicity of linked lists Efficient O(log n) average (expected) performance. Randomized Data Structures Use random number generator to create it The average performance has nothing to do with the keys being inserted; it is affected only by the random number generator Therefore, you cannot pick a sequence of operations that will always be bad for skip lists. Division 3 of Computer Science and Engineering, Hanyang University

4 Perfect Skip Lists Sorted linked list that allows skipping over lots of items A hierarchy of sorted linked lists. Take every other element of the linked list and lift them up to a new linked list with ½ of elements, and then take every other element of this linked list and lift them up to another list of ¼ elements, and so on until only one element is left. level 3 level 2 level 1 level Sentinel Nil Searching is done first in the linked list at the highest level to skip over lots of elements, and then descend to lower levels only as needed.

5 Perfect Skip Lists To search for a key x, we start at the highest level and we scan linearly the list at level i, finding the first item p whose next item q is greater than x (assume that the Nil node has item ) if p = x then stop otherwise, we descend to level i 1 and repeat from p. In the worst case, we have to go through all log n levels, and at each level we visit at most 2 nodes O(log n) Between any two consecutive items p and q at level i there is only one item at level i 1. Division 5 of Computer Science and Engineering, Hanyang University

6 Randomized Skip Lists Insertion into a perfect skip list requires complete restructuring Skip lists allow a certain amount of imbalance through randomization. For each node at level i, we toss a coin; if it is a head (probability ½): it is promoted to level i + 1 otherwise it stays. The expected number of nodes at level 1: n/2 The expected number of nodes at level 2: n/4... We also expect at each level, it is well distributed. Division 6 of Computer Science and Engineering, Hanyang University

7 Example: Skip List Find(11) Nil Insert(12) Nil Division 7 of Computer Science and Engineering, Hanyang University

8 Insertion and Deletion The probabilistic structure will hold through insertion and deletion Insert x at the lowest level and toss a coin; if it is a head, promote to level 1 and repeat toss, otherwise stay there. For deletion, simply delete the node from every level it appears We can maintain the desired probabilistic structure Your enemy cannot see our random number generator and cannot selectively delete/insert. Each node tosses independently, so levels of nodes are independent. Division 8 of Computer Science and Engineering, Hanyang University

9 The average performance has nothing to do with the keys being inserted; it is affected only by the random number generator Therefore, you cannot pick a sequence of operations that will always be bad for skip lists.

10 Implementation Notes Skip List can be implemented easily as the linked lists Variable Node Size where the size of the node is determined randomly when it is created. struct skip_node { element_type element; int level; struct skip_node **forward; } *p; p = (skip_node*)malloc( sizeof(struct skip_node) ); p->forward = (skip_node**)malloc( sizeof(skip_node *)*(k+1) ); What would be the maximum level (the size of header node)? The maximum level is log n when n is the maximum number of nodes allowed (if n = 2 16, then the level is 16); you should not allow the level of a node to exceed this value. Division 10 of Computer Science and Engineering, Hanyang University

11 Practice EQUIVALENCE CLASSES

12 Equivalence classes Def) a relation over a set S is an equivalence relation over S iff it is symmetric, reflexive, transitive over S partition the set S into equivalence classes 1) x = x : reflexive 2) x = y, y = x : symmetric 3) x = y, y = z, x = z : transitive the algorithm to determine equivalence classes 1) 1st phase read and store the equivalence pairs (i, j) 2) 2nd phase begin at 0 and find all pairs of the form (0, j) by transitivity, all pairs of the form (j, k) is in the same class as 0

13 Equivalence classes (Cont.) how to implement the data structures for holding pairs 1) using array pairs[n][n] pairs[i][j] = TRUE iff i and j are paired waste of space require O(n**2) time, to initialize the array 2) consider a linked list to represent each row still need random access to the i th row seq[n] can be used as the head node of the n lists

14 Equivalence classes (Cont.)

15 Equivalence classes (Cont.) need a mechanism that tells us whether or not object i is yet to be printed out[n]

16 Equivalence classes (Cont.) typedef struct node *node_pointer; typedef struct node { int data; node_pointer link; };

17 Equivalence classes (Cont.) seq[i] points to a list of nodes that contains every number directly equivalent to i create a stack of nodes, to process the remaining lists which, by transitivity, belong in the same class as i accomplished by changing the link data members

18 Equivalence classes (Cont.)

19 Equivalence classes (Cont.)

20 Equivalence classes (Cont.)

21 Practice SPARSE MATRIX - LINKED LIST

22 Sparse Matrix Representation Representation of header node, element node use a union to create the appropriate data structure /* size of largest matrix */ #define MAX_SIZE 50 typedef enum {head, entry} tagfield; typedef struct matrixnode *matrixpointer; typedef struct entrynode { int row; int col; int value; }; typedef struct matrixnode { matrixpointer down; matrixpointer right; tagfield tag; union { matrixpointer next; entrynode entry; } u; }; matrixpointer hdnode[max_size];

23 Sparse Matrix Representation(cont.)

24 Sparse Matrix Input

25 Sparse Matrix Input(cont.) O(max{# rows,# cols} + # term )

26 Sparse Matrix Output O(# rows + # terms)

27 Erasing a Sparse Matrix Free the entry and head nodes by row O(# rows + # cols + # terms)