Skip lists (Advance Data structure)
Download as pptx, pdf1 like3,037 views
Skip list is data structure that possesses the concept of the expressway in terms of basic operation like insertion, deletion and searching. It guarantees approximate cost of this operation should not go beyond O(log n).
More Related Content
What's hot (20)
Similar to Skip lists (Advance Data structure) (20)
More from Shubham Shukla (6)
Recently uploaded (20)
Skip lists (Advance Data structure)
- 1. Skip Lists 1
- 2. Skip Lists 2 Outline and Reading What is a skip list Operations Search Insertion Deletion Implementation Analysis Space usage Search and update times
- 3. Intro to Skip Lists Motivation: Unordered Arrays: Searching and removing takes O(n) times Inserting takes O(1) times Ordered Arrays: Searching takes O(log n) times Inserting and removing takes O(n) times ► Unordered LL: fast insertion, slow search ► Ordered LL: slow insertion, slow search Basic idea of skip lists Organize ordered list hierarchically so we don’t need to scan all elements in search Skip Lists 3
- 4. Skip Lists 4 What is a Skip List A skip list for a set S of n distinct keys is a series of lists S0, S1 , … , Sh such that Each list Si contains the special keys + and - List S0 contains the keys of S in nondecreasing order Each list is a subsequence of the previous one, i.e., S0 S1 … Sh List Sh contains only the two special keys 56 64 78 +31 34 44- 12 23 26 +- +31- 64 +31 34- 23 S0 S1 S2 S3
- 5. Skip Lists 5 Skip List Node We can implement a skip list with quad-nodes A quad-node stores: item link to the node before link to the node after link to the node below link to the node above Also, we define special keys PLUS_INF and MINUS_INF, and we modify the key comparator to handle them x quad-node
- 6. Skip Lists 6 Search Steps for search a key x in a a skip list: Start at the first position of the top list At the current position p, we compare x with y key(next(p)) x = y: Return next(p) x > y: Scan forward x < y: Drop down Repeat the above step. (If “drop down” pasts the bottom list, return null.) Example: search for 78 +- S0 S1 S2 S3 +31- 64 +31 34- 23 56 64 78 +31 34 44- 12 23 26 scan forward drop down Find the interval where x belong to…
- 7. Skip Lists 7
- 8. Skip Lists 8
- 9. Skip Lists 9
- 10. Skip Lists 10
- 11. Skip Lists 11
- 12. Skip Lists 12
- 13. Skip Lists 13
- 14. Skip Lists 14
- 15. Skip Lists 15
- 16. Skip Lists 16
- 17. Skip Lists 17
- 18. Skip Lists 18
- 19. Skip Lists 19
- 20. Skip Lists 20
- 21. Skip Lists 21
- 22. Skip Lists 22
- 23. Skip Lists 23
- 24. Skip Lists 24
- 25. Skip Lists 25
- 26. Skip Lists 26
- 27. Skip Lists 27
- 28. Skip Lists 28
- 29. Skip Lists 29
- 30. Implementation (1/2) Skip Lists 30 Resutls due to different randomization Another linked list implementation
- 31. Skip Lists 31 Implementation (2/2) We can implement a skip list with quad-nodes A quad-node stores: item link to the node before link to the node after link to the node below link to the node above Also, we define special keys PLUS_INF and MINUS_INF, and we modify the key comparator to handle them x quad-node
- 32. Skip Lists 32 Outline and Reading What is a skip list Operations Search Insertion Deletion Implementation Analysis Space usage Search and update times
- 33. Skip Lists 33 Randomized Algorithms A randomized algorithm performs coin tosses (i.e., uses random bits) to control its execution It contains statements of the type b random() if b = 0 do A … else { b = 1} do B … Its running time depends on the outcomes of the coin tosses We analyze the expected running time of a randomized algorithm under the following assumptions the coins are unbiased, and the coin tosses are independent The worst-case running time of a randomized algorithm is often large but has very low probability (e.g., it occurs when all the coin tosses give “heads”) We use a randomized algorithm to insert items into a skip list
- 34. Skip Lists 34 To insert an item x into a skip list, we use a randomized algorithm: We repeatedly toss a coin until we get tails, and we denote with i the number of times the coin came up heads If i h, we add to the skip list new lists Sh+1, … , Si +1, each containing only the two special keys We search for x in the skip list and find the positions p0, p1 , …, pi of the items with largest key less than x in each list S0, S1, … , Si For j 0, …, i, we insert item x into list Sj after position pj Example: insert key 15, with i = 2 Insertion +- 10 36 +- 23 23 +- S0 S1 S2 +- S0 S1 S2 S3 +- 10 362315 +- 15 +- 2315 p0 p1 p2 n nodes n/2 nodes in average n/4 nodes in average
- 35. Skip Lists 35 Deletion To remove an item with key x from a skip list, we proceed as follows: We search for x in the skip list and find the positions p0, p1 , …, pi of the items with key x, where position pj is in list Sj We remove positions p0, p1 , …, pi from the lists S0, S1, … , Si We remove all but one list containing only the two special keys Example: remove key 34 - +4512 - + 23 23- + S0 S1 S2 - + S0 S1 S2 S3 - +4512 23 34 - +34 - +23 34 p0 p1 p2
- 36. Skip Lists 36 Space Usage The space used by a skip list depends on the random bits used by each invocation of the insertion algorithm We use the following two basic probabilistic facts: Fact 1: The probability of getting i consecutive heads when flipping a coin is 1/2i Fact 2: If each of n items is present in a set with probability p, the expected size of the set is np Consider a skip list with n items By Fact 1, we insert an item in list Si with probability 1/2i By Fact 2, the expected size of list Si is n/2i The expected number of nodes used by the skip list is nnn n h h i i h i i 2 2 1 2 2 1 2 00 < -== == Thus, the expected space usage of a skip list with n items is O(n)
- 37. Skip Lists 37 Height The running time of the search an insertion algorithms is affected by the height h of the skip list We show that with high probability, a skip list with n items has height O(log n) We use the following additional probabilistic fact: Fact 3: If each of n events has probability p, the probability that at least one event occurs is at most np Consider a skip list with n items By Fact 1, we insert an item in list Si with probability 1/2i By Fact 3, the probability that list Si has at least one item is at most n/2i By picking i = 3log n, we have that the probability that S3log n has at least one item is at most n/23log n = n/n3 = 1/n2 Thus a skip list with n items has height at most 3log n with probability at least 1 - 1/n2
- 38. Search and Update Times The search time in a skip list is proportional to the sum of #drop-downs #scan-forwards #drop-downs Bounded by the height of the skip list O(log n) #scan-forwards Each scan forward bounded by nodes in an interval O(2) in average for each scan forward O(log n) overall. Thus the complexity for search in a skip list is O(log n) The analysis of insertion and deletion gives similar results Skip Lists 38
- 39. Skip Lists 39 Summary A skip list is a data structure for dictionaries that uses a randomized insertion algorithm In a skip list with n items The expected space used is O(n) The expected search, insertion and deletion time is O(log n) Using a more complex probabilistic analysis, one can show that these performance bounds also hold with high probability Skip lists are fast and simple to implement in practice
Editor's Notes
- #34: 二○一八年十月十六日